#%TITLE% getbeam.mac
#%NAME%
# Macros for optics alignment
#%DESCRIPTION%
# Includes macros for pslit, sslit and slitbox alignment and mono calibration.
# Includes also a menu (getbeam) to select and run alignment procedures.
#%END%
#%UU% ()
#%MDESC% Set all the motors and counters. Check if exist. Return -1 if any
#error.
def gb_setup() '{
if (gb_pslit() < 0) {
if (GB_USE["pslit"] == 0)
return(-1)
}
if (gb_u() < 0) {
if (GB_USE["undulator"] == 0)
return(-1)
}
if (gb_en() < 0) {
return(-1)
}
if (gb_calibfoils() < 0) {
if (GB_USE["foil"] == 0)
return(-1)
}
if (gb_sslit() < 0) {
if (GB_USE["sslit"] == 0)
return(-1)
}
}'
#%UU%
#%MDESC% Procedure to align the beam - primary slits, secondary slits. If all
#starts with calibrating the mono, then aligning the pslits and sslits.
def getbeam '{
local selection
#set the default & specific parameters
if (gb_setup() < 0)
exit
printf ("\n <OPTICS ALIGNMENT (getbeam)>\n")
while(1) {
printf ("\n Options:\n\n")
printf (" 1. Pslit alignment (OH)\n")
printf (" 2. Mono calibration (OH)\n")
printf (" 3. Sslit alignment (OH)\n")
printf (" 4. All (pslit+mono+sslit)\n")
printf (" 5. Mirror align menu (OH)\n" )
printf (" 6. Slitbox alignment (EH)\n\n" )
printf (" 0. Quit \n")
selection = getval(" select -> ", selection)
if (dark_current() == -1)
exit
if (selection == 1) {
pslit_align()
} else if (selection == 2) {
mono_calib()
} else if (selection == 3) {
sslit_align()
} else if (selection == 4) {
pslit_align()
mono_calib()
sslit_align()
} else if (selection == 5) {
mirror_align
} else if (selection == 6) {
slitbox_align()
} else if (selection == 0) {
gb_setfilters("empty")
break
}
}
}'
#%UU%()
#%MDESC% Align the primary slits to the centre of the beam. Return -1 if error.
def pslit_align() '{
local darkcur zeropos cnt
#save the slits positions
gb_save_positions()
cdef("cleanup_once","gb_pslit_cleanup\n","_gb_")
tty_cntl("md")
printf ("Aligning primary slits\n")
tty_cntl("me")
#close FE before moving filters to avoid moving them through the beam
feclose
#move the filters
gb_setfilters("pslit")
if (gb_checkfilters("pslit") == -1) {
printf("Filters cannot be set. Sorry. Giving up\n")
exit
}
if (GB_DARK_TAKEN == 0) {
if (dark_current() == -1)
exit
}
eval(sprintf("plotselect %s", GB_PSLIT_CTMNE))
local_ct_set "pslit"
darkcur = GB_DARK[GB_PSLIT_CTMNE]
printf("Dark current for %s is %f\n", GB_PSLIT_CTMNE, darkcur)
feopen
if (id_state() != 4) {
printf ("Frontend cannot open. Giving up\n")
exit
}
#zero gap
printf ("Looking for zero gap:\n")
#Opening moderately primary slits and wide secondary slits
printf("Opening primary slits\n")
printf ("Set secondary slits wide open\n")
gb_setslits("pslit", "gap")
## Finding zero for vertical gap
printf ("- VERTICAL GAP (finding zero)-\n")
cmd = sprintf ("dscan %s %g %g %d %g", GB_PSLIT_MOT["psu"], \
GB_PARAMS["first"]["start"], GB_PARAMS["first"]["stop"], \
GB_PARAMS["first"]["pts"], GB_PARAMS["first"]["ctime"])
eval (cmd)
zeropos = slit_find_zero(0.5, GB_PSLIT_CTMNE)
printf ("\t- moving %s to half height position %g\n", \
GB_PSLIT_MNE["psu"], zeropos)
A[GB_PSLIT_MOT["psu"]] = zeropos
move_em; waitmove; get_angles
cmd = sprintf ("dscan %s %g %g %d %g", GB_PSLIT_MOT["psd"], \
GB_PARAMS["second"]["start"], GB_PARAMS["second"]["stop"], \
GB_PARAMS["second"]["pts"], GB_PARAMS["second"]["ctime"])
eval (cmd)
zeropos = slit_find_zero(0.01, GB_PSLIT_CTMNE)
# TODO: check here for sensible results or quit
printf ("\t- moving %s to zero position %g\n", GB_PSLIT_MNE["psd"], zeropos)
A[GB_PSLIT_MOT["psd"]] = zeropos
move_em; waitmove; get_angles
printf ("Setting psvg to zero\n")
eval(sprintf("set %s 0", GB_PSLIT_MNE["psvg"]))
printf ("Opening psvg to 1\n")
A[GB_PSLIT_MOT["psvg"]] = 1
move_em; waitmove; get_angles
# Finding zero for horizontal gap
printf ("- HORIZONTAL GAP (finding zero)-\n")
cmd = sprintf ("dscan %s %g %g %d %g", GB_PSLIT_MOT["psr"], \
GB_PARAMS["first"]["start"], GB_PARAMS["first"]["stop"], \
GB_PARAMS["first"]["pts"], GB_PARAMS["first"]["ctime"])
eval (cmd)
zeropos = slit_find_zero(0.5, GB_PSLIT_CTMNE)
printf ("\t- moving %s to half height position %g\n", \
GB_PSLIT_MNE["psr"], zeropos)
A[GB_PSLIT_MOT["psr"]] = zeropos
move_em; waitmove; get_angles
cmd = sprintf ("dscan %s %g %g %d %g", GB_PSLIT_MOT["psl"], \
GB_PARAMS["second"]["start"], GB_PARAMS["second"]["stop"], \
GB_PARAMS["second"]["pts"], GB_PARAMS["second"]["ctime"])
eval (cmd)
zeropos = slit_find_zero(0.01, GB_PSLIT_CTMNE)
printf ("\t- moving %s to zero position %g\n", GB_PSLIT_MNE["psl"], zeropos)
A[GB_PSLIT_MOT["psl"]] = zeropos
move_em; waitmove; get_angles
printf ("Setting pshg to zero\n")
eval(sprintf("set %s 0", GB_PSLIT_MNE["pshg"]))
# Finding center for zero offset
# vertical offset
printf ("- VERTICAL OFFSET (finding center)-\n")
gb_setslits("pslit", "voffset")
cmd = sprintf ("dscan %s %g %g %d %g", GB_PSLIT_MOT["psvo"], \
GB_PARAMS["voffset"]["start"], GB_PARAMS["voffset"]["stop"], \
GB_PARAMS["voffset"]["pts"], GB_PARAMS["voffset"]["ctime"])
eval (cmd)
cnt = cnt_num(GB_PSLIT_CTMNE)
_plcom = array_op("com", \
SCAN_D[:NPTS-1][0],SCAN_D[:NPTS-1][cnt+1] - darkcur)
printf("Moving %s to center of mass %f\n", GB_PSLIT_MNE["psvo"], _plcom)
A[GB_PSLIT_MOT["psvo"]] = _plcom
move_em;waitmove;get_angles
printf ("\t- setting psvo to zero\n")
eval(sprintf("set %s 0", GB_PSLIT_MNE["psvo"]))
#horizontal offset
printf ("- HORIZONTAL OFFSET (finding center)-\n")
gb_setslits("pslit", "hoffset")
cmd = sprintf ("dscan %s %g %g %d %g", GB_PSLIT_MOT["psho"], \
GB_PARAMS["hoffset"]["start"], GB_PARAMS["hoffset"]["stop"], \
GB_PARAMS["hoffset"]["pts"], GB_PARAMS["hoffset"]["ctime"])
eval (cmd)
_plcom = array_op("cfwhm", \
SCAN_D[:NPTS-1][0],SCAN_D[:NPTS-1][cnt+1] - darkcur)
printf("Moving %s to FWHM %f\n", GB_PSLIT_MNE["psho"], _plcom)
A[GB_PSLIT_MOT["psho"]] = _plcom
move_em;waitmove;get_angles
printf ("\t- setting psho to zero\n")
eval(sprintf("set %s 0", GB_PSLIT_MNE["psho"]))
gb_restore_positions("pslit")
cdef("","","_gb_","delete")
return(0)
}'
#%UU% ()
#%MDESC% Align the secondary slits to the centre of the beam.
#Return -1 if error.
def sslit_align() '{
local darkcur zeropos cnt
gb_save_positions()
cdef("cleanup_once","gb_sslit_cleanup\n","_gb_")
tty_cntl("md")
printf ("Aligning secondary slits\n")
tty_cntl("me")
#close FE before moving filters to avoid moving them through the beam
feclose
#move the filters
gb_setfilters("sslit")
if (gb_checkfilters("sslit") == -1) {
printf("Filters cannot be set. Sorry. Giving up\n")
exit
}
if (GB_DARK_TAKEN == 0) {
if (dark_current() == -1)
exit
}
eval(sprintf("plotselect %s", GB_SSLIT_CTMNE))
local_ct_set "sslit"
darkcur = GB_DARK[GB_SSLIT_CTMNE]
printf("Dark current is %f\n", darkcur)
feopen
if (id_state() != 4 ) {
print "Frontend cannot open. Giving up"
exit
}
#zero gap
printf ("Looking for zero gap:\n")
#Opening moderately secondary slits and wide primary slits
printf("Opening primary and secondary slits\n")
gb_setslits("sslit", "gap")
## Finding zero for vertical gap
printf ("- VERTICAL GAP (finding zero)-\n")
cmd = sprintf ("dscan %s %g %g %d %g", GB_SSLIT_MOT["ssu"], \
GB_PARAMS["first"]["start"], GB_PARAMS["first"]["stop"], \
GB_PARAMS["first"]["pts"], GB_PARAMS["first"]["ctime"])
eval (cmd)
zeropos = slit_find_zero(0.5, GB_SSLIT_CTMNE)
printf ("\t - moving %s to half height position %g\n", \
GB_SSLIT_MNE["ssu"], zeropos)
A[GB_SSLIT_MOT["ssu"]] = zeropos
move_em; waitmove; get_angles
cmd = sprintf ("dscan %s %g %g %d %g", GB_PSLIT_MOT["ssd"], \
GB_PARAMS["second"]["start"], GB_PARAMS["second"]["stop"], \
GB_PARAMS["second"]["pts"], GB_PARAMS["second"]["ctime"])
eval (cmd)
zeropos = slit_find_zero(0.01, GB_SSLIT_CTMNE)
printf ("\t - moving %s to zero position %g\n", GB_SSLIT_MNE["ssd"], zeropos)
A[GB_SSLIT_MOT["ssd"]] = zeropos
move_em; waitmove; get_angles
printf ("Setting ssvg to zero\n")
eval(sprintf("set %s 0", GB_SSLIT_MNE["ssvg"]))
printf ("Opening ssvg to 1\n")
A[GB_SSLIT_MOT["ssvg"]] = 1
move_em; waitmove; get_angles
# Finding zero for horizontal gap
printf ("- HORIZONTAL GAP (finding zero)-\n")
cmd = sprintf ("dscan %s %g %g %d %g", GB_PSLIT_MOT["ssr"], \
GB_PARAMS["first"]["start"], GB_PARAMS["first"]["stop"], \
GB_PARAMS["first"]["pts"], GB_PARAMS["first"]["ctime"])
eval (cmd)
zeropos = slit_find_zero(0.5, GB_SSLIT_CTMNE)
printf ("\t - moving ssr to half height position %g\n", zeropos)
A[GB_SSLIT_MOT["ssr"]] = zeropos
move_em; waitmove; get_angles
cmd = sprintf ("dscan %s %g %g %d %g", GB_PSLIT_MOT["ssl"], \
GB_PARAMS["second"]["start"], GB_PARAMS["second"]["stop"], \
GB_PARAMS["second"]["pts"], GB_PARAMS["second"]["ctime"])
eval (cmd)
zeropos = slit_find_zero(0.01, GB_SSLIT_CTMNE)
printf ("\t - moving ssl to zero position %g\n", zeropos)
A[GB_SSLIT_MOT["ssl"]] = zeropos
move_em; waitmove; get_angles
printf ("Setting sshg to zero\n")
eval(sprintf("set %s 0", GB_SSLIT_MNE["sshg"]))
# Finding centre for zero offset
# vertical offset
printf ("- VERTICAL OFFSET (finding center)-\n")
gb_setslits("sslit", "voffset")
cmd = sprintf ("dscan %s %g %g %d %g", GB_PSLIT_MOT["ssvo"], \
GB_PARAMS["voffset"]["start"], GB_PARAMS["voffset"]["stop"], \
GB_PARAMS["voffset"]["pts"], GB_PARAMS["voffset"]["ctime"])
eval (cmd)
cnt = cnt_num(GB_SSLIT_CTMNE)
_plcom = array_op("com", \
SCAN_D[:NPTS-1][0],SCAN_D[:NPTS-1][cnt+1]-darkcur)
printf("Moving ssvo to center of mass %f\n", _plcom)
A[GB_SSLIT_MOT["ssvo"]] = _plcom
move_em;waitmove;get_angles
printf ("\t - setting ssvo to zero\n")
eval(sprintf("set %s 0", GB_SSLIT_MNE["ssvo"]))
#horizontal offset
printf ("- HORIZONTAL OFFSET (finding center)-\n")
gb_setslits("pslit", "hoffset")
cmd = sprintf ("dscan %s %g %g %d %g", GB_PSLIT_MOT["ssho"], \
GB_PARAMS["hoffset"]["start"], GB_PARAMS["hoffset"]["stop"], \
GB_PARAMS["hoffset"]["pts"], GB_PARAMS["hoffset"]["ctime"])
eval (cmd)
_plcom = array_op("cfwhm", \
SCAN_D[:NPTS-1][0],SCAN_D[:NPTS-1][cnt+1]-darkcur)
printf("Moving ssho to center of FWHM %f\n", _plcom)
A[GB_SSLIT_MOT["ssho"]] = _plcom
move_em;waitmove;get_angles
printf ("\t - setting ssvo to zero\n")
eval(sprintf("set %s 0", GB_SSLIT_MNE["ssho"]))
printf ("\t - FINISHED. Opening sshg to 3, ssvg to 1 \n")
A[GB_SSLIT_MOT["sshg"]] = 3.0
A[GB_SSLIT_MOT["ssvg"]] = 1.0
move_em;waitmove;get_angles
cdef("","","_gb_","delete")
return(0)
}'
#%IU% ()
#%MDESC% Save position of pslits, sslits and slitbox
def gb_save_positions() '{
global GB_SAVED
if (GB_USE["pslit"]) {
GB_SAVED["pslit"]["pshg"] = A[GB_PSLIT_MOT["pshg"]]
GB_SAVED["pslit"]["psvg"] = A[GB_PSLIT_MOT["psvg"]]
GB_SAVED["pslit"]["psho"] = A[GB_PSLIT_MOT["psho"]]
GB_SAVED["pslit"]["psvo"] = A[GB_PSLIT_MOT["psvo"]]
}
if (GB_USE["sslit"]) {
GB_SAVED["sslit"]["sshg"] = A[GB_SSLIT_MOT["sshg"]]
GB_SAVED["sslit"]["ssvg"] = A[GB_SSLIT_MOT["ssvg"]]
GB_SAVED["sslit"]["ssho"] = A[GB_SSLIT_MOT["ssho"]]
GB_SAVED["sslit"]["ssvo"] = A[GB_SSLIT_MOT["ssvo"]]
}
if (GB_USE["slitbox"]) {
GB_SAVED["slitbox"]["s1h"] = A[GB_SB_MOT["s1h"]]
GB_SAVED["slitbox"]["s1v"] = A[GB_SB_MOT["s1v"]]
GB_SAVED["slitbox"]["s2h"] = A[GB_SB_MOT["s2h"]]
GB_SAVED["slitbox"]["s2v"] = A[GB_SB_MOT["s2v"]]
}
}'
#%IU% (key)
#%MDESC% Restore all positions saved or a name set of it (%B%key%B% is set
#to pslit, sslit, slitbox )
def gb_restore_positions(key) '{
local motnum mne
printf("Restoring %s to saved positions.\n", key)
for (mne in GB_SAVED[key]) {
motnum = motor_num(mne)
A[motnum] = GB_SAVED[key][mne]
}
move_em; waitmove; get_angles
}'
#******** dark current ********
#%IU% ()
#%MDESC% Procedure to take the dark current. Returns 0 if OK, -1 if error.
def dark_current() '{
global GB_DARK GB_DARK_TAKEN
GB_DARK_TAKEN = 0
feclose
if (id_state() != 3 ) {
printf ("Frontend cannot open. Giving up dark current measuring.\n")
GB_DARK["dm2"] = -1
GB_DARK["i0"] = -1
return(-1)
}
GB_DARK["dm2"] = getdark(dm2,0.1,10)
GB_DARK["i0"] = getdark(i0,0.1,10)
GB_DARK_TAKEN = 1
return(0)
}'
#%IU%(cnt,cttime,iter)
#%MDESC% Get the dark current of a %B%cnt%B% WAGO counter, for %B%iter%B%
#iterations.
def getdark(cnt,cttime,iter) '{
local acum ai
acum = 0
for (ai=0;ai<iter;ai++) {
sleep(cttime)
wcreadct(WAGO_CTDEV[cnt],cnt)
acum += S[cnt]
}
return( acum/(iter+0.0) )
}'
#%IU%(cnt,cttime,iter)
#%MDESC% Get the dark current of a "VCT6 like" %B%cnt%B% counter, counting
#%B%cttime%B%, for %B%iter%B% iterations.
def getdarkct (cnt, cttime,iter) '{
local acum ai
acum = 0
for (ai=0;ai<iter;ai++) {
tcount(cttime); waitcount; getcounts
acum += S[cnt]
}
return( acum/(iter+0.0) )
}'
#******** end dark current ********
#******** filters procedures ********
#%IU% (key)
#%MDESC% Move the detectors and filters motors to the predefined positions
#as function of the %B%key%B% word (pslit, sslit, empty, mono ...).
def gb_setfilters(key) '{
local motmne motnum rcurr
global GB_FILTERS
printf("Moving filters to %s position\n",key)
if (key != "empty") {
#get the machine current to choose the right white beam attenuator
rcurr = _rc()
if (rcurr < 0) {
printf ("Cannot read the ring current, exiting...\n")
exit
}
}
if (gb_filters(key, rcurr) < 0)
exit
#Close front end before moving filters to avoid moving them through the beam
if (key != "empty")
feclose
waitmove; get_angles
for (motmne in GB_FILTERS[key]) {
if (motmne) {
motnum = motor_num(motmne)
if (motnum != -1) {
A[motnum] = GB_FILTERS[key][motmne]
}
} else {
print "Filter motor configuration is wrong. "
printf("Motor %s is not configured. Please check it.", motmne)
exit
}
}
move_em; waitmove; get_angles
}'
#%IU% (key)
#%MDESC% Check that detectors and filters motors are at predefined positions
# as function of the %B%key%B% word (pslit, sslit, empty...).
def gb_checkfilters(key) '{
local motmne motnum difpos
waitmove; get_angles
for (motmne in GB_FILTERS[key]) {
motnum = motor_num(motmne)
difpos = fabs( A[motnum] - GB_FILTERS[key])
if (motnum == -1 || difpos > 0.1 )
return (-1)
}
}'
#******** end filters procedures ********
#******** slits procedures ********
#%IU% (key)
#%MDESC% Set the primary and secondary slits predefined positions.
def gb_setslits(key, key2) '{
if (GB_USE[key] != -1) {
if (gb_positions(key, key2) < 0) {
eprintf ("Positions not set, nothing moved\n")
return(-1)
}
printf ("Moving mottors, please wait...\n")
move_em; waitmove; get_angles
}
}'
#%IU%(sfor,cnt)
#%MDESC%Find the min value position, using the %B%cnt%B% counter data and
#%B%sfor%B% treshold (e.g. sfor=0.5 gives the half height position).
def slit_find_zero(sfor,cnt) '{
local min max idxmin
local retpos seachfor
local float array avarr[(NPTS-1)/2][1]
cnt = cnt_num(cnt)
# contract the array by three to get averaging on every three points
avarr = array_op("contract", SCAN_D[0:NPTS-1][cnt+1],2)
max = array_op("max", avarr)
min = array_op("min", avarr)
seachfor = (max - min) * sfor + min
idxmin = array_op("i_<=_value", SCAN_D[0:NPTS-1][cnt+1],seachfor)
retpos = SCAN_D[idxmin-1][0]
return(retpos)
}'
#******** end slits procedures ********
#******** cleanup procedures ********
#%IU%
#%MDESC% Primaty slits cleanup part.
def gb_pslit_cleanup '{
feclose
gb_restore_positions("pslit")
gb_setfilters("empty")
}'
#%IU%
#%MDESC% Monochromator calibration cleanup
def gb_monocalib_cleanup '{
feclose
if (GB_USE["pslit"] != -1)
gb_restore_positions("pslit")
if (GB_USE["filter"] != -1)
gb_setfilters("empty")
}'
#%IU%
#%MDESC% Secondary slits cleanup part.
def gb_sslit_cleanup '{
feclose
gb_restore_positions("sslit")
gb_setfilters("empty")
}'
#******** end cleanup procedures ********
if (whatis("local_ct_set") == 0)
eval("def local_ct_set\'{ }\'")
if (whatis("_rc") == 0)
eval("def _rc()\'{ }\'")
#%MACROS%
#%IMACROS%
#%DEPENDENCIES% machinfo.mac getbeam_presets.mac monocalib.mac
#mirror_align.mac slitboxalign.mac
#%TOC%
#%AUTHOR% A.Beteva%BR%
#$Revision: 2.0 $$Date: 2013/05/31 09:31:26 $
#%END%
#%LOG%
#$Log: getbeam.mac,v $
#Revision 2.0 2013/05/31 09:31:26 beteva
#*** empty log message ***
#
#Revision 1.1 2005/08/31 08:20:58 beteva
#Initial revision
|