2175 lines
76 KiB
Python
Executable File
2175 lines
76 KiB
Python
Executable File
#! /usr/bin/env python
|
|
# Federica Marone, July 2, 2014
|
|
|
|
import time
|
|
import sys
|
|
import math
|
|
import os
|
|
import ca
|
|
import CaChannel
|
|
import xml.etree.ElementTree as ET
|
|
|
|
sys.path.append("/work/sls/bin")
|
|
|
|
from epicsPV import epicsPV
|
|
from epicsMotor import epicsMotor
|
|
from channelDefinition import *
|
|
|
|
CaChannel.CaChannel.ca_timeout = 3
|
|
# ------------------------ Functions -------------------------------------
|
|
def show_help():
|
|
print "Tomography macro"
|
|
print ""
|
|
print "USAGE"
|
|
print "Input parameters"
|
|
print " $0 = scanType"
|
|
print " tomography-scan.py <scanType>"
|
|
print ""
|
|
print "ARGUMENTS"
|
|
print " scanType Scan type"
|
|
print " 2 - Fast Scan Mode"
|
|
print " 5 - Fast Scan DPC Mode"
|
|
print " 6 - Snap&Snap Mode"
|
|
print " 7 - Snap&Step DPC Mode"
|
|
sys.exit()
|
|
|
|
def standardChannelDefinition(operationMode):
|
|
|
|
global chStorage,chFilePrefix, chUserID
|
|
global chServer,chEndstation
|
|
global chGo, chPause, chExperimentStatus, chCameraStatus
|
|
global chScanInterruption, chComputeSinograms
|
|
global chActualRotation, chScanTimeToGo
|
|
global chRoi, chExposure, chRotyMin, chRotyMax, chRotationAxisPosition
|
|
global chNumberOfDarks, chNumberOfFlats, chNumberOfProjections
|
|
global chXLinIn, chXLinOut, chTriggerDelay
|
|
|
|
if operationMode!=2:
|
|
chStorage=epicsPV('X02DA-SCAN-CAM1:STORAGE')
|
|
chFilePrefix=epicsPV('X02DA-SCAN-CAM1:FILPRE')
|
|
chServer=epicsPV("X02DA-ES1-CAM1:SERV_SEL")
|
|
chEndstation=epicsPV("X02DA-ES1-CAM1:ENDST_SEL")
|
|
chGo=epicsPV("X02DA-SCAN-SCN1:GO")
|
|
chPause=epicsPV("X02DA-SCAN-SCN1:PAUSE")
|
|
chExperimentStatus=epicsPV("X02DA-SCAN-SCN1:STATUS")
|
|
chCameraStatus=epicsPV("X02DA-SCAN-CAM1:STATUS")
|
|
chScanInterruption=epicsPV("X02DA-SCAN-SCN1:INTR")
|
|
chComputeSinograms=epicsPV("X02DA-SCAN-SCN1:SINO")
|
|
chUserID=epicsPV("X02DA-SCAN-SCN1:USERID")
|
|
chActualRotation=epicsPV("X02DA-SCAN-SCN1:ACTROT")
|
|
chScanTimeToGo=epicsPV("X02DA-SCAN-SCN1:SCNFINTME")
|
|
chRoi=epicsPV("X02DA-SCAN-CAM1:ROI")
|
|
chExposure=epicsPV("X02DA-SCAN-CAM1:EXPTME")
|
|
chRotyMin=epicsPV("X02DA-SCAN-SCN1:ROTSTA")
|
|
chRotyMax=epicsPV("X02DA-SCAN-SCN1:ROTSTO")
|
|
chRotationAxisPosition=epicsPV("X02DA-SCAN-SCN1:STITCH")
|
|
chNumberOfDarks=epicsPV("X02DA-SCAN-SCN1:NPPDRK")
|
|
chNumberOfFlats=epicsPV("X02DA-SCAN-SCN1:NPPFLT")
|
|
chNumberOfProjections=epicsPV("X02DA-SCAN-SCN1:NPRJ")
|
|
chXLinIn=epicsPV("X02DA-SCAN-SCN1:SMPIN")
|
|
chXLinOut=epicsPV("X02DA-SCAN-SCN1:SMPOUT")
|
|
chTriggerDelay=epicsPV("X02DA-SCAN-SCN1:TRIDEL")
|
|
else:
|
|
channelPrefix="X02DA-SOFTTEST-TEST"
|
|
chStorage=epicsPV(channelPrefix+":STORAGE")
|
|
chFilePrefix=epicsPV(channelPrefix+":FILPRE")
|
|
chServer=epicsPV(channelPrefix+":SERV_SEL")
|
|
chEndstation=epicsPV(channelPrefix+":ENDST_SEL")
|
|
chGo=epicsPV(channelPrefix+":GO")
|
|
chPause=epicsPV(channelPrefix+":PAUSE")
|
|
chExperimentStatus=epicsPV(channelPrefix+":STATUS")
|
|
chCameraStatus=epicsPV(channelPrefix+":STATUS")
|
|
chScanInterruption=epicsPV(channelPrefix+":INTR")
|
|
chComputeSinograms=epicsPV(channelPrefix+":SINO")
|
|
chUserID=epicsPV(channelPrefix+":USERID")
|
|
chActualRotation=epicsPV(channelPrefix+":ACTROT")
|
|
chScanTimeToGo=epicsPV(channelPrefix+":SCNFINTME")
|
|
chRoi=epicsPV(channelPrefix+":ROI")
|
|
chExposure=epicsPV(channelPrefix+":EXPTME")
|
|
chRotyMin=epicsPV(channelPrefix+":ROTSTA")
|
|
chRotyMax=epicsPV(channelPrefix+":ROTSTO")
|
|
chRotationAxisPosition=epicsPV(channelPrefix+":STITCH")
|
|
chNumberOfDarks=epicsPV(channelPrefix+":NPPDRK")
|
|
chNumberOfFlats=epicsPV(channelPrefix+":NPPFLT")
|
|
chNumberOfProjections=epicsPV(channelPrefix+":NPRJ")
|
|
chXLinIn=epicsPV(channelPrefix+":SMPIN")
|
|
chXLinOut=epicsPV(channelPrefix+":SMPOUT")
|
|
|
|
chGo.setMonitor()
|
|
chPause.setMonitor()
|
|
|
|
|
|
def cameraChannelDefinition(beamline,server):
|
|
|
|
global chCCDCAM_SET_PARAM
|
|
global chCCDCAM_RECMODE
|
|
global chCCDCAM_STOREMODE
|
|
global chCCDCAM_DELAY
|
|
global chCCDCAM_FILENR
|
|
global chCCDCAM_SAVESTOP
|
|
global chCCDCAM_SAVESTART
|
|
global chCCDCAM_CLEARMEM
|
|
global chCCDCAM_STATUSCODE
|
|
global chCCDCAM_CAMERA
|
|
global chCCDCAM_COCTIME
|
|
global chCCDCAM_TRIGGER
|
|
global chCCDCAM_ACQMODE
|
|
global chCCDCAM_FILEFORMAT
|
|
global chCCDCAM_EXPOSURE
|
|
global chCCDCAM_FILESAVEBUSY
|
|
global chCCDCAM_CAMPROGRESS
|
|
global chCCDCAM_FTRANSFER
|
|
global chCCDCAM_FTRANSFERSEVR
|
|
global chCCDCAM_FILEPATH
|
|
global chCCDCAM_FILEPATHSEVR
|
|
global chCCDCAM_FILEPATHSTAT
|
|
global chCCDCAM_FILENAME
|
|
global chCCDCAM_REGIONX_START
|
|
global chCCDCAM_REGIONX_END
|
|
global chCCDCAM_REGIONY_START
|
|
global chCCDCAM_REGIONY_END
|
|
global chCCDCAM_CCDTEMP
|
|
global chCCDCAM_HEIGHT
|
|
global chCCDCAM_WIDTH
|
|
global chCCDCAM_PIC_MAX
|
|
global chCCDCAM_PIC_BUFFER
|
|
global chCCDCAM_CAMRATE
|
|
global chCCDCAM_INIT
|
|
global chCCDCAM_HSSPEED
|
|
global chCCDCAM_TRANSFER
|
|
global chCCDCAM_FILERATE
|
|
global chCCDCAM_HWFILENR
|
|
global chCCDCAM_POWERTEMP
|
|
global chCCDCAM_ERRCODE
|
|
global chCCDCAM_WARNCODE
|
|
global chCCDCAM_CAMTEMP
|
|
global chCCDCAM_BUSY
|
|
|
|
chCCDCAM_SET_PARAM = epicsPV(beamline+"-"+server+":SET_PARAM")
|
|
chCCDCAM_RECMODE = epicsPV(beamline+"-"+server+":RECMODE")
|
|
chCCDCAM_STOREMODE = epicsPV(beamline+"-"+server+":STOREMODE")
|
|
chCCDCAM_DELAY = epicsPV(beamline+"-"+server+":DELAY")
|
|
chCCDCAM_FILENR = epicsPV(beamline+"-"+server+":FILENR")
|
|
chCCDCAM_SAVESTOP = epicsPV(beamline+"-"+server+":SAVESTOP")
|
|
chCCDCAM_SAVESTART = epicsPV(beamline+"-"+server+":SAVESTART")
|
|
chCCDCAM_CLEARMEM = epicsPV(beamline+"-"+server+":CLEARMEM")
|
|
chCCDCAM_CAMERA = epicsPV(beamline+"-"+server+":CAMERA")
|
|
chCCDCAM_COCTIME = epicsPV(beamline+"-"+server+":COCTIME")
|
|
chCCDCAM_TRIGGER = epicsPV(beamline+"-"+server+":TRIGGER")
|
|
chCCDCAM_ACQMODE = epicsPV(beamline+"-"+server+":ACQMODE")
|
|
chCCDCAM_FILEFORMAT = epicsPV(beamline+"-"+server+":FILEFORMAT")
|
|
chCCDCAM_EXPOSURE = epicsPV(beamline+"-"+server+":EXPOSURE")
|
|
# chCCDCAM_FILESAVEBUSY = epicsPV(beamline+"-"+server+":FILESAVEBUSY.RVAL")
|
|
chCCDCAM_FILESAVEBUSY = epicsPV(beamline+"-"+server+":FILESAVEBUSY")
|
|
chCCDCAM_CAMPROGRESS = epicsPV(beamline+"-"+server+":CAMPROGRESS")
|
|
chCCDCAM_FTRANSFER = epicsPV(beamline+"-"+server+":FTRANSFER")
|
|
chCCDCAM_FTRANSFERSEVR = epicsPV(beamline+"-"+server+":FTRANSFER.SEVR")
|
|
chCCDCAM_FILEPATH = epicsPV(beamline+"-"+server+":FILEPATH")
|
|
chCCDCAM_FILEPATHSEVR = epicsPV(beamline+"-"+server+":FILEPATH.SEVR")
|
|
chCCDCAM_FILEPATHSTAT = epicsPV(beamline+"-"+server+":FILEPATH.STAT")
|
|
chCCDCAM_FILENAME = epicsPV(beamline+"-"+server+":FILENAME")
|
|
chCCDCAM_REGIONX_START = epicsPV(beamline+"-"+server+":REGIONX_START")
|
|
chCCDCAM_REGIONX_END = epicsPV(beamline+"-"+server+":REGIONX_END")
|
|
chCCDCAM_REGIONY_START = epicsPV(beamline+"-"+server+":REGIONY_START")
|
|
chCCDCAM_REGIONY_END = epicsPV(beamline+"-"+server+":REGIONY_END")
|
|
|
|
# The following variables are not used for the moment but are listed for completeness
|
|
|
|
chCCDCAM_STATUSCODE = epicsPV(beamline+"-"+server+":STATUSCODE")
|
|
chCCDCAM_CCDTEMP = epicsPV(beamline+"-"+server+":CCDTEMP")
|
|
chCCDCAM_HEIGHT = epicsPV(beamline+"-"+server+":HEIGHT")
|
|
chCCDCAM_WIDTH = epicsPV(beamline+"-"+server+":WIDTH")
|
|
chCCDCAM_PIC_MAX = epicsPV(beamline+"-"+server+":PIC_MAX")
|
|
chCCDCAM_PIC_BUFFER = epicsPV(beamline+"-"+server+":PIC_BUFFER")
|
|
chCCDCAM_CAMRATE = epicsPV(beamline+"-"+server+":CAMRATE")
|
|
chCCDCAM_INIT = epicsPV(beamline+"-"+server+":INIT")
|
|
chCCDCAM_HSSPEED = epicsPV(beamline+"-"+server+":HSSPEED")
|
|
chCCDCAM_TRANSFER = epicsPV(beamline+"-"+server+":TRANSFER")
|
|
chCCDCAM_FILERATE = epicsPV(beamline+"-"+server+":FILERATE")
|
|
chCCDCAM_HWFILENR = epicsPV(beamline+"-"+server+":HWFILENR")
|
|
chCCDCAM_POWERTEMP = epicsPV(beamline+"-"+server+":POWERTEMP")
|
|
chCCDCAM_ERRCODE = epicsPV(beamline+"-"+server+":ERRCODE")
|
|
chCCDCAM_WARNCODE = epicsPV(beamline+"-"+server+":WARNCODE")
|
|
chCCDCAM_CAMTEMP = epicsPV(beamline+"-"+server+":CAMTEMP")
|
|
chCCDCAM_BUSY = epicsPV(beamline+"-"+server+":BUSY")
|
|
|
|
# Set monitors
|
|
|
|
chCCDCAM_FILESAVEBUSY.setMonitor()
|
|
chCCDCAM_CAMPROGRESS.setMonitor()
|
|
|
|
def rotationStageDefinition(rotationStage,endstationPrefix,beamline):
|
|
|
|
global chROT_SET_ABS, chROT_GET_POS, chROT_SVEL, chROT_GVEL, chROT_STOP, chROT_TWEAK, chROT_GACC
|
|
global chROT_SNAP_START, chROT_SNAP_OFFSET, chROT_DIRECT_MODE, chROT_STAB_TIME, chROT_REPETIONS
|
|
global chROT_PULSE_WIDTH, chROT_COUNTER, chROT_SNAP_READY, chROT_START, chROT_MOVE
|
|
global chSampleX, chSampleY, chSampleZ, chSampleXX, chSampleZZ, chMicroscopeX, chMicroscopeY, chMicroscopeZ
|
|
|
|
if rotationStage!="Aerotech" and rotationStage!="Micos":
|
|
print "The " + rotationStage + " rotation stage has not been implemented yet"
|
|
|
|
|
|
chROT_SET_ABS = epicsPV(beamline+"-"+endstationPrefix+"-SMP1:ROTYUSETP")
|
|
chROT_GET_POS = epicsPV(beamline+"-"+endstationPrefix+"-SMP1:ROTYUGETP")
|
|
chROT_GET_POS.setMonitor()
|
|
chROT_SVEL = epicsPV(beamline+"-"+endstationPrefix+"-SMP1:ROTYSETVE")
|
|
chROT_MOVE = epicsPV(beamline+"-"+endstationPrefix+"-SMP1:ROTYASTAT")
|
|
|
|
if rotationStage=="Aerotech":
|
|
|
|
chROT_STOP = epicsPV(beamline+"-"+endstationPrefix+"-SMP1:ROTYESTOP.PROC")
|
|
chROT_SNAP_START = epicsPV(beamline+"-"+endstationPrefix+"-SMP1:ROTYMSTART")
|
|
chROT_SNAP_OFFSET = epicsPV(beamline+"-"+endstationPrefix+"-SMP1:ROTYMOFFS")
|
|
chROT_DIRECT_MODE = epicsPV(beamline+"-"+endstationPrefix+"-SMP1:ROTY-DMODE")
|
|
chROT_STAB_TIME = epicsPV(beamline+"-"+endstationPrefix+"-SMP1:ROTYMTRIGDLY")
|
|
chROT_TWEAK = epicsPV(beamline+"-"+endstationPrefix+"-SMP1:ROTYMDIST")
|
|
chROT_REPETIONS = epicsPV(beamline+"-"+endstationPrefix+"-SMP1:ROTYMREP")
|
|
chROT_PULSE_WIDTH = epicsPV(beamline+"-"+endstationPrefix+"-SMP1:#ROTYPULSEON")
|
|
chROT_COUNTER = epicsPV(beamline+"-"+endstationPrefix+"-SMP1:ROTYSCNT")
|
|
chROT_SNAP_READY = epicsPV(beamline+"-"+endstationPrefix+"-SMP1:ROTY-M2READY.PROC")
|
|
chROT_START = epicsPV(beamline+"-"+endstationPrefix+"-SMP1:ROTY-M2START.PROC")
|
|
chROT_GVEL = epicsPV(beamline+"-"+endstationPrefix+"-SMP1:ROTYSETVE")
|
|
chROT_GACC = epicsPV(beamline+"-"+endstationPrefix+"-SMP1:ROTYSETAC")
|
|
|
|
chSampleX=epicsMotor("X02DA-ES1-SMP1:TRX")
|
|
chSampleY=epicsPV("X02DA-ES1-SMP1:TRY-VAL")
|
|
chSampleZ=epicsMotor("X02DA-ES1-SMP1:TRZ")
|
|
chSampleXX=epicsMotor("X02DA-ES1-SMP1:TRXX")
|
|
chSampleZZ=epicsMotor("X02DA-ES1-SMP1:TRZZ")
|
|
chMicroscopeX=epicsMotor("X02DA-ES1-MS1:TRX")
|
|
chMicroscopeY=epicsMotor("X02DA-ES1-MS1:TRY")
|
|
chMicroscopeZ=epicsMotor("X02DA-ES1-MS1:TRZ")
|
|
|
|
elif rotationStage=="Micos":
|
|
|
|
chROT_STOP = epicsPV(beamline+"-"+endstationPrefix+"-SMP1:ROTYSTOP.PROC")
|
|
chROT_TWEAK = epicsPV(beamline+"-"+endstationPrefix+"-SMP1:ROTYTWEAK")
|
|
chROT_GVEL = epicsPV(beamline+"-"+endstationPrefix+"-SMP1:ROTYGETVE")
|
|
chROT_GACC = epicsPV(beamline+"-"+endstationPrefix+"-SMP1:ROTYGETAC")
|
|
|
|
chSampleX=epicsMotor("X02DA-ES2-SMP1:TRX")
|
|
chSampleY=epicsPV("X02DA-ES2-SMP1:TRY-VAL")
|
|
chSampleZ=epicsMotor("X02DA-ES2-SMP1:TRZ")
|
|
chSampleXX=epicsMotor("X02DA-ES2-SMP1:TRXX")
|
|
chSampleZZ=epicsMotor("X02DA-ES2-SMP1:TRZZ")
|
|
chMicroscopeX=epicsMotor("X02DA-ES2-DET1:TRX")
|
|
chMicroscopeY=epicsMotor("X02DA-ES2-DET1:TRY")
|
|
chMicroscopeZ=epicsMotor("X02DA-ES2-DET1:TRZ")
|
|
|
|
def moveRotationWait(value):
|
|
|
|
poll=1
|
|
|
|
chROT_SET_ABS.putWait(value)
|
|
# To be sure that the rotation starts before I pull
|
|
time.sleep(1)
|
|
|
|
while (1):
|
|
movementDone = chROT_MOVE.getw(req_type=ca.DBF_STRING)
|
|
if movementDone!="MOVING" and movementDone!="1":
|
|
break
|
|
time.sleep(poll)
|
|
|
|
def checkpausestop_fast():
|
|
|
|
global scanInterruption, logFile
|
|
|
|
scanStatus=chGo.getw()
|
|
|
|
if scanStatus!=1:
|
|
|
|
FILE = open(logFile,"a")
|
|
FILE.write("SCAN HAS BEEN INTERRUPTED!!!!!\n")
|
|
FILE.close()
|
|
print "SCAN HAS BEEN INTERRUPTED!!!!!"
|
|
chCCDCAM_SAVESTOP.putWait(0)
|
|
chCameraStatus.putWait(0)
|
|
|
|
cameraSaveBusy=chCCDCAM_FILESAVEBUSY.getw()
|
|
while cameraSaveBusy==1:
|
|
cameraSaveBusy=chCCDCAM_FILESAVEBUSY.getw()
|
|
time.sleep(0.5)
|
|
|
|
chCCDCAM_CAMERA.putWait("OFF",req_type=ca.DBF_STRING)
|
|
chROT_STOP.putWait(0)
|
|
|
|
scanInterruption=1
|
|
chScanTimeToGo.putWait(0)
|
|
|
|
def checkpausestop_fast_dpc():
|
|
|
|
global scanInterruption
|
|
global scanPause
|
|
global logFile
|
|
|
|
# Abort scan if stop button is pressed!
|
|
|
|
scanStatus=chGo.getw()
|
|
|
|
if scanStatus!=1:
|
|
FILE = open(logFile,"a")
|
|
FILE.write("SCAN HAS BEEN INTERRUPTED!!!!!\n")
|
|
FILE.close()
|
|
print "SCAN HAS BEEN INTERRUPTED!!!!!"
|
|
chCCDCAM_SAVESTOP.putWait(0)
|
|
chCameraStatus.putWait(0)
|
|
|
|
cameraSaveBusy=chCCDCAM_FILESAVEBUSY.getw()
|
|
while cameraSaveBusy==1:
|
|
cameraSaveBusy=chCCDCAM_FILESAVEBUSY.getw()
|
|
time.sleep(0.5)
|
|
|
|
chCCDCAM_CAMERA.putWait("OFF",req_type=ca.DBF_STRING)
|
|
chROT_STOP.putWait(0)
|
|
|
|
scanInterruption=1
|
|
return
|
|
|
|
# Check if scan has been paused
|
|
|
|
pauseStatus=chPause.getw()
|
|
if pauseStatus!=0:
|
|
FILE = open(logFile,"a")
|
|
FILE.write("SCAN HAS BEEN PAUSED!!!!!\n")
|
|
FILE.close()
|
|
print "SCAN HAS BEEN PAUSED!!!"
|
|
chCCDCAM_SAVESTOP.putWait(0)
|
|
cameraSaveBusy=chCCDCAM_FILESAVEBUSY.getw()
|
|
while cameraSaveBusy==1:
|
|
cameraSaveBusy=chCCDCAM_FILESAVEBUSY.getw()
|
|
time.sleep(0.5)
|
|
|
|
chCCDCAM_CAMERA.putWait("OFF",req_type=ca.DBF_STRING)
|
|
chROT_STOP.putWait(0)
|
|
scanPause=1
|
|
|
|
while pauseStatus!=0 and scanStatus==1:
|
|
time.sleep(0.1)
|
|
pauseStatus=chPause.getw()
|
|
scanStatus=chGo.getw()
|
|
|
|
def snap_fifo():
|
|
|
|
global totalScanTime, logFile
|
|
|
|
# Let perform some checks for beam status
|
|
if operationMode==0:
|
|
ringCurrentStatus=chRingCurrentStatus.getw()
|
|
interlockStatus=chInterlockStatus.getw()
|
|
absorberStatus=chAbsorberStatus.getw()
|
|
else:
|
|
ringCurrentStatus=chRingCurrentStartFake.getw()
|
|
interlockStatus=0
|
|
absorberStatus=1
|
|
|
|
# Interrupt the scan if there is a beam dump, an optics interlock or the absorber has been closed
|
|
|
|
if ringCurrentStatus <= ringCurrentStart-0.05*ringCurrentStart:
|
|
FILE = open(logFile,"a")
|
|
FILE.write("Scan is going to be interrupted because of a beam dump!\n")
|
|
FILE.close()
|
|
print "Scan is going to be interrupted because of a beam dump!"
|
|
chGo.putWait(0)
|
|
if interlockStatus==1:
|
|
FILE = open(logFile,"a")
|
|
FILE.write("Scan is going to be interrupted because of an optics interlock!\n")
|
|
FILE.close()
|
|
print "Scan is going to be interrupted because of an optics interlock!"
|
|
chGo.putWait(0)
|
|
if absorberStatus==0:
|
|
FILE = open(logFile,"a")
|
|
FILE.write("Scan is going to be interrupted because the absorber has been closed!\n")
|
|
FILE.close()
|
|
print "Scan is going to be interrupted because the absorber has been closed!"
|
|
chGo.putWait(0)
|
|
|
|
# Start the camera
|
|
cameraStatus=chCCDCAM_CAMERA.getw(req_type=ca.DBF_STRING)
|
|
if cameraStatus=="OFF":
|
|
print "Starting the camera"
|
|
chCCDCAM_CAMERA.putWait("RUNNING",req_type=ca.DBF_STRING)
|
|
time.sleep(5)
|
|
chCCDCAM_FTRANSFER.putWait(1)
|
|
|
|
cameraProgress=chCCDCAM_CAMPROGRESS.getw()
|
|
cameraSaveBusy=chCCDCAM_FILESAVEBUSY.getw()
|
|
|
|
while cameraSaveBusy==1:
|
|
|
|
if operationMode==0:
|
|
ringCurrentStatus=chRingCurrentStatus.getw()
|
|
interlockStatus=chInterlockStatus.getw()
|
|
absorberStatus=chAbsorberStatus.getw()
|
|
else:
|
|
ringCurrentStatus=chRingCurrentStartFake.getw()
|
|
interlockStatus=0
|
|
absorberStatus=1
|
|
|
|
# Interrupt the scan if there is a beam dump, an optics interlock or the absorber has been closed
|
|
|
|
if ringCurrentStatus <= ringCurrentStart-0.05*ringCurrentStart:
|
|
FILE = open(logFile,"a")
|
|
FILE.write("Scan is going to be interrupted because of a beam dump!\n")
|
|
FILE.close()
|
|
print "Scan is going to be interrupted because of a beam dump!"
|
|
chGo.putWait(0)
|
|
if interlockStatus==1:
|
|
FILE = open(logFile,"a")
|
|
FILE.write("Scan is going to be interrupted because of an optics interlock!\n")
|
|
FILE.close()
|
|
print "Scan is going to be interrupted because of an optics interlock!"
|
|
chGo.putWait(0)
|
|
if absorberStatus==0:
|
|
FILE = open(logFile,"a")
|
|
FILE.write("Scan is going to be interrupted because the absorber has been closed!\n")
|
|
FILE.close()
|
|
print "Scan is going to be interrupted because the absorber has been closed!"
|
|
chGo.putWait(0)
|
|
|
|
checkpausestop_fast()
|
|
|
|
cameraProgress=chCCDCAM_CAMPROGRESS.getw()
|
|
cameraSaveBusy=chCCDCAM_FILESAVEBUSY.getw()
|
|
print "Acquiring projections ... %2.2f" % cameraProgress + "% ... done"
|
|
|
|
if rotyMax!=rotyMin:
|
|
currentAngle=chROT_GET_POS.getw()
|
|
timeToGo=totalScanTime*(1-((currentAngle-rotyMin)/(rotyMax-rotyMin)))
|
|
currentRotation=((currentAngle-rotyMin)/(rotyMax-rotyMin))
|
|
if currentRotation>=0:
|
|
chActualRotation.putWait(currentRotation)
|
|
else:
|
|
chActualRotation.putWait(0)
|
|
if math.fabs(currentAngle-rotyMin)>1e-4:
|
|
chScanTimeToGo.putWait(timeToGo)
|
|
|
|
time.sleep(2)
|
|
|
|
chCCDCAM_CAMERA.putWait("OFF",req_type=ca.DBF_STRING)
|
|
chCameraStatus.putWait("Idle")
|
|
|
|
def snap_dpc():
|
|
|
|
global scanPause
|
|
global totalScanTime
|
|
global NSteps, iPhase
|
|
|
|
beamDump=0
|
|
# Let perform some checks for beam status
|
|
if operationMode==0:
|
|
ringCurrentStatus=chRingCurrentStatus.getw()
|
|
interlockStatus=chInterlockStatus.getw()
|
|
absorberStatus=chAbsorberStatus.getw()
|
|
else:
|
|
ringCurrentStatus=chRingCurrentStartFake.getw()
|
|
interlockStatus=0
|
|
absorberStatus=1
|
|
|
|
# Check for a beam dump, an optics interlock or a closed absorber
|
|
|
|
scanStatus=chGo.getw()
|
|
|
|
while (ringCurrentStatus <= ringCurrentStart-0.05*ringCurrentStart or interlockStatus==1 or absorberStatus==0) and scanStatus==1:
|
|
|
|
if scanPause!=1:
|
|
scanPause=1
|
|
chPause.putWait(1)
|
|
|
|
chCCDCAM_SAVESTOP.putWait(0)
|
|
cameraSaveBusy=chCCDCAM_FILESAVEBUSY.getw()
|
|
while cameraSaveBusy==1:
|
|
cameraSaveBusy=chCCDCAM_FILESAVEBUSY.getw()
|
|
time.sleep(0.5)
|
|
|
|
chCCDCAM_CAMERA.putWait("OFF",req_type=ca.DBF_STRING)
|
|
chROT_STOP.putWait(0)
|
|
|
|
if operationMode==0:
|
|
ringCurrentStatus=chRingCurrentStatus.getw()
|
|
interlockStatus=chInterlockStatus.getw()
|
|
absorberStatus=chAbsorberStatus.getw()
|
|
else:
|
|
ringCurrentStatus=chRingCurrentStartFake.getw()
|
|
interlockStatus=0
|
|
absorberStatus=1
|
|
|
|
beamDump=1
|
|
scanStatus=chGo.getw()
|
|
|
|
|
|
if ringCurrentStatus >= ringCurrentStart-0.05*ringCurrentStart and interlockStatus==0 and absorberStatus==0:
|
|
|
|
FILE = open(logFile,"a")
|
|
FILE.write("The absorber has been closed by the interlock!!!\n")
|
|
FILE.close()
|
|
print "The absorber has been closed by the interlock!!!"
|
|
chAbsorberStatus.putWait(1)
|
|
FILE = open(logFile,"a")
|
|
FILE.write("Waiting for 10s for thermal compenstaion after the absorber has been opened ...\n")
|
|
FILE.close()
|
|
print "Waiting for 10s for thermal compenstaion after the absorber has been opened ..."
|
|
time.sleep(10)
|
|
|
|
if beamDump==1:
|
|
chPause.putWait(0)
|
|
beamDump=0
|
|
|
|
checkpausestop_fast_dpc()
|
|
|
|
if scanPause!=1:
|
|
|
|
# Start the camera
|
|
cameraStatus=chCCDCAM_CAMERA.getw(req_type=ca.DBF_STRING)
|
|
if cameraStatus=="OFF":
|
|
print "Starting the camera"
|
|
chCCDCAM_CAMERA.putWait("RUNNING",req_type=ca.DBF_STRING)
|
|
chCCDCAM_FTRANSFER.putWait(1)
|
|
|
|
cameraProgress=chCCDCAM_CAMPROGRESS.getw()
|
|
cameraSaveBusy=chCCDCAM_FILESAVEBUSY.getw()
|
|
|
|
while cameraSaveBusy==1:
|
|
|
|
if operationMode==0:
|
|
ringCurrentStatus=chRingCurrentStatus.getw()
|
|
interlockStatus=chInterlockStatus.getw()
|
|
absorberStatus=chAbsorberStatus.getw()
|
|
else:
|
|
ringCurrentStatus=chRingCurrentStartFake.getw()
|
|
interlockStatus=0
|
|
absorberStatus=1
|
|
|
|
# Check for a beam dump, an optics interlock or a closed absorber
|
|
|
|
scanStatus=chGo.getw()
|
|
|
|
while (ringCurrentStatus <= ringCurrentStart-0.05*ringCurrentStart or interlockStatus==1 or absorberStatus==0) and scanStatus==1:
|
|
|
|
if scanPause!=1:
|
|
scanPause=1
|
|
chPause.putWait(1)
|
|
chCCDCAM_SAVESTOP.putWait(0)
|
|
cameraSaveBusy=chCCDCAM_FILESAVEBUSY.getw()
|
|
while cameraSaveBusy==1:
|
|
cameraSaveBusy=chCCDCAM_FILESAVEBUSY.getw()
|
|
time.sleep(0.5)
|
|
|
|
chCCDCAM_CAMERA.putWait("OFF",req_type=ca.DBF_STRING)
|
|
chROT_STOP.putWait(0)
|
|
|
|
if operationMode==0:
|
|
ringCurrentStatus=chRingCurrentStatus.getw()
|
|
interlockStatus=chInterlockStatus.getw()
|
|
absorberStatus=chAbsorberStatus.getw()
|
|
else:
|
|
ringCurrentStatus=chRingCurrentStartFake.getw()
|
|
interlockStatus=0
|
|
absorberStatus=1
|
|
|
|
beamDump=1
|
|
scanStatus=chGo.getw()
|
|
|
|
|
|
if ringCurrentStatus >= ringCurrentStart-0.05*ringCurrentStart and interlockStatus==0 and absorberStatus==0:
|
|
|
|
FILE = open(logFile,"a")
|
|
FILE.write("The absorber has been closed by the interlock!!!\n")
|
|
FILE.close()
|
|
print "The absorber has been closed by the interlock!!!"
|
|
chAbsorberStatus.putWait(1)
|
|
FILE = open(logFile,"a")
|
|
FILE.write("Waiting for 10s for thermal compenstaion after the absorber has been opened ...\n")
|
|
FILE.close()
|
|
print "Waiting for 10s for thermal compenstaion after the absorber has been opened ..."
|
|
time.sleep(10)
|
|
|
|
if beamDump==1:
|
|
chPause.putWait(0)
|
|
beamDump=0
|
|
|
|
checkpausestop_fast_dpc()
|
|
|
|
cameraProgress=chCCDCAM_CAMPROGRESS.getw()
|
|
cameraSaveBusy=chCCDCAM_FILESAVEBUSY.getw()
|
|
print "Acquiring projections ... %2.2f" % cameraProgress + "% ... done"
|
|
|
|
if rotyMax!=rotyMin:
|
|
currentAngle=chROT_GET_POS.getw()
|
|
timeToGo=totalScanTime*(1-((currentAngle-rotyMin)/(rotyMax-rotyMin)))+totalScanTime*(NSteps-iPhase-1)
|
|
chScanTimeToGo.putWait(timeToGo)
|
|
|
|
time.sleep(2)
|
|
|
|
chCCDCAM_CAMERA.putWait("OFF",req_type=ca.DBF_STRING)
|
|
chCameraStatus.putWait("Idle")
|
|
|
|
def fasttomoscan(rotyMin,rotyMax,numberOfProjections,exposure,xLinIn,xLinOut,numberOfDarks,numberOfFlats,crystal1Pitch,scanType,millisecondShutter,rotationStage):
|
|
|
|
global scanInterruption
|
|
global totalScanTime
|
|
global logFile,sampleTifPath,logPath,databaseFile
|
|
|
|
scanInterruption=0
|
|
|
|
# Set the scan status flag to running
|
|
chExperimentStatus.putWait("Running")
|
|
print "TOMOGRAPHIC SCAN STARTED!!!"
|
|
FILE = open(logFile,"a")
|
|
FILE.write("TOMOGRAPHIC SCAN STARTED!!!\n")
|
|
FILE.close()
|
|
|
|
# Set scan type to continuous mode (just in case)
|
|
if rotationStage=="Micos":
|
|
chScanType.putWait(0)
|
|
|
|
# Setting file format
|
|
chCCDCAM_FILEFORMAT.putWait("TIFF")
|
|
|
|
baseRotySpeed=chROT_GVEL.getw()
|
|
|
|
# Select FIFO mode
|
|
chCCDCAM_STOREMODE.putWait("FIFO Buffer")
|
|
print "Fifo mode ON"
|
|
chCCDCAM_RECMODE.putWait("Sequence")
|
|
chCCDCAM_ACQMODE.putWait("Auto")
|
|
chCCDCAM_TRIGGER.putWait("auto trigger")
|
|
if scanType=="6":
|
|
chCCDCAM_DELAY.putWait(0)
|
|
chCCDCAM_SET_PARAM.putWait("SET")
|
|
|
|
# This is to make the camera run with the correct settings
|
|
# TODO do I need this??? Maybe for the COCTIME???
|
|
#chCCDCAM_CLEARMEM.putWait("CLEAR")
|
|
#chCCDCAM_CAMERA.putWait("RUNNING",req_type=ca.DBF_STRING)
|
|
#time.sleep(1)
|
|
#chCCDCAM_CAMERA.putWait("OFF",req_type=ca.DBF_STRING)
|
|
chCCDCAM_CLEARMEM.putWait("CLEAR")
|
|
|
|
ccdFrameTime=chCCDCAM_COCTIME.getw()
|
|
|
|
# Angular increment
|
|
deltaRot=rotyMax-rotyMin
|
|
if numberOfProjections!=0:
|
|
angularIncrement=deltaRot/(numberOfProjections-1)
|
|
else:
|
|
angularIncrement=0
|
|
|
|
if scanType=="6":
|
|
chROT_TWEAK.putWait(angularIncrement)
|
|
if rotationStage=="Micos":
|
|
systemOffset=chSystemOffset.getw()
|
|
systemTime=systemOffset+(rotyMax-rotyMin)*1000/((numberOfProjections-1)*baseRotySpeed)
|
|
systemTimeForFlats=systemOffset
|
|
delay=systemTime+exposure-ccdFrameTime
|
|
delayForFlats=systemTimeForFlats+exposure-ccdFrameTime
|
|
totalScanTime=numberOfProjections*(exposure+systemTime)/1000
|
|
else:
|
|
stabilizationTime=chROT_STAB_TIME.getw()
|
|
print "Stabilization time " + str(stabilizationTime) + " ms"
|
|
totalScanTime=numberOfProjections*(ccdFrameTime+stabilizationTime)/1000
|
|
elif scanType=="2":
|
|
totalScanTime=numberOfProjections*ccdFrameTime/1000
|
|
else:
|
|
print "This scan type has not been implemented yet!"
|
|
sys.exit()
|
|
|
|
print "Total scan time " + str(totalScanTime) + " s"
|
|
|
|
if deltaRot!=0 and scanType=="2":
|
|
rotySpeed=deltaRot/((numberOfProjections-1)*ccdFrameTime)*1000
|
|
else:
|
|
rotySpeed=baseRotySpeed
|
|
|
|
rotationAcceleration=chROT_GACC.getw()
|
|
print "Acceleration " + str(rotationAcceleration)
|
|
accelerationAngle=rotySpeed*rotySpeed/rotationAcceleration
|
|
waitingTime=math.fabs(rotySpeed)/rotationAcceleration
|
|
if waitingTime <= 0.2999:
|
|
waitingTime=0.3
|
|
|
|
if deltaRot!=0:
|
|
if scanType=="2":
|
|
rotationStart=rotyMin-rotySpeed*waitingTime-accelerationAngle
|
|
rotationStop=rotationStart+deltaRot+2*(rotySpeed*waitingTime+accelerationAngle)
|
|
elif scanType=="6":
|
|
rotationStart=rotyMin-angularIncrement
|
|
rotationStop=rotyMax
|
|
else:
|
|
print "This scan type has not been implemented yet!"
|
|
sys.exit()
|
|
|
|
else:
|
|
rotationStart=rotyMin
|
|
rotationStop=rotyMax
|
|
|
|
print "Expected frame time " + str(ccdFrameTime) + " ms"
|
|
print "Angular scan: " + str(deltaRot) + " degrees"
|
|
print "Rotation speed (angle/s): " + str(math.fabs(rotySpeed))
|
|
print "Base rotation speed (angle/s): " + str(baseRotySpeed)
|
|
print "Start position: " + str(rotationStart)
|
|
print "Acceleration angle: " + str(accelerationAngle)
|
|
print "End position: " + str(rotationStop)
|
|
|
|
if numberOfDarks>0:
|
|
###################### Acquire dark images #################################
|
|
|
|
print "\033[1m" ## bold
|
|
print "Acquiring dark images"
|
|
print "\033[0m" ## back to normal
|
|
|
|
print "Move to start position"
|
|
print "Move rotation axis to: " + str(rotationStart)
|
|
chROT_SVEL.putWait(baseRotySpeed)
|
|
moveRotationWait(rotationStart)
|
|
|
|
# Closing filter for dark acquisition
|
|
if operationMode!=2:
|
|
if crystal1Pitch>-100:
|
|
print "Dump the beam by moving OP-FILTER 4 at -22.0 mm ..."
|
|
chOPFilter4.move(-22)
|
|
else:
|
|
print "Dump the beam by moving OP-FILTER 4 at -12.0 mm ..."
|
|
chOPFilter4.move(-12)
|
|
chOPFilter4.wait(poll=1)
|
|
else:
|
|
if crystal1Pitch>-100:
|
|
print "Dump the beam by moving OP-FILTER 4 at -22.0 mm ..."
|
|
else:
|
|
print "Dump the beam by moving OP-FILTER 4 at -12.0 mm ..."
|
|
|
|
print "Wait for afterglow ..."
|
|
print "Done!"
|
|
|
|
# Set the channel of the tomography panel
|
|
chCameraStatus.putWait("Acquiring")
|
|
|
|
# Clear buffer
|
|
chCCDCAM_CLEARMEM.putWait("CLEAR")
|
|
|
|
print "Saving dark images 1-" + str(int(numberOfDarks))
|
|
chCCDCAM_FILENR.putWait(1)
|
|
chCCDCAM_SAVESTART.putWait(1)
|
|
chCCDCAM_SAVESTOP.putWait(int(numberOfDarks))
|
|
|
|
# Triggering the CCD acquisition sequence
|
|
print "Send trigger to the camera"
|
|
snap_fifo()
|
|
|
|
chCameraStatus.putWait("Idle")
|
|
print "Darks acquisition done!"
|
|
|
|
if numberOfFlats>0:
|
|
#################### Acquire pre flats ########################################
|
|
|
|
if scanInterruption==0:
|
|
|
|
print "\033[1m" ## bold
|
|
print "Acquiring pre-flat images"
|
|
print "\033[0m" ## back to normal
|
|
|
|
print "Moving the sample out of beam ..."
|
|
chSampleX.move(xLinOut)
|
|
chSampleX.wait(poll=1)
|
|
|
|
# Opening the shutter
|
|
if operationMode!=2:
|
|
chOPFilter4.move(0);chOPFilter4.wait(poll=1)
|
|
print "Moving up the filter OP-FILTER 4 at 0.0 mm ..."
|
|
time.sleep(3)
|
|
|
|
moveRotationWait(rotationStart)
|
|
|
|
if scanType=="6":
|
|
if millisecondShutter=="Cam-Ctrl":
|
|
if rotationStage=="Micos":
|
|
chCCDCAM_DELAY.putWait(delayForFlats)
|
|
else:
|
|
chCCDCAM_DELAY.putWait(stabilizationTime)
|
|
chCCDCAM_SET_PARAM.putWait("SET")
|
|
|
|
# Set the channel of the tomography panel
|
|
chCameraStatus.putWait("Acquiring")
|
|
|
|
# Clear buffer
|
|
chCCDCAM_CLEARMEM.putWait("CLEAR")
|
|
|
|
print "Saving pre flats images " + str(int(numberOfDarks+1)) + "-" + str(int(numberOfDarks+numberOfFlats))
|
|
chCCDCAM_FILENR.putWait(numberOfDarks+1)
|
|
chCCDCAM_SAVESTART.putWait(1)
|
|
chCCDCAM_SAVESTOP.putWait(numberOfFlats)
|
|
|
|
# Triggering the CCD acquisition sequence
|
|
print "Send trigger to the camera"
|
|
snap_fifo()
|
|
|
|
chCameraStatus.putWait("Idle")
|
|
print "Pre flats acquisition done!"
|
|
|
|
if scanType=="6":
|
|
if millisecondShutter=="Cam-Ctrl":
|
|
chCCDCAM_DELAY.putWait(0)
|
|
chCCDCAM_SET_PARAM.putWait("SET")
|
|
|
|
################## Acquire projection images ########################################
|
|
|
|
if scanInterruption==0:
|
|
|
|
print "\033[1m" ## bold
|
|
print "Acquiring projections"
|
|
print "\033[0m" ## back to normal
|
|
|
|
if numberOfFlats==0:
|
|
|
|
if operationMode!=2:
|
|
# Opening the shutter
|
|
chOPFilter4.move(0);chOPFilter4.wait(poll=1)
|
|
print "Moving up the filter OP-FILTER 4 at 0.0 mm ..."
|
|
time.sleep(3)
|
|
|
|
print "Saving projection images " + str(int(numberOfDarks+numberOfFlats+1)) + "-" + str(int(numberOfDarks+numberOfFlats+numberOfProjections))
|
|
chCCDCAM_FILENR.putWait(numberOfDarks+numberOfFlats+1)
|
|
chCCDCAM_SAVESTART.putWait(1)
|
|
chCCDCAM_SAVESTOP.putWait(numberOfProjections)
|
|
|
|
print "Moving the sample in the beam ..."
|
|
chSampleX.move(xLinIn);chSampleX.wait(poll=1)
|
|
|
|
if scanType=="2":
|
|
print "Set the speed to: " + str(math.fabs(rotySpeed))
|
|
if rotationStage=="Aerotech":
|
|
chROT_STOP.putWait(0)
|
|
chROT_SVEL.putWait(math.fabs(rotySpeed))
|
|
|
|
# Clear buffer
|
|
chCCDCAM_CLEARMEM.putWait("CLEAR")
|
|
|
|
if scanType=="6":
|
|
if rotationStage=="Micos":
|
|
chScanType.putWait(1)
|
|
chCCDCAM_DELAY.putWait(delay)
|
|
chCCDCAM_SET_PARAM.putWait("SET")
|
|
else:
|
|
chBoxModeSelection.putWait("Snap\'n\'Step")
|
|
chROT_GACC.putWait(500)
|
|
chROT_TWEAK.putWait(angularIncrement)
|
|
chROT_SNAP_START.putWait(rotationStart)
|
|
chROT_REPETIONS.putWait(numberOfProjections)
|
|
chROT_PULSE_WIDTH.putWait(1000)
|
|
chROT_SNAP_READY.putWait(1)
|
|
chROT_COUNTER.putWait(0)
|
|
chCCDCAM_TRIGGER.putWait("ext.exp sfttrg")
|
|
chCCDCAM_SET_PARAM.putWait("SET")
|
|
time.sleep(1)
|
|
chCCDCAM_CAMERA.putWait("RUNNING")
|
|
|
|
# Set the channel of the tomography panel
|
|
chCameraStatus.putWait("Acquiring")
|
|
|
|
print "Rotation starts"
|
|
if scanType=="2":
|
|
chROT_SET_ABS.putWait(rotationStop)
|
|
else:
|
|
if rotationStage=="Aerotech":
|
|
chROT_START.putWait(1)
|
|
|
|
print "Send trigger to the camera"
|
|
snap_fifo()
|
|
|
|
chCameraStatus.putWait("Idle")
|
|
|
|
if scanType=="6" and rotationStage=="Aerotech":
|
|
|
|
chBoxModeSelection.putWait("Custom")
|
|
chROT_GACC.putWait(rotationAcceleration)
|
|
chROT_DIRECT_MODE.putWait(1)
|
|
chCCDCAM_TRIGGER.putWait("auto trigger")
|
|
chCCDCAM_SET_PARAM.putWait("SET")
|
|
|
|
if scanInterruption==0:
|
|
print "Projection acquisition done!"
|
|
|
|
if numberOfFlats>0:
|
|
##################### Acquire post flats #############################################
|
|
|
|
if scanInterruption==0:
|
|
|
|
chROT_STOP.putWait(0)
|
|
chROT_SVEL.putWait(baseRotySpeed)
|
|
|
|
if rotationStage=="Micos":
|
|
chScanType.putWait(0)
|
|
print "Move Rotation to " + str(rotyMin)
|
|
moveRotationWait(rotyMin)
|
|
|
|
print "\033[1m" ## bold
|
|
print "Acquiring post-flat images"
|
|
print "\033[0m" ## back to normal
|
|
|
|
print "Moving the sample out of beam ..."
|
|
chSampleX.move(xLinOut)
|
|
chSampleX.wait(poll=1)
|
|
|
|
if scanType=="6":
|
|
if rotationStage=="Micos":
|
|
chScanType.putWait(0)
|
|
chCCDCAM_DELAY.putWait(delayForFlats)
|
|
else:
|
|
if millisecondShutter=="Cam-Ctrl":
|
|
chCCDCAM_DELAY.putWait(stabilizationTime)
|
|
chCCDCAM_SET_PARAM.putWait("SET")
|
|
|
|
print "Saving post flat images " + str(int(numberOfDarks+numberOfFlats+numberOfProjections+1)) + "-" + str(int(numberOfDarks+2*numberOfFlats+numberOfProjections))
|
|
chCCDCAM_FILENR.putWait(numberOfDarks+numberOfFlats+numberOfProjections+1)
|
|
chCCDCAM_SAVESTART.putWait(1)
|
|
chCCDCAM_SAVESTOP.putWait(numberOfFlats)
|
|
|
|
# Clear buffer
|
|
chCCDCAM_CLEARMEM.putWait("CLEAR")
|
|
|
|
# Set the channel of the tomography panel
|
|
chCameraStatus.putWait("Acquiring")
|
|
|
|
print "Send trigger to the camera"
|
|
snap_fifo()
|
|
|
|
chCameraStatus.putWait("Idle")
|
|
print "Post flats acquisition done!"
|
|
|
|
if scanType=="6":
|
|
if millisecondShutter=="Cam-Ctrl":
|
|
chCCDCAM_DELAY.putWait(0)
|
|
chCCDCAM_SET_PARAM.putWait("SET")
|
|
|
|
print "Moving back to initial conditions ..."
|
|
|
|
if scanInterruption==0:
|
|
chComputeSinograms.putWait(1)
|
|
|
|
# Close the shutter and put sample back!
|
|
|
|
if operationMode!=2:
|
|
if crystal1Pitch>-100:
|
|
print "Dump the beam by moving OP_FILTER 4 to -22.0 mm ..."
|
|
chOPFilter4.move(-22);chOPFilter4.wait(poll=1)
|
|
else:
|
|
print "Dump the beam by moving OP_FILTER 4 to -12.0 mm ..."
|
|
chOPFilter4.move(-12);chOPFilter4.wait(poll=1)
|
|
else:
|
|
if crystal1Pitch>-100:
|
|
print "Dump the beam by moving OP_FILTER 4 to -22.0 mm ..."
|
|
else:
|
|
print "Dump the beam by moving OP_FILTER 4 to -12.0 mm ..."
|
|
|
|
|
|
print "Set rotation speed back to " + str(baseRotySpeed)
|
|
#if rotationStage=="Aerotech":
|
|
chROT_STOP.putWait(0)
|
|
chROT_SVEL.putWait(baseRotySpeed)
|
|
|
|
if rotationStage=="Micos":
|
|
chScanType.putWait(0)
|
|
print "Move Rotation to " + str(rotyMin)
|
|
moveRotationWait(rotyMin)
|
|
if numberOfFlats>0:
|
|
print "Moving the sample out of beam ..."
|
|
chSampleX.move(xLinOut);chSampleX.wait(poll=1)
|
|
|
|
chScanTimeToGo.putWait(0)
|
|
|
|
if scanType=="6" and rotationStage=="Aerotech":
|
|
chBoxModeSelection.putWait("Custom")
|
|
chROT_GACC.putWait(rotationAcceleration)
|
|
chROT_DIRECT_MODE.putWait(1)
|
|
chCCDCAM_TRIGGER.putWait("auto trigger")
|
|
chROT_COUNTER.putWait(0)
|
|
|
|
FILE = open(logFile,"a")
|
|
FILE.write("TOMOGRAPHIC SCAN FINISHED at " + str(time.asctime(time.localtime(time.time())))+"\n")
|
|
FILE.close()
|
|
|
|
# Logging
|
|
tree = ET.parse(databaseFile)
|
|
sample = tree.getroot()
|
|
scan = sample.find("./pointOfInterest/scan")
|
|
endDate=ET.Element("endDate")
|
|
endDate.text=str(time.asctime(time.localtime(time.time())))
|
|
scan.append(endDate)
|
|
tree.write(databaseFile)
|
|
|
|
command = "cp " + logFile + " " + sampleTifPath
|
|
os.system(command)
|
|
command = "ln " + sampleTifPath + "/" + filePrefix + ".log " + logPath
|
|
os.system(command)
|
|
command = "rm " + logFile
|
|
os.system(command)
|
|
|
|
if scanInterruption==0:
|
|
command = "curl -X PUT -H \"Content-Type: application/xml\" -d @\"" + databaseFile + "\" http://x02da-www-1:8080/ch.psi.epms.web/rs/epms/upload"
|
|
os.system(command)
|
|
command = "cp " + databaseFile + " " + sampleTifPath
|
|
os.system(command)
|
|
command = "ln " + sampleTifPath + "/" + filePrefix + ".xml " + logPath
|
|
os.system(command)
|
|
command = "rm " + databaseFile
|
|
os.system(command)
|
|
else:
|
|
chScanInterruption.putWait(1)
|
|
|
|
print "Set STOREMODE and RECMODE back to Recorder and Ring Buffer (for preview purposes)"
|
|
chCCDCAM_STOREMODE.putWait("Recorder")
|
|
chCCDCAM_RECMODE.putWait("Ring Buffer")
|
|
chCCDCAM_SET_PARAM.putWait("SET")
|
|
print "Fifo mode OFF"
|
|
|
|
# Set the scan status flag to Idle
|
|
chExperimentStatus.putWait("Idle")
|
|
|
|
def fastdpcscan(rotyMin,rotyMax,numberOfProjections,exposure,xLinIn,xLinOut,numberOfDarks,numberOfFlats,gridStart,gridEnd,gridNSteps,crystal1Pitch,scanType,millisecondShutter,rotationStage):
|
|
|
|
global scanPause
|
|
global scanInterruption
|
|
global totalScanTime
|
|
global NSteps, iPhase
|
|
global logFile,sampleTifPath,logPath,databaseFile
|
|
|
|
scanInterruption=0
|
|
scanPause=0
|
|
|
|
# Set the scan status flag to running
|
|
chExperimentStatus.putWait("Running")
|
|
print "DPC-TOMOGRAPHIC SCAN STARTED!!!"
|
|
FILE = open(logFile,"a")
|
|
FILE.write("DPC-TOMOGRAPHIC SCAN STARTED!!!\n")
|
|
FILE.close()
|
|
|
|
# Set scan type to continuous mode (just in case)
|
|
if rotationStage=="Micos":
|
|
chScanType.putWait(0)
|
|
|
|
# Setting file format
|
|
chCCDCAM_FILEFORMAT.putWait("TIFF")
|
|
|
|
baseRotySpeed=chROT_GVEL.getw()
|
|
|
|
# Select FIFO mode
|
|
chCCDCAM_STOREMODE.putWait("FIFO Buffer")
|
|
print "Fifo mode ON"
|
|
chCCDCAM_RECMODE.putWait("Sequence")
|
|
chCCDCAM_ACQMODE.putWait("Auto")
|
|
chCCDCAM_TRIGGER.putWait("auto trigger")
|
|
if scanType=="7":
|
|
chCCDCAM_DELAY.putWait(0)
|
|
chCCDCAM_SET_PARAM.putWait("SET")
|
|
|
|
# This is to make the camera run with the correct settings
|
|
# TODO do I need this??? Maybe for the COCTIME???
|
|
#chCCDCAM_CLEARMEM.putWait("CLEAR")
|
|
#chCCDCAM_CAMERA.putWait("RUNNING",req_type=ca.DBF_STRING)
|
|
#time.sleep(1)
|
|
#chCCDCAM_CAMERA.putWait("OFF",req_type=ca.DBF_STRING)
|
|
chCCDCAM_CLEARMEM.putWait("CLEAR")
|
|
|
|
# Grid increment
|
|
gridStepSize=(gridEnd-gridStart)/gridNSteps
|
|
NSteps=gridNSteps+1
|
|
|
|
# Total number of projections
|
|
totalNumberOfProjections=numberOfDarks+numberOfFlats*2*NSteps+numberOfProjections*NSteps
|
|
|
|
ccdFrameTime=chCCDCAM_COCTIME.getw()
|
|
|
|
# Angular increment
|
|
deltaRot=rotyMax-rotyMin
|
|
if numberOfProjections!=0:
|
|
angularIncrement=deltaRot/(numberOfProjections-1)
|
|
else:
|
|
angularIncrement=0
|
|
|
|
if scanType=="7":
|
|
chROT_TWEAK.putWait(angularIncrement)
|
|
if rotationStage=="Micos":
|
|
systemOffset=chSystemOffset.getw()
|
|
systemTime=systemOffset+(rotyMax-rotyMin)*1000/((numberOfProjections-1)*baseRotySpeed)
|
|
systemTimeForFlats=systemOffset
|
|
delay=systemTime+exposure-ccdFrameTime
|
|
delayForFlats=systemTimeForFlats+exposure-ccdFrameTime
|
|
totalScanTime=numberOfProjections*(exposure+systemTime)/1000
|
|
else:
|
|
stabilizationTime=chROT_STAB_TIME.getw()
|
|
print "Stabilization time " + str(stabilizationTime) + " ms"
|
|
totalScanTime=numberOfProjections*(ccdFrameTime+stabilizationTime)/1000
|
|
elif scanType=="5":
|
|
totalScanTime=numberOfProjections*ccdFrameTime/1000
|
|
else:
|
|
print "This scan type has not been implemented yet!"
|
|
sys.exit()
|
|
|
|
if deltaRot!=0 and scanType=="5":
|
|
rotySpeed=deltaRot/((numberOfProjections-1)*ccdFrameTime)*1000
|
|
else:
|
|
rotySpeed=baseRotySpeed
|
|
|
|
rotationAcceleration=chROT_GACC.getw()
|
|
print "Acceleration " + str(rotationAcceleration)
|
|
accelerationAngle=rotySpeed*rotySpeed/rotationAcceleration
|
|
waitingTime=math.fabs(rotySpeed)/rotationAcceleration
|
|
if waitingTime <= 0.2999:
|
|
waitingTime=0.3
|
|
|
|
if deltaRot!=0:
|
|
if scanType=="5":
|
|
rotationStart=rotyMin-rotySpeed*waitingTime-accelerationAngle
|
|
rotationStop=rotationStart+deltaRot+2*(rotySpeed*waitingTime+accelerationAngle)
|
|
elif scanType=="7":
|
|
rotationStart=rotyMin-angularIncrement
|
|
rotationStop=rotyMax
|
|
else:
|
|
print "This scan type has not been implemented yet!"
|
|
sys.exit()
|
|
|
|
else:
|
|
rotationStart=rotyMin
|
|
rotationStop=rotationStart
|
|
|
|
print "Expected frame time " + str(ccdFrameTime) + " ms"
|
|
print "Angular scan: " + str(deltaRot) + " degrees"
|
|
print "Rotation speed (angle/s): " + str(math.fabs(rotySpeed))
|
|
print "Base rotation speed (angle/s): " + str(baseRotySpeed)
|
|
print "Start position: " + str(rotationStart)
|
|
print "Acceleration angle: " + str(accelerationAngle)
|
|
print "End position: " + str(rotationStop)
|
|
|
|
|
|
###################### Acquire dark images #################################
|
|
|
|
print "\033[1m" ## bold
|
|
print "Acquiring dark images"
|
|
print "\033[0m" ## back to normal
|
|
|
|
print "Move to start position"
|
|
print "Move rotation axis to: " + str(rotationStart)
|
|
chROT_SVEL.putWait(baseRotySpeed)
|
|
moveRotationWait(rotationStart)
|
|
|
|
# Closing filter for dark acquisition
|
|
if operationMode!=2:
|
|
if crystal1Pitch>-100:
|
|
print "Dump the beam by moving OP-FILTER 4 at -22.0 mm ..."
|
|
chOPFilter4.move(-22)
|
|
else:
|
|
print "Dump the beam by moving OP-FILTER 4 at -12.0 mm ..."
|
|
chOPFilter4.move(-12)
|
|
chOPFilter4.wait(poll=1)
|
|
else:
|
|
if crystal1Pitch>-100:
|
|
print "Dump the beam by moving OP-FILTER 4 at -22.0 mm ..."
|
|
else:
|
|
print "Dump the beam by moving OP-FILTER 4 at -12.0 mm ..."
|
|
|
|
print "Wait for afterglow ..."
|
|
time.sleep(5)
|
|
print "Done!"
|
|
|
|
# Set the channel of the tomography panel
|
|
chCameraStatus.putWait("Acquiring")
|
|
|
|
# Clear buffer
|
|
chCCDCAM_CLEARMEM.putWait("CLEAR")
|
|
|
|
print "Saving dark images 1-" + str(int(numberOfDarks))
|
|
chCCDCAM_FILENR.putWait(1)
|
|
chCCDCAM_SAVESTART.putWait(1)
|
|
chCCDCAM_SAVESTOP.putWait(int(numberOfDarks))
|
|
|
|
# Triggering the CCD acquisition sequence
|
|
print "Send trigger to the camera"
|
|
snap_fifo()
|
|
|
|
chCameraStatus.putWait("Idle")
|
|
print "Darks acquisition done!"
|
|
|
|
print "Moving the sample out of beam ..."
|
|
chSampleX.move(xLinOut)
|
|
chSampleX.wait(poll=1)
|
|
|
|
##################### Start step scans #######################################
|
|
|
|
print "\033[1m" ## bold
|
|
print "Starting grating stepping"
|
|
print "\033[0m" ## back to normal
|
|
|
|
# Opening the shutter
|
|
print "Moving up the filter OP-FILTER 4 at 0.0 mm ..."
|
|
if operationMode!=2:
|
|
chOPFilter4.move(0);chOPFilter4.wait(poll=1)
|
|
time.sleep(3)
|
|
|
|
# Defining a loop to take a block of flats and a tomograph for each grating step
|
|
|
|
iPhase=0
|
|
while iPhase<int(NSteps):
|
|
chActualStep.putWait(iPhase+1)
|
|
pauseFound=0
|
|
|
|
#################### Acquire pre flats ########################################
|
|
|
|
if scanInterruption==0:
|
|
if scanPause==1:
|
|
if pauseFound==0:
|
|
pauseFound=1
|
|
iPhase=iPhase-1
|
|
else:
|
|
|
|
print "\033[1m" ## bold
|
|
print "Grating step " + str(iPhase+1)
|
|
print "\033[0m" ## back to normal
|
|
|
|
FILE = open(logFile,"a")
|
|
FILE.write("Grating step " + str(iPhase+1) + "\n")
|
|
FILE.close()
|
|
|
|
gratingPosition=gridStart+iPhase*gridStepSize
|
|
print "Move grating to " + str(gratingPosition)
|
|
|
|
if operationMode==0:
|
|
chPiezo.move(gratingPosition)
|
|
chPiezo.wait(poll=1)
|
|
|
|
moveRotationWait(rotationStart)
|
|
|
|
print "\033[1m" ## bold
|
|
print "Acquiring pre flats " + str(iPhase+1)
|
|
print "\033[0m" ## back to normal
|
|
|
|
if scanType=="7":
|
|
if millisecondShutter=="Cam-Ctrl":
|
|
if rotationStage=="Micos":
|
|
chCCDCAM_DELAY.putWait(delayForFlats)
|
|
else:
|
|
chCCDCAM_DELAY.putWait(stabilizationTime)
|
|
chCCDCAM_SET_PARAM.putWait("SET")
|
|
|
|
# Set the channel of the tomography panel
|
|
chCameraStatus.putWait("Acquiring")
|
|
|
|
# Clear buffer
|
|
chCCDCAM_CLEARMEM.putWait("CLEAR")
|
|
|
|
print "Saving pre flats images " + str(int(numberOfDarks+iPhase*(2*numberOfFlats+numberOfProjections)+1)) + "-" + str(int(numberOfDarks+iPhase*(2*numberOfFlats+numberOfProjections)+numberOfFlats))
|
|
chCCDCAM_FILENR.putWait(numberOfDarks+iPhase*(2*numberOfFlats+numberOfProjections)+1)
|
|
chCCDCAM_SAVESTART.putWait(1)
|
|
chCCDCAM_SAVESTOP.putWait(numberOfFlats)
|
|
|
|
# Triggering the CCD acquisition sequence
|
|
print "Send trigger to the camera"
|
|
snap_dpc()
|
|
|
|
chCameraStatus.putWait("Idle")
|
|
print "Pre flats acquisition done!"
|
|
|
|
if scanType=="7":
|
|
if millisecondShutter=="Cam-Ctrl":
|
|
chCCDCAM_DELAY.putWait(0)
|
|
chCCDCAM_SET_PARAM.putWait("SET")
|
|
|
|
################## Acquire projection images ########################################
|
|
|
|
if scanInterruption==0:
|
|
if scanPause==1:
|
|
if pauseFound==0:
|
|
pauseFound=1
|
|
iPhase=iPhase-1
|
|
else:
|
|
|
|
print "\033[1m" ## bold
|
|
print "Acquiring projections " + str(iPhase+1)
|
|
print "\033[0m" ## back to normal
|
|
|
|
print "Saving projection images " + str(int(numberOfDarks+iPhase*(2*numberOfFlats+numberOfProjections)+numberOfFlats+1)) + "-" + str(int(numberOfDarks+iPhase*(2*numberOfFlats+numberOfProjections)+numberOfFlats+numberOfProjections))
|
|
chCCDCAM_FILENR.putWait(numberOfDarks+iPhase*(2*numberOfFlats+numberOfProjections)+numberOfFlats+1)
|
|
chCCDCAM_SAVESTART.putWait(1)
|
|
chCCDCAM_SAVESTOP.putWait(numberOfProjections)
|
|
|
|
print "Moving the sample in the beam ..."
|
|
chSampleX.move(xLinIn);chSampleX.wait(poll=1)
|
|
|
|
if scanType=="5":
|
|
print "Set the speed to: " + str(math.fabs(rotySpeed))
|
|
if rotationStage=="Aerotech":
|
|
chROT_STOP.putWait(0)
|
|
chROT_SVEL.putWait(math.fabs(rotySpeed))
|
|
|
|
if scanType=="7":
|
|
if rotationStage=="Micos":
|
|
chScanType.putWait(1)
|
|
chCCDCAM_DELAY.putWait(delay)
|
|
chCCDCAM_SET_PARAM.putWait("SET")
|
|
else:
|
|
chBoxModeSelection.putWait("Snap\'n\'Step")
|
|
chROT_GACC.putWait(500)
|
|
chROT_TWEAK.putWait(angularIncrement)
|
|
chROT_SNAP_START.putWait(rotationStart)
|
|
chROT_REPETIONS.putWait(numberOfProjections)
|
|
chROT_PULSE_WIDTH.putWait(1000)
|
|
chROT_SNAP_READY.putWait(1)
|
|
chROT_COUNTER.putWait(0)
|
|
chCCDCAM_TRIGGER.putWait("ext.exp sfttrg")
|
|
chCCDCAM_SET_PARAM.putWait("SET")
|
|
time.sleep(1)
|
|
chCCDCAM_CAMERA.putWait("RUNNING")
|
|
|
|
# Set the channel of the tomography panel
|
|
chCameraStatus.putWait("Acquiring")
|
|
|
|
# Clear buffer
|
|
chCCDCAM_CLEARMEM.putWait("CLEAR")
|
|
|
|
print "Rotation starts"
|
|
if scanType=="5":
|
|
chROT_SET_ABS.putWait(rotationStop)
|
|
else:
|
|
if rotationStage=="Aerotech":
|
|
chROT_START.putWait(1)
|
|
|
|
print "Send trigger to the camera"
|
|
snap_dpc()
|
|
|
|
chCameraStatus.putWait("Idle")
|
|
|
|
if scanType=="7" and rotationStage=="Aerotech":
|
|
|
|
chBoxModeSelection.putWait("Custom")
|
|
chROT_GACC.putWait(rotationAcceleration)
|
|
chROT_DIRECT_MODE.putWait(1)
|
|
chCCDCAM_TRIGGER.putWait("auto trigger")
|
|
chCCDCAM_SET_PARAM.putWait("SET")
|
|
|
|
if scanInterruption==0:
|
|
print "Projection acquisition done!"
|
|
|
|
##################### Acquire post flats #############################################
|
|
|
|
if scanInterruption==0:
|
|
if scanPause==1:
|
|
if pauseFound==0:
|
|
pauseFound=1
|
|
iPhase=iPhase-1
|
|
else:
|
|
|
|
chROT_STOP.putWait(0)
|
|
chROT_SVEL.putWait(baseRotySpeed)
|
|
|
|
if rotationStage=="Micos":
|
|
chScanType.putWait(0)
|
|
print "Move Rotation to " + str(rotyMin)
|
|
moveRotationWait(rotyMin)
|
|
|
|
print "\033[1m" ## bold
|
|
print "Acquiring post flats " + str(iPhase+1)
|
|
print "\033[0m" ## back to normal
|
|
|
|
print "Saving post flat images " + str(int(numberOfDarks+iPhase*(2*numberOfFlats+numberOfProjections)+numberOfFlats+numberOfProjections+1)) + "-" + str(int(numberOfDarks+(iPhase+1)*(2*numberOfFlats+numberOfProjections)))
|
|
chCCDCAM_FILENR.putWait(numberOfDarks+iPhase*(2*numberOfFlats+numberOfProjections)+numberOfFlats+numberOfProjections+1)
|
|
chCCDCAM_SAVESTART.putWait(1)
|
|
chCCDCAM_SAVESTOP.putWait(numberOfFlats)
|
|
|
|
print "Moving the sample out of beam ..."
|
|
chSampleX.move(xLinOut)
|
|
chSampleX.wait(poll=1)
|
|
|
|
if scanType=="7":
|
|
if rotationStage=="Micos":
|
|
chScanType.putWait(0)
|
|
chCCDCAM_DELAY.putWait(delayForFlats)
|
|
else:
|
|
if millisecondShutter=="Cam-Ctrl":
|
|
chCCDCAM_DELAY.putWait(stabilizationTime)
|
|
chCCDCAM_SET_PARAM.putWait("SET")
|
|
|
|
# Set the channel of the tomography panel
|
|
chCameraStatus.putWait("Acquiring")
|
|
|
|
# Clear buffer
|
|
chCCDCAM_CLEARMEM.putWait("CLEAR")
|
|
|
|
print "Send trigger to the camera"
|
|
snap_dpc()
|
|
|
|
chCameraStatus.putWait("Idle")
|
|
print "Post flats acquisition done!"
|
|
|
|
if scanType=="7":
|
|
if millisecondShutter=="Cam-Ctrl":
|
|
chCCDCAM_DELAY.putWait(0)
|
|
chCCDCAM_SET_PARAM.putWait("SET")
|
|
|
|
print "Moving back to initial conditions ..."
|
|
print "Set rotation speed back to " + str(baseRotySpeed)
|
|
if rotationStage=="Aerotech":
|
|
chROT_STOP.putWait(0)
|
|
chROT_SVEL.putWait(baseRotySpeed)
|
|
print "Move Rotation to " + str(rotyMin)
|
|
moveRotationWait(rotyMin)
|
|
|
|
if scanPause==1:
|
|
scanPause=0
|
|
print "PHASE " + str(iPhase)
|
|
if pauseFound==0:
|
|
pauseFound=1
|
|
iPhase=iPhase-1
|
|
iPhase+=1
|
|
|
|
|
|
print "\033[1m" ## bold
|
|
print "Grating stepping finished"
|
|
print "\033[0m" ## back to normal
|
|
|
|
print "Moving back to initial conditions ..."
|
|
|
|
if scanInterruption==0:
|
|
chComputeSinograms.putWait(1)
|
|
|
|
# Close the shutter and put sample back!
|
|
|
|
if operationMode!=2:
|
|
if crystal1Pitch>-100:
|
|
print "Dump the beam by moving OP_FILTER 4 to -22.0 mm ..."
|
|
chOPFilter4.move(-22);chOPFilter4.wait(poll=1)
|
|
else:
|
|
print "Dump the beam by moving OP_FILTER 4 to -12.0 mm ..."
|
|
chOPFilter4.move(-12);chOPFilter4.wait(poll=1)
|
|
else:
|
|
if crystal1Pitch>-100:
|
|
print "Dump the beam by moving OP_FILTER 4 to -22.0 mm ..."
|
|
else:
|
|
print "Dump the beam by moving OP_FILTER 4 to -12.0 mm ..."
|
|
|
|
print "Set rotation speed back to " + str(baseRotySpeed)
|
|
#if rotationStage=="Aerotech":
|
|
chROT_STOP.putWait(0)
|
|
chROT_SVEL.putWait(baseRotySpeed)
|
|
|
|
if rotationStage=="Micos":
|
|
chScanType.putWait(0)
|
|
print "Move Rotation to " + str(rotyMin)
|
|
moveRotationWait(rotyMin)
|
|
print "Moving the sample out of beam ..."
|
|
chSampleX.move(xLinOut);chSampleX.wait(poll=1)
|
|
|
|
if operationMode==0:
|
|
chPiezo.move(gridStart)
|
|
chPiezo.wait(poll=1)
|
|
print "Moving grating to " + str(gridStart)
|
|
|
|
chScanTimeToGo.putWait(0)
|
|
|
|
if scanType=="7" and rotationStage=="Aerotech":
|
|
chBoxModeSelection.putWait("Custom")
|
|
chROT_GACC.putWait(rotationAcceleration)
|
|
chROT_DIRECT_MODE.putWait(1)
|
|
chCCDCAM_TRIGGER.putWait("auto trigger")
|
|
chROT_COUNTER.putWait(0)
|
|
|
|
FILE = open(logFile,"a")
|
|
FILE.write("DPC-TOMOGRAPHIC SCAN FINISHED at " + str(time.asctime(time.localtime(time.time())))+"\n")
|
|
FILE.close()
|
|
|
|
# Logging
|
|
tree = ET.parse(databaseFile)
|
|
sample = tree.getroot()
|
|
scan = sample.find("./pointOfInterest/scan")
|
|
endDate=ET.Element("endDate")
|
|
endDate.text=str(time.asctime(time.localtime(time.time())))
|
|
scan.append(endDate)
|
|
tree.write(databaseFile)
|
|
|
|
command = "cp " + logFile + " " + sampleTifPath
|
|
os.system(command)
|
|
command = "ln " + sampleTifPath + "/" + filePrefix + ".log " + logPath
|
|
os.system(command)
|
|
command = "rm " + logFile
|
|
os.system(command)
|
|
|
|
if scanInterruption==0:
|
|
command = "curl -X PUT -H \"Content-Type: application/xml\" -d @\"" + databaseFile + "\" http://x02da-www-1:8080/ch.psi.epms.web/rs/epms/upload"
|
|
os.system(command)
|
|
command = "cp " + databaseFile + " " + sampleTifPath
|
|
os.system(command)
|
|
command = "ln " + sampleTifPath + "/" + filePrefix + ".xml " + logPath
|
|
os.system(command)
|
|
command = "rm " + databaseFile
|
|
os.system(command)
|
|
else:
|
|
chScanInterruption.putWait(1)
|
|
|
|
print "Set STOREMODE and RECMODE back to Recorder and Ring Buffer (for preview purposes)"
|
|
chCCDCAM_STOREMODE.putWait("Recorder")
|
|
chCCDCAM_RECMODE.putWait("Ring Buffer")
|
|
chCCDCAM_SET_PARAM.putWait("SET")
|
|
print "Fifo mode OFF"
|
|
|
|
# Set the scan status flag to Idle
|
|
chExperimentStatus.putWait("Idle")
|
|
chPause.putWait(0)
|
|
|
|
|
|
# ---------------------------------- Main ---------------------------------------------
|
|
global logFile,sampleTifPath,logPath,databaseFile,operationMode
|
|
|
|
beamline="X02DA"
|
|
|
|
'''
|
|
operationMode=0 Production mode
|
|
operationMode=1 Production mode during machine/shutdown
|
|
operationMode=2 Testing on second endstation during operation
|
|
'''
|
|
|
|
operationMode=0
|
|
standardChannelDefinition(operationMode)
|
|
|
|
# Camera channel definition
|
|
usedServer=chServer.getw()
|
|
if usedServer==0:
|
|
cameraPrefix="CCDCAM"
|
|
SERVERNR="1"
|
|
elif usedServer==1:
|
|
cameraPrefix="CCDCAM2"
|
|
SERVERNR="2"
|
|
else:
|
|
print "Server " + str(usedServer) + " has not been implemented yet!"
|
|
sys.exit(0)
|
|
print "Used server: " + SERVERNR
|
|
cameraChannelDefinition(beamline,cameraPrefix)
|
|
|
|
# Endstation definition
|
|
usedEndstation=chEndstation.getw()
|
|
if usedEndstation==0:
|
|
endstationPrefix="ES1"
|
|
rotationStage="Aerotech"
|
|
elif usedEndstation==1:
|
|
endstationPrefix="ES2"
|
|
rotationStage="Micos"
|
|
else:
|
|
print "Endstation " + str(usedEndstation) + " has not been implemented yet!"
|
|
sys.exit(0)
|
|
print "Used endstation: " + endstationPrefix
|
|
rotationStageDefinition(rotationStage,endstationPrefix,beamline)
|
|
|
|
# Initialize
|
|
chGo.putWait(0)
|
|
chPause.putWait(0)
|
|
chExperimentStatus.putWait("Idle",req_type=ca.DBF_STRING)
|
|
chCameraStatus.putWait("Idle",req_type=ca.DBF_STRING)
|
|
|
|
oldSamplename="Null"
|
|
|
|
while (1):
|
|
|
|
# Scan type
|
|
scanType=sys.argv[1]
|
|
|
|
scango=chGo.getw()
|
|
|
|
if scanType == "2":
|
|
print "\033[1m" ## bold
|
|
print "Fast Mode ON"
|
|
print "Waiting for your toggle on the panel to start the scan"
|
|
print "\033[0m" ## back to normal
|
|
elif scanType == "5":
|
|
print "\033[1m" ## bold
|
|
print "DPC Fast Mode ON"
|
|
print "Waiting for your toggle on the panel to start the scan"
|
|
print "\033[0m" ## back to normal
|
|
elif scanType == "6":
|
|
print "\033[1m" ## bold
|
|
print "Snap&Step Mode On"
|
|
print "Waiting for your toggle on the panel to start the scan"
|
|
print "\033[0m" ## back to normal
|
|
elif scanType == "7":
|
|
print "\033[1m" ## bold
|
|
print "DPC Snap&Step Mode On"
|
|
print "Waiting for your toggle on the panel to start the scan"
|
|
print "\033[0m" ## back to normal
|
|
elif scanType == "-h":
|
|
show_help()
|
|
else:
|
|
show_help()
|
|
|
|
while scango!=1:
|
|
time.sleep(0.1)
|
|
scango=chGo.getw()
|
|
|
|
# Stop camera if running and reset rotation stage features
|
|
chCCDCAM_CAMERA.putWait("OFF",req_type=ca.DBF_STRING)
|
|
if rotationStage=="Aerotech":
|
|
chBoxModeSelection.putWait("Custom")
|
|
chROT_SNAP_START.putWait(0)
|
|
chROT_SNAP_OFFSET.putWait(0)
|
|
chROT_DIRECT_MODE.putWait(1)
|
|
|
|
# Scan interruption flag
|
|
chScanInterruption.putWait(0)
|
|
chComputeSinograms.putWait(0)
|
|
|
|
# Filename prefix for ccd images
|
|
filePrefix=chFilePrefix.getw()
|
|
baseName=filePrefix
|
|
|
|
# Sample ROI (for robot operation and stacked scans)
|
|
roi=chRoi.getw()
|
|
if roi=="":
|
|
roi="P1" # For database
|
|
filePrefix=baseName
|
|
else:
|
|
filePrefix=baseName+"_"+roi
|
|
|
|
if filePrefix==oldSamplename:
|
|
print "\033[1m" ## bold
|
|
print ""
|
|
print "Current samplename is the same as the one of the previous scan!"
|
|
print "Please change the samplename and start the scan again."
|
|
print ""
|
|
print "\033[0m" ## back to normal
|
|
scanType="10"
|
|
oldSamplename=filePrefix
|
|
|
|
# Check for empty spaces in the samplename
|
|
filePrefixList=filePrefix.split(" ")
|
|
if len(filePrefixList)>1:
|
|
print "\033[1m" ## bold
|
|
print ""
|
|
print "The samplename must not contain spaces!!!"
|
|
print ""
|
|
print "\033[0m" ## back to normal
|
|
scanType="10"
|
|
|
|
chFilePrefix.putWait(filePrefix)
|
|
|
|
# Exposure time (in s)
|
|
exposure=chExposure.getw()
|
|
chCCDCAM_EXPOSURE.putWait(exposure)
|
|
chCCDCAM_SET_PARAM.putWait("SET")
|
|
# Delay time (in s)
|
|
delayStart=chCCDCAM_DELAY.getw()
|
|
# Rotation scan values
|
|
rotyMin=chRotyMin.getw()
|
|
rotyMax=chRotyMax.getw()
|
|
rotationAxisPosition=chRotationAxisPosition.getw(ca.DBF_STRING)
|
|
|
|
# Region of interest
|
|
ccdXStart=chCCDCAM_REGIONX_START.getw()
|
|
ccdXEnd=chCCDCAM_REGIONX_END.getw()
|
|
ccdYStart=chCCDCAM_REGIONY_START.getw()
|
|
ccdYEnd=chCCDCAM_REGIONY_END.getw()
|
|
|
|
# Values for in and out of beam position
|
|
xLinIn=chXLinIn.getw()
|
|
xLinOut=chXLinOut.getw()
|
|
|
|
# Number of darks
|
|
numberOfDarks=chNumberOfDarks.getw()
|
|
# Number of flats
|
|
numberOfFlats=chNumberOfFlats.getw()
|
|
# Number of projections
|
|
numberOfProjections=chNumberOfProjections.getw()
|
|
|
|
if math.fabs(rotyMax-rotyMin)==360:
|
|
if numberOfProjections%2==0 and rotationAxisPosition!="Standard":
|
|
print "\033[1m" ## bold
|
|
print ""
|
|
print "360 degrees stiched scan: an odd number of projections is required"
|
|
print "The number of projections has been incremented by 1"
|
|
print ""
|
|
print "\033[0m" ## back to normal
|
|
numberOfProjections=numberOfProjections+1
|
|
print "Number of projections " + str(numberOfProjections)
|
|
chNumberOfProjections.putWait(numberOfProjections)
|
|
if numberOfProjections%2!=0 and rotationAxisPosition=="Standard":
|
|
print "\033[1m" ## bold
|
|
print ""
|
|
print "360 degrees standard scan: an even number of projections is required"
|
|
print "The number of projections has been incremented by 1"
|
|
print ""
|
|
print "\033[0m" ## back to normal
|
|
numberOfProjections=numberOfProjections+1
|
|
print "Number of projections " + str(numberOfProjections)
|
|
chNumberOfProjections.putWait(numberOfProjections)
|
|
|
|
# Sample coordinatesLog
|
|
sampleX=chSampleX.get_position(dial=1)
|
|
sampleY=chSampleY.getw()
|
|
sampleZ=chSampleZ.get_position(dial=1)
|
|
sampleXX=chSampleXX.get_position(dial=1)
|
|
sampleZZ=chSampleZZ.get_position(dial=1)
|
|
|
|
# Microscope coordinates
|
|
microscopeX=chMicroscopeX.get_position(dial=1)
|
|
microscopeY=chMicroscopeY.get_position(dial=1)
|
|
microscopeZ=chMicroscopeZ.get_position(dial=1)
|
|
|
|
# For DPC
|
|
if scanType=="5" or scanType=="7":
|
|
piezoOffset=50
|
|
piezoCalibration=1.0
|
|
# Grid start point
|
|
gridStartRaw=chGridStartRaw.getw()
|
|
gridEndRaw=chGridEndRaw.getw()
|
|
gridStart=(gridStartRaw*piezoCalibration)+piezoOffset
|
|
gridEnd=(gridEndRaw-gridStartRaw)*piezoCalibration+gridStart
|
|
gridNSteps=chGridNSteps.getw()
|
|
gridNPeriods=chGridNPeriods.getw()
|
|
|
|
if scanType=="6" or scanType=="7":
|
|
triggerDelay=chTriggerDelay.getw()
|
|
if rotationStage=="Aerotech":
|
|
chROT_STAB_TIME.putWait(triggerDelay)
|
|
elif rotationStage=="Micos":
|
|
chSystemOffset.putWait(triggerDelay)
|
|
|
|
millisecondShutter=chMillisecondShutter.getw(req_type=ca.DBF_STRING)
|
|
|
|
# Read user id
|
|
userID=chUserID.getw()
|
|
|
|
# Read machine and beamline parameters
|
|
if operationMode==0:
|
|
ringCurrentStart=chRingCurrentStatus.getw()
|
|
else:
|
|
ringCurrentStart=chRingCurrentStartFake.getw()
|
|
if ringCurrentStart<10:
|
|
print "\033[1m" ## bold
|
|
print ""
|
|
print "Ring current is too low to start a scan!!"
|
|
print ""
|
|
print "\033[0m" ## back to normal
|
|
chGo.putWait(0)
|
|
scanType="10"
|
|
|
|
# Energy
|
|
crystal1Pitch=chCrystal1Pitch.get_position()
|
|
if crystal1Pitch>-100:
|
|
beamEnergy="Polychromatic radiation"
|
|
else:
|
|
beamEnergy=chBeamEnergy.getw()
|
|
stripe=chStripe.getw(req_type=ca.DBF_STRING)
|
|
|
|
# Filters
|
|
FEFilter=chFEFilter.getw(req_type=ca.DBF_STRING)
|
|
OPFilter1=chOPFilter1.getw(req_type=ca.DBF_STRING)
|
|
OPFilter2=chOPFilter2.getw(req_type=ca.DBF_STRING)
|
|
OPFilter3=chOPFilter3.getw(req_type=ca.DBF_STRING)
|
|
|
|
# Read detector parameters
|
|
camera=chCamera.getw(req_type=ca.DBF_STRING)
|
|
microscope=chMicroscope.getw(req_type=ca.DBF_STRING)
|
|
magnification=chMagnification.getw()
|
|
scintillator=chScintillator.getw()
|
|
pixelSize=chPixelSize.getw()
|
|
|
|
# Path variables
|
|
storage=chStorage.getw()
|
|
|
|
# Define the temporary path for logging
|
|
loggingBasePath="/sls/X02DA/data/e" + userID + "/public/"
|
|
logFile=loggingBasePath + filePrefix + ".log"
|
|
databaseFile=loggingBasePath + filePrefix + ".xml"
|
|
|
|
# Sample path
|
|
sampleBasePath="/sls/X02DA/data/e" + userID + "/" + storage + "/" + filePrefix + "/"
|
|
sampleTifPath=sampleBasePath + "tif"
|
|
|
|
# Log path
|
|
logPath="/sls/X02DA/data/e" + userID + "/" + storage + "/log"
|
|
|
|
# Folder name for Camera Server X:// is hardcoded!!!
|
|
folderName="X:/" + storage + "/" + filePrefix + "/tif/\0"
|
|
if len(folderName)>255:
|
|
print "\033[1m" ## bold
|
|
print ""
|
|
print "The samplename is too long!!"
|
|
print ""
|
|
print "\033[0m" ## back to normal
|
|
scanType="10"
|
|
|
|
if scanType!="10":
|
|
if os.path.isdir(logPath):
|
|
pass
|
|
else:
|
|
os.mkdir(logPath)
|
|
if os.path.isdir(sampleBasePath):
|
|
print "\033[1m" ## bold
|
|
print ""
|
|
print "The samplename " + filePrefix + " already exist!!"
|
|
print ""
|
|
print "\033[0m" ## back to normal
|
|
scanType="10"
|
|
else:
|
|
os.mkdir(sampleBasePath)
|
|
if os.path.isdir(sampleTifPath):
|
|
pass
|
|
else:
|
|
os.mkdir(sampleTifPath)
|
|
|
|
if scanType!="10":
|
|
|
|
print "User ID : e" + str(userID)
|
|
if scanType=="2":
|
|
print "FAST-TOMO scan of sample " + filePrefix + " started on " + str(time.asctime(time.localtime(time.time())))
|
|
elif scanType=="5" or scanType=="7":
|
|
print "DPC scan of sample " + filePrefix + " started on " + str(time.asctime(time.localtime(time.time())))
|
|
else:
|
|
print "SNAP&STEP-TOMO scan of sample " + filePrefix + " started on " + str(time.asctime(time.localtime(time.time())))
|
|
|
|
print "--------------------Beamline Settings-------------------------"
|
|
print "Ring current [mA] : %3.3f" % ringCurrentStart
|
|
if crystal1Pitch>-100:
|
|
print "Beam energy : " + str(beamEnergy)
|
|
else:
|
|
print "Beam energy [keV] : %2.3f" % beamEnergy
|
|
print "Monostripe : " + str(stripe)
|
|
print "FE-Filter : " + str(FEFilter)
|
|
print "OP-Filter 1 : " + str(OPFilter1)
|
|
print "OP-Filter 2 : " + str(OPFilter2)
|
|
print "OP-Filter 3 : " + str(OPFilter3)
|
|
print "--------------------Detector Settings-------------------------"
|
|
print "Camera : " + str(camera)
|
|
print "Microscope : " + str(microscope)
|
|
print "Magnification : " + str(magnification)
|
|
print "Scintillator : " + str(scintillator)
|
|
print "Exposure time [ms] : " + str(exposure)
|
|
if scanType=="2" or scanType=="5":
|
|
print "Delay time [ms] : " + str(delayStart)
|
|
if (scanType=="6" or scanType=="7") and rotationStage=="Aerotech":
|
|
stabilizationTime=chROT_STAB_TIME.getw()
|
|
print "Stabilization time [ms] : " + str(stabilizationTime)
|
|
|
|
if millisecondShutter=="IOC-Ctrl":
|
|
print "Millisecond shutter : not used"
|
|
else:
|
|
print "Millisecond shutter : used"
|
|
print "X-ROI : " + str(int(ccdXStart)) + " - " +str(int(ccdXEnd))
|
|
print "Y-ROI : " + str(int(ccdYStart)) + " - " +str(int(ccdYEnd))
|
|
print "Actual pixel size [um] : " + str(pixelSize)
|
|
print "------------------------Scan Settings-------------------------"
|
|
print "Sample folder : " + str(sampleBasePath)
|
|
print "File Prefix : " + str(filePrefix)
|
|
print "Number of projections : " + str(int(numberOfProjections))
|
|
print "Number of darks : " + str(int(numberOfDarks))
|
|
print "Number of flats : " + str(int(numberOfFlats))
|
|
print "Number of inter-flats : 0"
|
|
print "Flat frequency : 0"
|
|
print "Rot Y min position [deg] : " + str(rotyMin)
|
|
print "Rot Y max position [deg] : " + str(rotyMax)
|
|
print "Rotation axis position : " + str(rotationAxisPosition)
|
|
if numberOfProjections!=0:
|
|
print "Angular step [deg] : " + str((rotyMax-rotyMin)/(numberOfProjections-1))
|
|
else:
|
|
print "Angular step [deg] : 0"
|
|
print "Sample In [um] : " + str(xLinIn)
|
|
print "Sample Out [um] : " + str(xLinOut)
|
|
print "-----------------------Sample coordinates---------------------"
|
|
print "X-coordinate : " + str(sampleX)
|
|
print "Y-coordinate : " + str(sampleY)
|
|
print "Z-coordinate : " + str(sampleZ)
|
|
print "XX-coordinate : " + str(sampleXX)
|
|
print "ZZ-coordinate : " + str(sampleZZ)
|
|
print "-----------------------Microscope coordinates---------------------"
|
|
print "X-coordinate : " + str(microscopeX)
|
|
print "Y-coordinate : " + str(microscopeY)
|
|
print "Z-coordinate : " + str(microscopeZ)
|
|
if scanType=="5" or scanType=="7":
|
|
print "--------------------Interferometer Settings-------------------"
|
|
print "Grid start position [um] : " + str(gridStartRaw)
|
|
print "Grid end position [um] : " + str(gridEndRaw)
|
|
print "Grid step : " + str(gridNSteps)
|
|
print "Grid period : " + str(gridNPeriods)
|
|
print "--------------------------------------------------------------"
|
|
|
|
|
|
FILE = open(logFile,"a")
|
|
FILE.write("User ID : e" + userID + "\n")
|
|
if scanType=="2":
|
|
FILE.write("FAST-TOMO scan of sample " + filePrefix + " started on " + str(time.asctime(time.localtime(time.time()))) + "\n")
|
|
elif scanType=="5" or scanType=="7":
|
|
FILE.write("DPC-TOMO scan of sample " + filePrefix + " started on " + str(time.asctime(time.localtime(time.time()))) + "\n")
|
|
else:
|
|
FILE.write("SNAP&STEP-TOMO scan of sample " + filePrefix + " started on " + str(time.asctime(time.localtime(time.time()))) + "\n")
|
|
FILE.write("--------------------Beamline Settings-------------------------\n")
|
|
FILE.write("Ring current [mA] : %3.3f\n" % ringCurrentStart)
|
|
if crystal1Pitch>-100:
|
|
FILE.write("Beam energy : " + beamEnergy + "\n")
|
|
else:
|
|
FILE.write("Beam energy [keV] : %2.3f\n" % beamEnergy)
|
|
FILE.write("Monostripe : " + str(stripe) + "\n")
|
|
FILE.write("FE-Filter : " + str(FEFilter) + "\n")
|
|
FILE.write("OP-Filter 1 : " + str(OPFilter1) + "\n")
|
|
FILE.write("OP-Filter 2 : " + str(OPFilter2) + "\n")
|
|
FILE.write("OP-Filter 3 : " + str(OPFilter3) + "\n")
|
|
FILE.write("--------------------Detector Settings-------------------------\n")
|
|
FILE.write("Camera : " + str(camera) + "\n")
|
|
FILE.write("Microscope : " + str(microscope) + "\n")
|
|
FILE.write("Magnification : " + str(magnification) + "\n")
|
|
FILE.write("Scintillator : " + str(scintillator) + "\n")
|
|
FILE.write("Exposure time [ms] : " + str(exposure) + "\n")
|
|
if scanType=="2" or scanType=="5":
|
|
FILE.write("Delay time [ms] : " + str(delayStart) + "\n")
|
|
if (scanType=="6" or scanType=="7") and rotationStage=="Aerotech":
|
|
FILE.write("Stabilization time [ms] : " + str(stabilizationTime) + "\n")
|
|
if millisecondShutter=="IOC-Ctrl":
|
|
FILE.write("Millisecond shutter [ms] : not used\n")
|
|
else:
|
|
FILE.write("Millisecond shutter [ms] : used\n")
|
|
FILE.write("X-ROI : " + str(int(ccdXStart)) + " - " + str(int(ccdXEnd)) + "\n")
|
|
FILE.write("Y-ROI : " + str(int(ccdYStart)) + " - " + str(int(ccdYEnd)) + "\n")
|
|
FILE.write("Actual pixel size [um] : " + str(pixelSize) + "\n")
|
|
FILE.write("------------------------Scan Settings-------------------------\n")
|
|
FILE.write("Sample folder : " + sampleBasePath + "\n")
|
|
FILE.write("File Prefix : " + str(filePrefix) + "\n")
|
|
FILE.write("Number of projections : " + str(int(numberOfProjections)) + "\n")
|
|
FILE.write("Number of darks : " + str(int(numberOfDarks)) + "\n")
|
|
FILE.write("Number of flats : " + str(int(numberOfFlats)) + "\n")
|
|
FILE.write("Number of inter-flats : 0\n")
|
|
FILE.write("Flat frequency : 0\n")
|
|
FILE.write("Rot Y min position [deg] : " + str(rotyMin) + "\n")
|
|
FILE.write("Rot Y max position [deg] : " + str(rotyMax) + "\n")
|
|
FILE.write("Rotation axis position : " + str(rotationAxisPosition) + "\n")
|
|
if numberOfProjections!=0:
|
|
FILE.write("Angular step [deg] : %3.3f\n" % ((rotyMax-rotyMin)/(numberOfProjections-1)))
|
|
else:
|
|
FILE.write("Angular step [deg] : 0")
|
|
FILE.write("Sample In [um] : %5.0f\n" % xLinIn)
|
|
FILE.write("Sample Out [um] : %5.0f\n" % xLinOut)
|
|
FILE.write("-----------------------Sample coordinates---------------------\n")
|
|
FILE.write("X-coordinate : %5.2f\n" % sampleX)
|
|
FILE.write("Y-coordinate : %5.2f\n" % sampleY)
|
|
FILE.write("Z-coordinate : %5.2f\n" % sampleZ)
|
|
FILE.write("XX-coordinate : %5.2f\n" % sampleXX)
|
|
FILE.write("ZZ-coordinate : %5.2f\n" % sampleZZ)
|
|
FILE.write("-----------------------Microscope coordinates---------------------\n")
|
|
FILE.write("X-coordinate : %5.2f\n" % microscopeX)
|
|
FILE.write("Y-coordinate : %5.2f\n" % microscopeY)
|
|
FILE.write("Z-coordinate : %5.2f\n" % microscopeZ)
|
|
if scanType=="5" or scanType=="7":
|
|
FILE.write("--------------------Interferometer Settings-------------------\n")
|
|
FILE.write("Grid start position [um] : " + str(gridStartRaw) + "\n")
|
|
FILE.write("Grid end position [um] : " + str(gridEndRaw) + "\n")
|
|
FILE.write("Grid step : " + str(int(gridNSteps)) + "\n")
|
|
FILE.write("Grid period : " + str(int(gridNPeriods)) + "\n")
|
|
FILE.write("--------------------------------------------------------------\n")
|
|
FILE.close()
|
|
|
|
# Write xml file
|
|
sample=ET.Element("sample")
|
|
name=ET.SubElement(sample,"name")
|
|
name.text=baseName
|
|
userid=ET.SubElement(sample,"userid")
|
|
userid.text="e" + str(userID)
|
|
pointOfInterest=ET.SubElement(sample,"pointOfInterest")
|
|
name1=ET.SubElement(pointOfInterest,"name")
|
|
name1.text=roi
|
|
coordinates=ET.SubElement(pointOfInterest,"coordinates")
|
|
x=ET.SubElement(coordinates,"x")
|
|
x.text=str('{0:.2f}'.format(sampleX))
|
|
y=ET.SubElement(coordinates,"y")
|
|
y.text=str('{0:.2f}'.format(sampleY))
|
|
z=ET.SubElement(coordinates,"z")
|
|
z.text=str('{0:.2f}'.format(sampleZ))
|
|
xx=ET.SubElement(coordinates,"xx")
|
|
xx.text=str('{0:.2f}'.format(sampleXX))
|
|
zz=ET.SubElement(coordinates,"zz")
|
|
zz.text=str('{0:.2f}'.format(sampleZZ))
|
|
coordinateSystem=ET.SubElement(coordinates,"coordinateSystem")
|
|
coordinateSystem.text="beamline"
|
|
scan=ET.SubElement(pointOfInterest,"scan")
|
|
scanTYPE=ET.SubElement(scan,"scanType")
|
|
if scanType=="2":
|
|
scanTYPE.text="FAST-TOMO"
|
|
elif scanType=="6":
|
|
scanTYPE.text="SNAP-AND-STEP-TOMO"
|
|
else:
|
|
scanTYPE.text="DPC-TOMO"
|
|
startDate=ET.SubElement(scan,"startDate")
|
|
startDate.text=str(time.asctime(time.localtime(time.time())))
|
|
beamlineParameters=ET.SubElement(scan,"beamlineParameters")
|
|
parameter=ET.SubElement(beamlineParameters,"parameter")
|
|
parameter.text=str('{0:.3f}'.format(ringCurrentStart))
|
|
parameter.set('name','Ring current')
|
|
parameter.set('unit','mA')
|
|
parameter1=ET.SubElement(beamlineParameters,"parameter")
|
|
if crystal1Pitch>-100:
|
|
parameter1.text=beamEnergy
|
|
parameter1.set('name','Beam energy')
|
|
else:
|
|
parameter1.text=str('{0:.3f}'.format(beamEnergy))
|
|
parameter1.set('name','Beam energy')
|
|
parameter1.set('unit','keV')
|
|
parameter2=ET.SubElement(beamlineParameters,"parameter")
|
|
parameter2.text=stripe
|
|
parameter2.set('name','Monostripe')
|
|
parameter3=ET.SubElement(beamlineParameters,"parameter")
|
|
parameter3.text=FEFilter
|
|
parameter3.set('name','FE-Filter')
|
|
parameter4=ET.SubElement(beamlineParameters,"parameter")
|
|
parameter4.text=OPFilter1
|
|
parameter4.set('name','OP-Filter1')
|
|
parameter5=ET.SubElement(beamlineParameters,"parameter")
|
|
parameter5.text=OPFilter2
|
|
parameter5.set('name','OP-Filter2')
|
|
parameter6=ET.SubElement(beamlineParameters,"parameter")
|
|
parameter6.text=OPFilter3
|
|
parameter6.set('name','OP-Filter3')
|
|
detectorParameters=ET.SubElement(scan,"detectorParameters")
|
|
parameter7=ET.SubElement(detectorParameters,"parameter")
|
|
parameter7.text=camera
|
|
parameter7.set('name','Camera')
|
|
parameter8=ET.SubElement(detectorParameters,"parameter")
|
|
parameter8.text=microscope
|
|
parameter8.set('name','Microscope')
|
|
parameter9=ET.SubElement(detectorParameters,"parameter")
|
|
parameter9.text=str(magnification)
|
|
parameter9.set('name','Objective')
|
|
parameter10=ET.SubElement(detectorParameters,"parameter")
|
|
parameter10.text=scintillator
|
|
parameter10.set('name','Scintillator')
|
|
parameter11=ET.SubElement(detectorParameters,"parameter")
|
|
parameter11.text=str(int(exposure))
|
|
parameter11.set('name','Exposure time')
|
|
parameter11.set('unit','ms')
|
|
if scanType=="2" or scanType=="5":
|
|
parameter12=ET.SubElement(detectorParameters,"parameter")
|
|
parameter12.text=str(int(delayStart))
|
|
parameter12.set('name','Delay time')
|
|
parameter12.set('unit','ms')
|
|
if (scanType=="6" or scanType=="7") and rotationStage=="Aerotech":
|
|
parameter12a=ET.SubElement(detectorParameters,"parameter")
|
|
parameter12a.text=str(int(stabilizationTime))
|
|
parameter12a.set('name','Stabilization time')
|
|
parameter12a.set('unit','ms')
|
|
if millisecondShutter=="IOC-Ctrl":
|
|
parameter13=ET.SubElement(detectorParameters,"parameter")
|
|
parameter13.text="not used"
|
|
parameter13.set('name','Millisecond shutter')
|
|
else:
|
|
parameter13=ET.SubElement(detectorParameters,"parameter")
|
|
parameter13.text="used"
|
|
parameter13.set('name','Millisecond shutter')
|
|
parameter14=ET.SubElement(detectorParameters,"parameter")
|
|
parameter14.text=str(int(ccdXStart))
|
|
parameter14.set('name','X-ROI Start')
|
|
parameter15=ET.SubElement(detectorParameters,"parameter")
|
|
parameter15.text=str(int(ccdXEnd))
|
|
parameter15.set('name','X-ROI End')
|
|
parameter16=ET.SubElement(detectorParameters,"parameter")
|
|
parameter16.text=str(int(ccdYStart))
|
|
parameter16.set('name','Y-ROI Start')
|
|
parameter17=ET.SubElement(detectorParameters,"parameter")
|
|
parameter17.text=str(int(ccdYEnd))
|
|
parameter17.set('name','Y-ROI End')
|
|
parameter18=ET.SubElement(detectorParameters,"parameter")
|
|
parameter18.text=str('{0:.2f}'.format(pixelSize))
|
|
parameter18.set('name','Actual pixel size')
|
|
parameter18.set('unit','um')
|
|
parameter18a=ET.SubElement(detectorParameters,"parameter")
|
|
parameter18a.text=str('{0:.2f}'.format(microscopeX))
|
|
parameter18a.set('name','Microscope x position')
|
|
parameter18a.set('unit','mm')
|
|
parameter18b=ET.SubElement(detectorParameters,"parameter")
|
|
parameter18b.text=str('{0:.2f}'.format(microscopeY))
|
|
parameter18b.set('name','Microscope y position')
|
|
parameter18b.set('unit','mm')
|
|
parameter18b=ET.SubElement(detectorParameters,"parameter")
|
|
parameter18b.text=str('{0:.2f}'.format(microscopeZ))
|
|
parameter18b.set('name','Microscope z position')
|
|
parameter18b.set('unit','mm')
|
|
scanParameters=ET.SubElement(scan,"scanParameters")
|
|
parameter19=ET.SubElement(scanParameters,"parameter")
|
|
parameter19.text=sampleBasePath
|
|
parameter19.set('name','Sample folder')
|
|
parameter20=ET.SubElement(scanParameters,"parameter")
|
|
parameter20.text=filePrefix
|
|
parameter20.set('name','File Prefix')
|
|
parameter21=ET.SubElement(scanParameters,"parameter")
|
|
parameter21.text=str(int(numberOfProjections))
|
|
parameter21.set('name','Number of projections')
|
|
parameter22=ET.SubElement(scanParameters,"parameter")
|
|
parameter22.text=str(int(numberOfDarks))
|
|
parameter22.set('name','Number of darks')
|
|
parameter23=ET.SubElement(scanParameters,"parameter")
|
|
parameter23.text=str(int(numberOfFlats))
|
|
parameter23.set('name','Number of flats')
|
|
parameter24=ET.SubElement(scanParameters,"parameter")
|
|
parameter24.text="0"
|
|
parameter24.set('name','Number of inter-flats')
|
|
parameter24=ET.SubElement(scanParameters,"parameter")
|
|
parameter24.text="0"
|
|
parameter24.set('name','Flat frequency')
|
|
parameter18=ET.SubElement(scanParameters,"parameter")
|
|
parameter18.text=str('{0:.3f}'.format(rotyMin))
|
|
parameter18.set('name','Rot Y min position')
|
|
parameter18.set('unit','deg')
|
|
parameter19=ET.SubElement(scanParameters,"parameter")
|
|
parameter19.text=str('{0:.3f}'.format(rotyMax))
|
|
parameter19.set('name','Rot Y max position')
|
|
parameter19a=ET.SubElement(scanParameters,"parameter")
|
|
parameter19a.text=str(rotationAxisPosition)
|
|
parameter19a.set('name','Rotation axis position')
|
|
if numberOfProjections!=0:
|
|
parameter20=ET.SubElement(scanParameters,"parameter")
|
|
parameter20.text=str('{0:.3f}'.format((rotyMax-rotyMin)/(numberOfProjections-1)))
|
|
parameter20.set('name','Angular step')
|
|
parameter20.set('unit','deg')
|
|
else:
|
|
parameter20=ET.SubElement(scanParameters,"parameter")
|
|
parameter20.text="0"
|
|
parameter20.set('name','Angular step')
|
|
parameter20.set('unit','deg')
|
|
parameter21=ET.SubElement(scanParameters,"parameter")
|
|
parameter21.text=str(int(xLinIn))
|
|
parameter21.set('name','Sample In')
|
|
parameter21.set('unit','um')
|
|
parameter22=ET.SubElement(scanParameters,"parameter")
|
|
parameter22.text=str(int(xLinOut))
|
|
parameter22.set('name','Sample Out')
|
|
parameter22.set('unit','um')
|
|
if scanType=="5" or scanType=="7":
|
|
parameter23=ET.SubElement(scanParameters,"parameter")
|
|
parameter23.text=str('{0:.3f}'.format(gridStartRaw))
|
|
parameter23.set('name','Grid start position')
|
|
parameter23.set('unit','um')
|
|
parameter24=ET.SubElement(scanParameters,"parameter")
|
|
parameter24.text=str('{0:.3f}'.format(gridEndRaw))
|
|
parameter24.set('name','Grid end position')
|
|
parameter24.set('unit','um')
|
|
parameter25=ET.SubElement(scanParameters,"parameter")
|
|
parameter25.text=str(int(gridNSteps))
|
|
parameter25.set('name','Grid step')
|
|
parameter26=ET.SubElement(scanParameters,"parameter")
|
|
parameter26.text=str(int(gridNPeriods))
|
|
parameter26.set('name','Grid period')
|
|
|
|
# Wrap it in an ElementTree instance, and save as XML
|
|
tree=ET.ElementTree(sample)
|
|
tree.write(databaseFile)
|
|
chCCDCAM_FILENAME.putWait(filePrefix + "\0",req_type=ca.DBF_CHAR)
|
|
chCCDCAM_FILEPATH.putWait(folderName,req_type=ca.DBF_CHAR)
|
|
filepathSevr=chCCDCAM_FILEPATHSEVR.getw()
|
|
filepathStat=chCCDCAM_FILEPATHSTAT.getw()
|
|
while filepathSevr!=0 or filepathStat!=0:
|
|
print "I am setting the filepath again"
|
|
print filepathSevr
|
|
print filepathStat
|
|
chCCDCAM_FILEPATH.putWait(folderName,req_type=ca.DBF_CHAR)
|
|
filepathSevr=chCCDCAM_FILEPATHSEVR.getw()
|
|
filepathStat=chCCDCAM_FILEPATHSTAT.getw()
|
|
|
|
# Make the scan
|
|
if scanType=="2" or scanType=="6":
|
|
fasttomoscan(rotyMin,rotyMax,numberOfProjections,exposure,xLinIn,xLinOut,numberOfDarks,numberOfFlats,crystal1Pitch,scanType,millisecondShutter,rotationStage)
|
|
else:
|
|
fastdpcscan(rotyMin,rotyMax,numberOfProjections,exposure,xLinIn,xLinOut,numberOfDarks,numberOfFlats,gridStart,gridEnd,gridNSteps,crystal1Pitch,scanType,millisecondShutter,rotationStage)
|
|
|
|
# Set the scan start button to Stop
|
|
chGo.putWait(0)
|
|
chFilePrefix.putWait(baseName)
|
|
chCCDCAM_DELAY.putWait(delayStart)
|