def toggleLowMagCameraSettings(stateCode):
if (stateCode == "DA"):
lowMagExpTime = db_lib.getBeamlineConfigParam(daq_utils.beamline,"lowMagExptimeDA")
beamline_support.setPvValFromDescriptor("lowMagGain",25)
beamline_support.setPvValFromDescriptor("lowMagAcquireTime",lowMagExpTime)
else:
lowMagExpTime = db_lib.getBeamlineConfigParam(daq_utils.beamline,"lowMagExptime")
beamline_support.setPvValFromDescriptor("lowMagGain",1)
beamline_support.setPvValFromDescriptor("lowMagAcquireTime",lowMagExpTime)
def mountSample(sampID):
global mountCounter
warmUpNeeded = 0
if (db_lib.getBeamlineConfigParam(daq_utils.beamline,"queueCollect") == 1):
mountCounter+=1
if (mountCounter > db_lib.getBeamlineConfigParam(daq_utils.beamline,"robotWarmupInterval")):
warmUpNeeded = 1
mountedSampleDict = db_lib.beamlineInfo(daq_utils.beamline, 'mountedSample')
currentMountedSampleID = mountedSampleDict["sampleID"]
if (currentMountedSampleID != ""): #then unmount what's there
if (sampID!=currentMountedSampleID):
puckPos = mountedSampleDict["puckPos"]
pinPos = mountedSampleDict["pinPos"]
if (robot_lib.unmountRobotSample(puckPos,pinPos,currentMountedSampleID)):
db_lib.deleteCompletedRequestsforSample(currentMountedSampleID)
set_field("mounted_pin","")
db_lib.beamlineInfo(daq_utils.beamline, 'mountedSample', info_dict={'puckPos':0,'pinPos':0,'sampleID':""})
(puckPos,pinPos,puckID) = db_lib.getCoordsfromSampleID(daq_utils.beamline,sampID)
if (warmUpNeeded):
gui_message("Warming gripper. Please stand by.")
mountCounter = 0
mountStat = robot_lib.mountRobotSample(puckPos,pinPos,sampID,init=0,warmup=warmUpNeeded)
if (warmUpNeeded):
destroy_gui_message()
if (mountStat == 1):
set_field("mounted_pin",sampID)
elif(mountStat == 2):
return 2
else:
return 0
else:
return 0
else: #desired sample is mounted, nothing to do
return 1
else: #nothing mounted
(puckPos,pinPos,puckID) = db_lib.getCoordsfromSampleID(daq_utils.beamline,sampID)
mountStat = robot_lib.mountRobotSample(puckPos,pinPos,sampID,init=1)
if (mountStat == 1):
set_field("mounted_pin",sampID)
elif(mountStat == 2):
return 2
else:
return 0
db_lib.beamlineInfo(daq_utils.beamline, 'mountedSample', info_dict={'puckPos':puckPos,'pinPos':pinPos,'sampleID':sampID})
return 1
def runDialsObsolete(imgPath,reqID=None):
comm_s = "dials.find_spots_client " + imgPath
print(comm_s)
dialsResultObj = xmltodict.parse("<data>\n"+os.popen(comm_s).read()+"</data>\n")
print("done parsing dials output")
print(dialsResultObj)
currentRequestID = db_lib.getBeamlineConfigParam(beamline,'currentRequestID')
dialsResult = db_lib.addResultforRequest("dials",currentRequestID, owner=owner,result_obj=dialsResultObj)
def finish():
if (db_lib.getBeamlineConfigParam(daq_utils.beamline,'robot_online')):
try:
RobotControlLib.runCmd("finish")
return 1
except Exception as e:
e_s = str(e)
daq_lib.gui_message("ROBOT Finish ERROR: " + e_s)
print(e)
# daq_lib.gui_message(e)
return 0
def mvaDescriptor(*args): #convenience to get around nasty PV names
newArgsList = []
if (args[0] == "detectorDist"):
beamline_support.setPvValFromDescriptor("govRobotDetDist",
float(args[1]))
beamline_support.setPvValFromDescriptor("govHumanDetDist",
float(args[1]))
if (db_lib.getBeamlineConfigParam(daq_utils.beamline, "HePath") == 1):
return
for i in range(0, len(args), 2):
newArgsList.append(
beamline_support.pvNameSuffix_from_descriptor(args[i]))
newArgsList.append(float(args[i + 1]))
newArgs = tuple(newArgsList)
mva(*newArgs)
def center_on_click(x,y,fovx,fovy,source="screen",maglevel=0,jog=0): #maglevel=0 means lowmag, high fov, #1 = himag with digizoom option,
#source=screen = from screen click, otherwise from macro with full pixel dimensions
if (db_lib.getBeamlineConfigParam(daq_utils.beamline,'robot_online')): #so that we don't move things when robot moving?
robotGovState = (beamline_support.getPvValFromDescriptor("robotSaActive") or beamline_support.getPvValFromDescriptor("humanSaActive"))
if (not robotGovState):
return
# if (daq_utils.beamline == "amx"):
if (1):
if not (checkC2C_X(x,fovx)):
return
if (source == "screen"):
waitGovNoSleep()
beamline_support.setPvValFromDescriptor("image_X_scalePix",daq_utils.screenPixX) #these are video dimensions in the gui
beamline_support.setPvValFromDescriptor("image_Y_scalePix",daq_utils.screenPixY)
beamline_support.setPvValFromDescriptor("image_X_centerPix",daq_utils.screenPixX/2)
beamline_support.setPvValFromDescriptor("image_Y_centerPix",daq_utils.screenPixY/2)
beamline_support.setPvValFromDescriptor("image_X_scaleMM",float(fovx))
beamline_support.setPvValFromDescriptor("image_Y_scaleMM",float(fovy))
else:
if (int(maglevel)==0): #I think hardcoded to not use maglevel anymore, replaced with more flexible fov
beamline_support.setPvValFromDescriptor("image_X_scalePix",daq_utils.lowMagPixX)
beamline_support.setPvValFromDescriptor("image_Y_scalePix",daq_utils.lowMagPixY)
beamline_support.setPvValFromDescriptor("image_X_centerPix",daq_utils.lowMagPixX/2)
beamline_support.setPvValFromDescriptor("image_Y_centerPix",daq_utils.lowMagPixY/2)
beamline_support.setPvValFromDescriptor("image_X_scaleMM",float(fovx))
beamline_support.setPvValFromDescriptor("image_Y_scaleMM",float(fovy))
else:
beamline_support.setPvValFromDescriptor("image_X_scalePix",daq_utils.lowMagPixX)
beamline_support.setPvValFromDescriptor("image_Y_scalePix",daq_utils.lowMagPixY)
beamline_support.setPvValFromDescriptor("image_X_centerPix",daq_utils.highMagPixX/2)
beamline_support.setPvValFromDescriptor("image_Y_centerPix",daq_utils.highMagPixY/2)
beamline_support.setPvValFromDescriptor("image_X_scaleMM",float(fovx))
beamline_support.setPvValFromDescriptor("image_Y_scaleMM",float(fovy))
omega_mod = beamline_lib.motorPosFromDescriptor("omega")%360.0
# daq_utils.broadcast_output("\ncenter on x = %s, y = %s, omega = %f, phi = %f\n" % (x,y,omega_mod,0))
# xcheck = checkC2C_X(x,fovx)
# if (xcheck):
lib_gon_center_xtal(x,y,omega_mod,0)
if (jog):
beamline_lib.mvrDescriptor("omega",float(jog))
def collectData(currentRequest):
global data_directory_name,currentIspybDCID,fastDPNodeCount,fastDPNodeCounter
# print(currentRequest)
# print("pretending to collect")
# time.sleep(5)
# db_lib.updatePriority(currentRequest["uid"],-1)
# refreshGuiTree()
# return 1 #SHORT CIRCUIT
logMe = 1
reqObj = currentRequest["request_obj"]
data_directory_name = str(reqObj["directory"])
exposure_period = reqObj["exposure_time"]
wavelength = reqObj["wavelength"]
resolution = reqObj["resolution"]
slit_height = reqObj["slit_height"]
slit_width = reqObj["slit_width"]
attenuation = reqObj["attenuation"]
img_width = reqObj["img_width"]
file_prefix = str(reqObj["file_prefix"])
print(reqObj["protocol"])
prot = str(reqObj["protocol"])
sweep_start = reqObj["sweep_start"]
sweep_end = reqObj["sweep_end"]
range_degrees = abs(sweep_end-sweep_start)
sweep_start = reqObj["sweep_start"]%360.0
file_number_start = reqObj["file_number_start"]
basePath = reqObj["basePath"]
# jpegDirectory = "jpegs" + data_directory_name[data_directory_name.find(basePath)+len(basePath):len(data_directory_name)]
visitName = daq_utils.getVisitName()
jpegDirectory = visitName + "/jpegs/" + data_directory_name[data_directory_name.find(visitName)+len(visitName):len(data_directory_name)]
status = 1
if not (os.path.isdir(data_directory_name)):
comm_s = "mkdir -p " + data_directory_name
os.system(comm_s)
comm_s = "chmod 777 " + data_directory_name
os.system(comm_s)
comm_s = "mkdir -p " + jpegDirectory
os.system(comm_s)
comm_s = "chmod 777 " + jpegDirectory
os.system(comm_s)
if (prot == "raster"):
status = daq_macros.snakeRaster(currentRequest["uid"])
elif (prot == "stepRaster"):
status = daq_macros.snakeStepRaster(currentRequest["uid"])
elif (prot == "vector" or prot == "stepVector"):
if (reqObj["centeringOption"] != "Interactive"):
logMe = 0
daq_macros.autoVector(currentRequest)
else:
imagesAttempted = collect_detector_seq_hw(sweep_start,range_degrees,img_width,exposure_period,file_prefix,data_directory_name,file_number_start,currentRequest)
elif (prot == "multiCol"):
# daq_macros.multiCol(currentRequest)
daq_macros.snakeRaster(currentRequest["uid"])
elif (prot == "multiColQ"):
daq_macros.multiCol(currentRequest)
# daq_macros.snakeRaster(currentRequest["uid"])
elif (prot == "eScan"):
daq_macros.eScan(currentRequest)
else: #standard, screening, or edna - these may require autoalign, checking first
if (reqObj["pos_x"] != -999):
beamline_lib.mvaDescriptor("sampleX",reqObj["pos_x"])
beamline_lib.mvaDescriptor("sampleY",reqObj["pos_y"])
beamline_lib.mvaDescriptor("sampleZ",reqObj["pos_z"])
elif (reqObj["centeringOption"] == "Interactive"): #robotic, pause and let user center
pause_data_collection()
check_pause()
else:
print("autoRaster")
if not (daq_macros.autoRasterLoop(currentRequest)):
print("could not center sample")
db_lib.updatePriority(currentRequest["uid"],-1)
refreshGuiTree()
return 0
# if (not stateModule.gotoState("DataCollection")):
# print("State violation")
# db_lib.updatePriority(currentRequest["uid"],-1)
# refreshGuiTree()
# return 0
if (reqObj["protocol"] == "screen"):
screenImages = 2
screenRange = 90
range_degrees = img_width
for i in range (0,screenImages):
sweep_start = reqObj["sweep_start"]+(i*screenRange)
sweep_end = sweep_start+screenRange
# sweep_end = reqObj["sweep_end"]+(i*screenRange)
file_prefix = str(reqObj["file_prefix"]+"_"+str(i*screenRange))
data_directory_name = str(reqObj["directory"]) # for now
file_number_start = reqObj["file_number_start"]
beamline_lib.mvaDescriptor("omega",sweep_start)
if (1):
# if (beamline_support.getPvValFromDescriptor("gonDaqHwTrig")):
imagesAttempted = collect_detector_seq_hw(sweep_start,range_degrees,img_width,exposure_period,file_prefix,data_directory_name,file_number_start,currentRequest)
else:
imagesAttempted = collect_detector_seq(sweep_start,range_degrees,img_width,exposure_period,file_prefix,data_directory_name,file_number_start,currentRequest)
seqNum = int(detector_get_seqnum())
cbfComm = db_lib.getBeamlineConfigParam(daq_utils.beamline,"cbfComm")
cbfDir = data_directory_name+"/cbf"
comm_s = "mkdir -p " + cbfDir
os.system(comm_s)
hdfSampleDataPattern = data_directory_name+"/"+file_prefix+"_"
hdfRowFilepattern = hdfSampleDataPattern + str(int(float(seqNum))) + "_master.h5"
CBF_conversion_pattern = cbfDir + "/" + file_prefix+"_" + str(int(sweep_start))+".cbf"
comm_s = "eiger2cbf-linux " + hdfRowFilepattern
startIndex=1
endIndex = 1
node = db_lib.getBeamlineConfigParam(daq_utils.beamline,"spotNode1")
comm_s = "ssh -q " + node + " \"sleep 6;" + cbfComm + " " + hdfRowFilepattern + " " + str(startIndex) + ":" + str(endIndex) + " " + CBF_conversion_pattern + "\"&"
print(comm_s)
os.system(comm_s)
elif (reqObj["protocol"] == "characterize" or reqObj["protocol"] == "ednaCol"):
characterizationParams = reqObj["characterizationParams"]
index_success = daq_macros.dna_execute_collection3(0.0,img_width,2,exposure_period,data_directory_name+"/",file_prefix,1,-89.0,1,currentRequest)
# if (0):
if (index_success):
resultsList = db_lib.getResultsforRequest(currentRequest["uid"]) # because for testing I keep running the same request. Probably not in usual use.
results = resultsList[-2]
strategyResults = results["result_obj"]["strategy"]
stratStart = strategyResults["start"]
stratEnd = strategyResults["end"]
stratWidth = strategyResults["width"]
stratExptime = strategyResults["exptime"]
stratDetDist = strategyResults["detDist"]
sampleID = currentRequest["sample"]
tempnewStratRequest = daq_utils.createDefaultRequest(sampleID)
newReqObj = tempnewStratRequest["request_obj"]
newReqObj["sweep_start"] = stratStart
newReqObj["sweep_end"] = stratEnd
newReqObj["img_width"] = stratWidth
newReqObj["exposure_time"] = stratExptime
newReqObj["detDist"] = stratDetDist
newReqObj["directory"] = data_directory_name
newReqObj["pos_x"] = beamline_lib.motorPosFromDescriptor("sampleX")
newReqObj["pos_y"] = beamline_lib.motorPosFromDescriptor("sampleY")
newReqObj["pos_z"] = beamline_lib.motorPosFromDescriptor("sampleZ")
newReqObj["fastDP"] = reqObj["fastDP"] # this is where you might want a "new from old" request to carry over stuff like this.
newReqObj["fastEP"] = reqObj["fastEP"]
newReqObj["dimple"] = reqObj["dimple"]
newReqObj["xia2"] = reqObj["xia2"]
runNum = db_lib.incrementSampleRequestCount(sampleID)
reqObj["runNum"] = runNum
newStratRequest = db_lib.addRequesttoSample(sampleID,newReqObj["protocol"],daq_utils.owner,newReqObj,priority=0,proposalID=daq_utils.getProposalID())
if (reqObj["protocol"] == "ednaCol"):
db_lib.updatePriority(currentRequest["uid"],-1)
refreshGuiTree()
collectData(newStratRequest)
return 1
else: #standard
beamline_lib.mvaDescriptor("omega",sweep_start)
if (1):
# if (beamline_support.getPvValFromDescriptor("gonDaqHwTrig")):
imagesAttempted = collect_detector_seq_hw(sweep_start,range_degrees,img_width,exposure_period,file_prefix,data_directory_name,file_number_start,currentRequest)
else:
imagesAttempted = collect_detector_seq(sweep_start,range_degrees,img_width,exposure_period,file_prefix,data_directory_name,file_number_start,currentRequest)
try:
if (logMe):
logMxRequestParams(currentRequest)
except TypeError:
print("caught type error in logging")
if (prot == "vector" or prot == "standard"):
seqNum = int(detector_get_seqnum())
comm_s = os.environ["LSDCHOME"] + "/runSpotFinder4syncW.py " + data_directory_name + " " + file_prefix + " " + str(currentRequest["uid"]) + " " + str(seqNum) + " " + str(currentIspybDCID)+ "&"
print(comm_s)
os.system(comm_s)
if (reqObj["fastDP"]):
if (reqObj["fastEP"]):
fastEPFlag = 1
else:
fastEPFlag = 0
if (reqObj["dimple"]):
dimpleFlag = 1
else:
dimpleFlag = 0
# node = db_lib.getBeamlineConfigParam(daq_utils.beamline,"fastDPNode")
nodeName = "fastDPNode" + str((fastDPNodeCounter%fastDPNodeCount)+1)
fastDPNodeCounter+=1
node = db_lib.getBeamlineConfigParam(daq_utils.beamline,nodeName)
dimpleNode = db_lib.getBeamlineConfigParam(daq_utils.beamline,"dimpleNode")
if (daq_utils.detector_id == "EIGER-16"):
seqNum = int(detector_get_seqnum())
# seqNum = beamline_support.get_any_epics_pv("XF:17IDC-ES:FMX{Det:Eig16M}cam1:SequenceId","VAL")
comm_s = os.environ["LSDCHOME"] + "/runFastDPH5.py " + data_directory_name + " " + file_prefix + " " + str(seqNum) + " " + str(int(round(range_degrees/img_width))) + " " + str(currentRequest["uid"]) + " " + str(fastEPFlag) + " " + node + " " + str(dimpleFlag) + " " + dimpleNode + " " + str(currentIspybDCID)+ "&"
else:
comm_s = os.environ["LSDCHOME"] + "/runFastDP.py " + data_directory_name + " " + file_prefix + " " + str(file_number_start) + " " + str(int(round(range_degrees/img_width))) + " " + str(currentRequest["uid"]) + " " + str(fastEPFlag) + " " + node + " " + str(dimpleFlag) + " " + dimpleNode + "&"
print(comm_s)
os.system(comm_s)
if (reqObj["xia2"]):
comm_s = "ssh -q xf17id1-srv1 \"" + os.environ["LSDCHOME"] + "/runXia2.py " + data_directory_name + " " + file_prefix + " " + str(file_number_start) + " " + str(int(round(range_degrees/img_width))) + " " + str(currentRequest["uid"]) + "\"&"
# comm_s = os.environ["CBHOME"] + "/runXia2.py " + data_directory_name + " " + file_prefix + " " + str(file_number_start) + " " + str(int(round(range_degrees/img_width))) + " " + str(currentRequest["request_id"]) + "&"
os.system(comm_s)
db_lib.updatePriority(currentRequest["uid"],-1)
refreshGuiTree()
return status
conn = ispyb.open(conf_file)
core = ispyb.factory.create_data_area(ispyb.factory.DataAreaType.CORE, conn)
mxacquisition = ispyb.factory.create_data_area(
ispyb.factory.DataAreaType.MXACQUISITION, conn)
mxprocessing = ispyb.factory.create_data_area(
ispyb.factory.DataAreaType.MXPROCESSING, conn)
mxscreening = ispyb.factory.create_data_area(
ispyb.factory.DataAreaType.MXSCREENING, conn)
cnx = mysql.connector.connect(user='******',
password=os.environ['ISPYB_PASSWORD'],
host='ispyb-db-dev',
database='ispyb')
cursor = cnx.cursor()
beamline = os.environ["BEAMLINE_ID"]
detSeqNumPVNAME = db_lib.getBeamlineConfigParam(
beamline, "detSeqNumPVNAME"
) #careful - this pvname is stored in DB and in detControl.
detSeqNumPV = PV(detSeqNumPVNAME)
# Find the id for a particular
def queryOneFromDB(q):
cursor.execute(q)
try:
return list(cursor.fetchone())[0]
except TypeError:
return 0
def personIdFromLogin(loginName):
numimages = int(sys.argv[4])
request_id = sys.argv[5]
request=db_lib.getRequestByID(request_id)
owner=request["owner"]
runFastEP = int(sys.argv[6])
node = sys.argv[7]
runDimple = int(sys.argv[8])
dimpleNode = sys.argv[9]
ispybDCID = int(sys.argv[10])
expectedFilenameList = []
timeoutLimit = 600 #for now
prefix_long = directory+"/"+filePrefix+"_"+str(numstart)
hdfFilepattern = prefix_long+"_master.h5"
CBF_conversion_pattern = cbfDir + "/"+filePrefix + "_"
#comm_s = "ssh -q " + node + " \"cd " + runningDir +";source /home/jjakoncic/jean_fastdp_prep.sh;fast_dp -j 12 -J 12 -k 60 " + hdfFilepattern + "\""
fastdpComm = ";source " + os.environ["PROJDIR"] + "wrappers/fastDPWrap2;" + db_lib.getBeamlineConfigParam(os.environ["BEAMLINE_ID"],"fastdpComm")
#fastdpComm = db_lib.getBeamlineConfigParam(os.environ["BEAMLINE_ID"],"fastdpComm")
dimpleComm = db_lib.getBeamlineConfigParam(os.environ["BEAMLINE_ID"],"dimpleComm")
comm_s = "ssh -q " + node + " \"cd " + runningDir + fastdpComm + hdfFilepattern + "\""
#comm_s = "ssh -q " + node + " \"cd " + runningDir +";source /nfs/skinner/wrappers/fastDPWrap2;fast_dp -j 12 -J 12 -k 60 " + hdfFilepattern + "\""
#comm_s = "ssh -q " + node + " \"cd " + runningDir +";source /nfs/skinner/wrappers/fastDPWrap;/usr/local/crys-local/fast_dp/bin/fast_dp -J 16 -j 16 -k 70 " + hdfFilepattern + "\""
print(comm_s)
os.system(comm_s)
fastDPResultFile = runningDir+"/fast_dp.xml"
#fastDPResultFile = "/GPFS/CENTRAL/xf17id2/skinner/ispyb/fast_dp.xml"
#fd = open("fast_dp.xml")
fd = open(fastDPResultFile)
resultObj = xmltodict.parse(fd.read())
print("finished fast_dp")
print(resultObj)
import os
from epics import PV
import db_lib
def check_pid(pid):
try:
os.kill(pid, 0)
except OSError:
return False
else:
return True
returnStat = (os.system("$LSDCHOME/lsdcGui.py"))
if (returnStat == 0):
exit(
1
) #a normal termination, no further work needed, else figure out who is master and restart
beamline = os.environ["BEAMLINE_ID"]
beamlineComm = db_lib.getBeamlineConfigParam(beamline, "beamlineComm")
controlMaster_pv = PV(beamlineComm + "zinger_flag")
for i in range(0, 4):
if (returnStat == 0): #normal exit, else restart
break
currentMasterPid = controlMaster_pv.get()
if (check_pid(int(currentMasterPid))):
returnStat = (os.system("$LSDCHOME/lsdcGui.py"))
else:
returnStat = (os.system("$LSDCHOME/lsdcGui.py master"))
def getVisitName(): return db_lib.getBeamlineConfigParam(beamline,"visitName")
def getProposalID(): return db_lib.getBeamlineConfigParam(beamline,"proposal")
def init_environment():
global beamline,detector_id,mono_mot_code,has_beamline,has_xtalview,xtal_url,xtal_url_small,xtalview_user,xtalview_pass,det_type,has_dna,beamstop_x_pvname,beamstop_y_pvname,camera_offset,det_radius,lowMagFOVx,lowMagFOVy,highMagFOVx,highMagFOVy,lowMagPixX,lowMagPixY,highMagPixX,highMagPixY,screenPixX,screenPixY,screenPixCenterX,screenPixCenterY,screenProtocol,screenPhist,screenPhiend,screenWidth,screenDist,screenExptime,screenWave,screenReso,gonioPvPrefix,searchParams,screenEnergy,detectorOffline,imgsrv_host,imgsrv_port,beamlineComm,primaryDewarName,lowMagCamURL,highMagZoomCamURL,lowMagZoomCamURL,highMagCamURL,owner,dewarPlateMap
owner = getpass.getuser()
# owner = db_lib.getBeamlineConfigParam(beamline,"user")
primaryDewarName = db_lib.getBeamlineConfigParam(beamline,"primaryDewarName")
db_lib.setPrimaryDewarName(primaryDewarName)
dewarPlateMap = db_lib.getBeamlineConfigParam(beamline,"dewarPlateMap")
lowMagCamURL = db_lib.getBeamlineConfigParam(beamline,"lowMagCamURL")
highMagCamURL = db_lib.getBeamlineConfigParam(beamline,"highMagCamURL")
highMagZoomCamURL = db_lib.getBeamlineConfigParam(beamline,"highMagZoomCamURL")
lowMagZoomCamURL = db_lib.getBeamlineConfigParam(beamline,"lowMagZoomCamURL")
lowMagFOVx = float(db_lib.getBeamlineConfigParam(beamline,"lowMagFOVx"))
lowMagFOVy = float(db_lib.getBeamlineConfigParam(beamline,"lowMagFOVy"))
highMagFOVx = float(db_lib.getBeamlineConfigParam(beamline,"highMagFOVx")) #digizoom will be this/2
highMagFOVy = float(db_lib.getBeamlineConfigParam(beamline,"highMagFOVy"))
lowMagPixX = float(db_lib.getBeamlineConfigParam(beamline,"lowMagPixX")) #for automated images
lowMagPixY = float(db_lib.getBeamlineConfigParam(beamline,"lowMagPixY"))
highMagPixX = float(db_lib.getBeamlineConfigParam(beamline,"highMagPixX")) #for automated images
highMagPixY = float(db_lib.getBeamlineConfigParam(beamline,"highMagPixY"))
screenPixX = float(db_lib.getBeamlineConfigParam(beamline,"screenPixX"))
screenPixY = float(db_lib.getBeamlineConfigParam(beamline,"screenPixY"))
beamlineComm = db_lib.getBeamlineConfigParam(beamline,"beamlineComm")
screenPixCenterX = screenPixX/2.0
screenPixCenterY = screenPixY/2.0
gonioPvPrefix = db_lib.getBeamlineConfigParam(beamline,"gonioPvPrefix")
detector_id = db_lib.getBeamlineConfigParam(beamline,"detector_id")
det_radius = db_lib.getBeamlineConfigParam(beamline,"detRadius")
# if (detector_id == "ADSC-Q315"):
# det_radius = 157.5
# elif (detector_id == "ADSC-Q210"):
# det_radius = 105.0
# elif (detector_id == "PILATUS-6"):
# det_radius = 212.0
# elif (detector_id == "EIGER-16"):
# det_radius = 155.0
# else: #default eiger 16
# det_radius = 155.0
det_type = db_lib.getBeamlineConfigParam(beamline,"detector_type")
imgsrv_port = db_lib.getBeamlineConfigParam(beamline,"imgsrv_port")
imgsrv_host = db_lib.getBeamlineConfigParam(beamline,"imgsrv_host")
has_dna = int(db_lib.getBeamlineConfigParam(beamline,"has_edna"))
has_beamline = int(db_lib.getBeamlineConfigParam(beamline,"has_beamline"))
detectorOffline = int(db_lib.getBeamlineConfigParam(beamline,"detector_offline"))
has_xtalview = int(db_lib.getBeamlineConfigParam(beamline,"has_xtalview"))
camera_offset = float(db_lib.getBeamlineConfigParam(beamline,"camera_offset"))
if (has_xtalview):
xtal_url_small = db_lib.getBeamlineConfigParam(beamline,"xtal_url_small")
xtal_url = db_lib.getBeamlineConfigParam(beamline,"xtal_url")
mono_mot_code = db_lib.getBeamlineConfigParam(beamline,"mono_mot_code")
screenProtocol = db_lib.getBeamlineConfigParam(beamline,"screen_default_protocol")
screenPhist = float(db_lib.getBeamlineConfigParam(beamline,"screen_default_phist"))
screenPhiend = float(db_lib.getBeamlineConfigParam(beamline,"screen_default_phi_end"))
screenWidth = float(db_lib.getBeamlineConfigParam(beamline,"screen_default_width"))
screenDist = float(db_lib.getBeamlineConfigParam(beamline,"screen_default_dist"))
screenExptime = float(db_lib.getBeamlineConfigParam(beamline,"screen_default_time"))
screenReso = float(db_lib.getBeamlineConfigParam(beamline,"screen_default_reso"))
screenWave = float(db_lib.getBeamlineConfigParam(beamline,"screen_default_wave"))
screenEnergy = float(db_lib.getBeamlineConfigParam(beamline,"screen_default_energy"))
screenbeamWidth = float(db_lib.getBeamlineConfigParam(beamline,"screen_default_beamWidth"))
screenbeamHeight = float(db_lib.getBeamlineConfigParam(beamline,"screen_default_beamHeight"))
screenTransmissionPercent = float(db_lib.getBeamlineConfigParam(beamline,"screen_transmission_percent"))
beamstop_x_pvname = db_lib.getBeamlineConfigParam(beamline,"beamstop_x_pvname")
beamstop_y_pvname = db_lib.getBeamlineConfigParam(beamline,"beamstop_y_pvname")
# varname = "HAS_XTALVIEW"
# if varname in os.environ:
# has_xtalview = int(os.environ[varname])
varname = "DETECTOR_OFFLINE"
if varname in os.environ:
detectorOffline = int(os.environ[varname])
def insertResult(result,
resultType,
request,
visitName,
dc_id=None,
xmlFileName=None): #xmlfilename for fastDP
#keep in mind that request type can be standard and result type be fastDP - multiple results per req.
try:
sessionid = core.retrieve_visit_id(visitName)
except ISPyBNoResultException as e:
logger.error(
"insert result - caught ISPyBNoResultException: '%s'. make sure visit name is in the format mx999999-1234. NOT HAVING MX IN FRONT IS A SIGN OF PROBLEMS - try newVisit() in that case."
% e)
propNum = visitName.split('-')[0]
sessionid = createVisit(propNum)
request_type = request['request_type']
if request_type in ('standard', 'vector'):
sample = request[
'sample'] # this needs to be created and linked to a DC group
if (resultType == 'fastDP'):
mx_data_reduction_dict = xml_file_to_dict(xmlFileName)
(app_id, ap_id, scaling_id,
integration_id) = mx_data_reduction_to_ispyb(
mx_data_reduction_dict, dc_id, mxprocessing)
mxprocessing.upsert_program_ex(program_id=app_id, status=1)
elif resultType == 'mxExpParams':
result_obj = result['result_obj']
request_obj = result_obj['requestObj']
directory = request_obj["directory"]
filePrefix = request_obj['file_prefix']
basePath = request_obj["basePath"]
visitName = daq_utils.getVisitName()
jpegDirectory = visitName + "/jpegs/" + directory[
directory.find(visitName) + len(visitName):len(directory)]
fullJpegDirectory = basePath + "/" + jpegDirectory
jpegImagePrefix = fullJpegDirectory + "/" + filePrefix
daq_utils.take_crystal_picture(filename=jpegImagePrefix)
jpegImageFilename = jpegImagePrefix + ".jpg"
jpegImageThumbFilename = jpegImagePrefix + "t.jpg"
node = db_lib.getBeamlineConfigParam(beamline, "adxvNode")
comm_s = f"ssh -q {node} \"{os.environ['MXPROCESSINGSCRIPTSDIR']}resize.sh {jpegImageFilename} {jpegImageThumbFilename} 40% \"&"
logger.info('resizing image: %s' % comm_s)
os.system(comm_s)
seqNum = int(detSeqNumPV.get())
node = db_lib.getBeamlineConfigParam(beamline, "adxvNode")
request_id = result['request']
comm_s = f"ssh -q {node} \"{os.environ['MXPROCESSINGSCRIPTSDIR']}eiger2cbf.sh {request_id} 1 1 0 {seqNum}\""
logger.info(f'diffraction thumbnail conversion to cbf: {comm_s}')
os.system(comm_s)
comm_s = f"ssh -q {node} \"{os.environ['MXPROCESSINGSCRIPTSDIR']}cbf2jpeg.sh {request_id}\""
logger.info(f'diffraction thumbnail conversion to jpeg: {comm_s}')
os.system(comm_s)
# Create a new data collection group entry:
params = mxacquisition.get_data_collection_group_params()
params['parentid'] = sessionid
if request_type == 'standard':
params['experimenttype'] = 'OSC'
elif request_type == 'vector':
params['experimenttype'] = 'Helical'
return createDataCollection(directory, filePrefix,
jpegImageFilename, params, request_obj,
sessionid)
def getBlConfig(param):
return db_lib.getBeamlineConfigParam(beamline, param)
def unmountRobotSample(puckPos,pinPos,sampID): #will somehow know where it came from
# absPos = (pinsPerPuck*puckPos)+pinPos+1
absPos = (pinsPerPuck*(puckPos%3))+pinPos+1
robotOnline = db_lib.getBeamlineConfigParam(daq_utils.beamline,'robot_online')
print("robot online = " + str(robotOnline))
if (robotOnline):
detDist = beamline_lib.motorPosFromDescriptor("detectorDist")
if (detDist<199.0):
beamline_support.setPvValFromDescriptor("govRobotDetDistOut",200.0)
beamline_support.setPvValFromDescriptor("govHumanDetDistOut",200.0)
daq_lib.setRobotGovState("SE")
print("unmounting " + str(puckPos) + " " + str(pinPos) + " " + str(sampID))
print("absPos = " + str(absPos))
platePos = int(puckPos/3)
rotMotTarget = daq_utils.dewarPlateMap[platePos][0]
rotCP = beamline_lib.motorPosFromDescriptor("dewarRot")
print("dewar target,CP")
print(rotMotTarget,rotCP)
if (abs(rotMotTarget-rotCP)>1):
print("rot dewar")
try:
RobotControlLib.runCmd("park")
except Exception as e:
e_s = str(e)
daq_lib.gui_message("ROBOT park ERROR: " + e_s)
print(e)
return 0
beamline_lib.mvaDescriptor("dewarRot",rotMotTarget)
try:
par_init=(beamline_support.get_any_epics_pv("SW:RobotState","VAL")!="Ready")
par_cool=(beamline_support.getPvValFromDescriptor("gripTemp")>-170)
if par_cool == False and daq_utils.beamline == "fmx":
time.sleep(3)
RobotControlLib.unmount1(init=par_init,cooldown=par_cool)
except Exception as e:
e_s = str(e)
daq_lib.gui_message("ROBOT unmount ERROR: " + e_s)
print(e)
return 0
detDist = beamline_lib.motorPosFromDescriptor("detectorDist")
if (detDist<200.0):
beamline_lib.mvaDescriptor("detectorDist",200.0)
if (beamline_lib.motorPosFromDescriptor("detectorDist") < 199.0):
print("ERROR - Detector < 200.0!")
return 0
try:
RobotControlLib.unmount2(absPos)
except Exception as e:
e_s = str(e)
if (e_s.find("Fatal") != -1):
daq_macros.robotOff()
daq_macros.disableMount()
daq_lib.gui_message(e_s + ". FATAL ROBOT ERROR - CALL STAFF! robotOff() executed.")
return 0
daq_lib.gui_message("ROBOT unmount2 ERROR: " + e_s)
print(e)
return 0
if (not daq_lib.waitGovRobotSE()):
daq_lib.clearMountedSample()
print("could not go to SE")
return 0
return 1
# visit = sys.argv[1]
#visit = 'mx30816-1'
visit = 'mx99999-1'
# Get a list of request dicts
#request_dicts = lsdb2.getColRequestsByTimeInterval('2018-02-14T00:00:00','2018-02-15T00:00:00')
# Connect to ISPyB, get the relevant data area objects
conn = ispyb.open(conf_file)
core = ispyb.factory.create_data_area(ispyb.factory.DataAreaType.CORE, conn)
mxacquisition = ispyb.factory.create_data_area(ispyb.factory.DataAreaType.MXACQUISITION, conn)
mxprocessing = ispyb.factory.create_data_area(ispyb.factory.DataAreaType.MXPROCESSING, conn)
mxscreening = ispyb.factory.create_data_area(ispyb.factory.DataAreaType.MXSCREENING, conn)
cnx = mysql.connector.connect(user='******', password='******',host='ispyb-db-dev',database='ispyb')
cursor = cnx.cursor()
beamline = os.environ["BEAMLINE_ID"]
detSeqNumPVNAME = db_lib.getBeamlineConfigParam(beamline,"detSeqNumPVNAME") #careful - this pvname is stored in DB and in detControl.
detSeqNumPV = PV(detSeqNumPVNAME)
# Find the id for a particular
def queryOneFromDB(q):
cursor.execute(q)
try:
return list(cursor.fetchone())[0]
except TypeError:
return 0
def personIdFromLogin(loginName):
q = ("select personId from Person where login = \""+ loginName + "\"")
return (queryOneFromDB(q))
def mountRobotSample(puckPos,pinPos,sampID,init=0,warmup=0):
global retryMountCount
# absPos = (pinsPerPuck*puckPos)+pinPos+1
absPos = (pinsPerPuck*(puckPos%3))+pinPos+1
if (db_lib.getBeamlineConfigParam(daq_utils.beamline,'robot_online')):
if (not daq_lib.waitGovRobotSE()):
daq_lib.setGovRobotSE()
print("mounting " + str(puckPos) + " " + str(pinPos) + " " + str(sampID))
print("absPos = " + str(absPos))
platePos = int(puckPos/3)
rotMotTarget = daq_utils.dewarPlateMap[platePos][0]
rotCP = beamline_lib.motorPosFromDescriptor("dewarRot")
print("dewar target,CP")
print(rotMotTarget,rotCP)
if (abs(rotMotTarget-rotCP)>1):
print("rot dewar")
try:
if (init == 0):
RobotControlLib.runCmd("park")
except Exception as e:
e_s = str(e)
daq_lib.gui_message("ROBOT Park ERROR: " + e_s)
print(e)
return 0
beamline_lib.mvaDescriptor("dewarRot",rotMotTarget)
try:
if (init):
beamline_support.setPvValFromDescriptor("boostSelect",0)
if (beamline_support.getPvValFromDescriptor("sampleDetected") == 0): #reverse logic, 0 = true
beamline_support.setPvValFromDescriptor("boostSelect",1)
else:
# if (beamline_support.getPvValFromDescriptor("gripTemp") > 20.0): #gripper warm
robotStatus = beamline_support.get_any_epics_pv("SW:RobotState","VAL")
if (robotStatus != "Ready"):
if (daq_utils.beamline == "fmx"):
daq_macros.homePins()
time.sleep(3.0)
if (not daq_lib.setGovRobotSE()):
return
RobotControlLib.mount(absPos)
else:
if (warmup):
RobotControlLib._mount(absPos,warmup=True)
else:
RobotControlLib._mount(absPos)
daq_lib.setGovRobotSA()
return 1
except Exception as e:
print(e)
e_s = str(e)
if (e_s.find("Fatal") != -1):
daq_macros.robotOff()
daq_macros.disableMount()
daq_lib.gui_message(e_s + ". FATAL ROBOT ERROR - CALL STAFF! robotOff() executed.")
return 0
if (e_s.find("tilted") != -1 or e_s.find("Load Sample Failed") != -1):
if (db_lib.getBeamlineConfigParam(daq_utils.beamline,"queueCollect") == 0):
daq_lib.gui_message(e_s + ". Try mounting again")
return 0
else:
if (retryMountCount == 0):
retryMountCount+=1
mountStat = mountRobotSample(puckPos,pinPos,sampID,init)
if (mountStat == 1):
retryMountCount = 0
return mountStat
else:
retryMountCount = 0
daq_lib.gui_message("ROBOT: Could not recover from " + e_s)
return 2
daq_lib.gui_message("ROBOT mount ERROR: " + e_s)
return 0
return 1
else:
return 1
def insertResult(result,resultType,request,visitName,dc_id=None,xmlFileName=None): #xmlfilename for fastDP
#keep in mind that request type can be standard and result type be fastDP - multiple results per req.
cbfComm = db_lib.getBeamlineConfigParam(daq_utils.beamline,"cbfComm")
try:
sessionid = core.retrieve_visit_id(visitName)
except ISPyBNoResultException:
print("caught ISPyBNoResultException")
sessionid = createVisit(visitName)
request_type = request['request_type']
if request_type in('standard', 'vector') :
sample = request['sample'] # this needs to be created and linked to a DC group
if (resultType == 'fastDP'):
mx_data_reduction_dict = xml_file_to_dict(xmlFileName)
(app_id, ap_id, scaling_id, integration_id) = mx_data_reduction_to_ispyb(mx_data_reduction_dict, dc_id, mxprocessing)
elif resultType == 'mxExpParams':
result_obj = result['result_obj']
request_obj = result_obj['requestObj']
directory = request_obj["directory"]
filePrefix = request_obj['file_prefix']
basePath = request_obj["basePath"]
visitName = daq_utils.getVisitName()
jpegDirectory = visitName + "/jpegs/" + directory[directory.find(visitName)+len(visitName):len(directory)]
# jpegDirectory = "jpegs" + directory[directory.find(basePath)+len(basePath):len(directory)]
fullJpegDirectory = basePath + "/" + jpegDirectory
jpegImagePrefix = fullJpegDirectory+"/"+filePrefix
daq_utils.take_crystal_picture(filename=jpegImagePrefix)
jpegImageFilename = jpegImagePrefix+".jpg"
jpegImageThumbFilename = jpegImagePrefix+"t.jpg"
node = db_lib.getBeamlineConfigParam(daq_utils.beamline,"adxvNode")
# node = db_lib.getBeamlineConfigParam(daq_utils.beamline,"spotNode1")
comm_s = "ssh -q " + node + " \"convert " + jpegImageFilename + " -resize 40% " + jpegImageThumbFilename + "\"&"
print(comm_s)
os.system(comm_s)
# seqNum = int(det_lib.detector_get_seqnum())
seqNum = int(detSeqNumPV.get())
hdfSampleDataPattern = directory+"/"+filePrefix+"_"
hdfRowFilepattern = hdfSampleDataPattern + str(int(float(seqNum))) + "_master.h5"
#jpeg folder cbfDir = os.getcwd()+"/jpegs/"+directory[len(os.getcwd()):len(directory)] #good luck with that working
# keep in mind I could do the jpeg conversion here, but maybe best to allow synchWeb on demand.
cbfDir = directory
CBF_conversion_pattern = cbfDir + "/" + filePrefix+"_"
JPEG_conversion_pattern = fullJpegDirectory + "/" + filePrefix+"_"
node = db_lib.getBeamlineConfigParam(daq_utils.beamline,"adxvNode")
# node = db_lib.getBeamlineConfigParam(daq_utils.beamline,"spotNode1")
adxvComm = os.environ["PROJDIR"] + db_lib.getBeamlineConfigParam(daq_utils.beamline,"adxvComm")
comm_s = "ssh -q " + node + " \"sleep 6;" + cbfComm + " " + hdfRowFilepattern + " 1 " + CBF_conversion_pattern + "0001.cbf;" + adxvComm + " -sa " + CBF_conversion_pattern + "0001.cbf " + JPEG_conversion_pattern + "0001.jpeg;convert " + JPEG_conversion_pattern + "0001.jpeg -resize 10% " + JPEG_conversion_pattern + "0001.thumb.jpeg\"&"
# comm_s = "ssh -q " + node + " \"sleep 6;" + cbfComm + " " + hdfRowFilepattern + " 1 " + CBF_conversion_pattern + "0001.cbf;" + adxvComm + " -sa " + CBF_conversion_pattern + "0001.cbf " + JPEG_conversion_pattern + "0001.jpeg;cp " + JPEG_conversion_pattern + "0001.jpeg " + JPEG_conversion_pattern + "0001.thumb.jpeg\"&"
print(comm_s)
os.system(comm_s)
# Create a new data collection group entry:
params = mxacquisition.get_data_collection_group_params()
params['parentid'] = sessionid
# params['sampleid'] = ?
if request_type == 'standard':
params['experimenttype'] = 'OSC'
elif request_type == 'vector':
params['experimenttype'] = 'Helical'
params['starttime'] = datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d %H:%M:%S')
params['endtime'] = datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d %H:%M:%S')
# params['starttime'] = datetime.fromtimestamp(request['time']).strftime('%Y-%m-%d %H:%M:%S')
# params['endtime'] = datetime.fromtimestamp(request['time']).strftime('%Y-%m-%d %H:%M:%S')
dcg_id = mxacquisition.insert_data_collection_group(list(params.values()))
print("dcg_id: %i" % dcg_id)
params = mxacquisition.get_data_collection_params()
params['parentid'] = dcg_id
params['visitid'] = sessionid
params['imgdir'] = directory
params['imgprefix'] = filePrefix
params['imgsuffix'] = 'cbf' # assume CBF ...?
params['wavelength'] = request_obj['wavelength']
params['starttime'] = datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d %H:%M:%S')
# params['starttime'] = datetime.fromtimestamp(request['time']).strftime('%Y-%m-%d %H:%M:%S')
params['run_status'] = 'DataCollection Successful' # assume success / not aborted
params['datacollection_number'] = request_obj['runNum']
params['n_images'] = int(round((request_obj['sweep_end'] - request_obj['sweep_start']) / request_obj['img_width']))
params['exp_time'] = request_obj['exposure_time']
params['start_image_number'] = request_obj['file_number_start']
params['axis_start'] = request_obj['sweep_start']
params['axis_end'] = request_obj['sweep_end']
params['axis_range'] = request_obj['img_width']
params['resolution'] = request_obj['resolution']
params['detector_distance'] = request_obj['detDist']
params['slitgap_horizontal'] = request_obj['slit_width']
params['slitgap_vertical'] = request_obj['slit_height']
params['transmission'] = request_obj['attenuation']
params['file_template'] = '%s_####.cbf' % (request_obj['file_prefix']) # assume cbf ...
# params['file_template'] = '%s_%s_####.cbf' % (request_obj['file_prefix'], request_obj['runNum']) # assume cbf ...
# params['flux'] = ?
params['overlap'] = 0.0
params['rotation_axis'] = 'Omega' # assume Omega unless we know otherwise
print("jpegimfilename = " + jpegImageFilename)
params['xtal_snapshot1'] = jpegImageFilename
# params['xtal_snapshot1'] = '/dls/i03/data/2016/cm14451-2/jpegs/20160413/test_xtal/xtal1_1_1_0.0.png'
params['xtal_snapshot2'] = '/dls/i03/data/2016/cm14451-2/jpegs/20160413/test_xtal/xtal1_1_1_90.0.png'
params['xtal_snapshot3'] = '/dls/i03/data/2016/cm14451-2/jpegs/20160413/test_xtal/xtal1_3_1_183.0.png'
params['xtal_snapshot4'] = '/dls/i03/data/2016/cm14451-2/jpegs/20160413/test_xtal/xtal1_3_1_93.0.png'
dc_id = mxacquisition.insert_data_collection(list(params.values()))
print("dc_id: %i" % dc_id)
return dc_id
def insertResult(result,
resultType,
request,
visitName,
dc_id=None,
xmlFileName=None): #xmlfilename for fastDP
#keep in mind that request type can be standard and result type be fastDP - multiple results per req.
cbfComm = db_lib.getBeamlineConfigParam(beamline, "cbfComm")
try:
sessionid = core.retrieve_visit_id(visitName)
except ISPyBNoResultException as e:
logger.error(
"caught ISPyBNoResultException: %s. make sure visit name is in the format mx999999-1234"
% e)
propNum = visitName.split('-')[0]
sessionid = createVisit(propNum)
request_type = request['request_type']
if request_type in ('standard', 'vector'):
sample = request[
'sample'] # this needs to be created and linked to a DC group
if (resultType == 'fastDP'):
mx_data_reduction_dict = xml_file_to_dict(xmlFileName)
(app_id, ap_id, scaling_id,
integration_id) = mx_data_reduction_to_ispyb(
mx_data_reduction_dict, dc_id, mxprocessing)
mxprocessing.upsert_program_ex(program_id=app_id, status=1)
elif resultType == 'mxExpParams':
result_obj = result['result_obj']
request_obj = result_obj['requestObj']
directory = request_obj["directory"]
filePrefix = request_obj['file_prefix']
basePath = request_obj["basePath"]
visitName = daq_utils.getVisitName()
jpegDirectory = visitName + "/jpegs/" + directory[
directory.find(visitName) + len(visitName):len(directory)]
fullJpegDirectory = basePath + "/" + jpegDirectory
jpegImagePrefix = fullJpegDirectory + "/" + filePrefix
daq_utils.take_crystal_picture(filename=jpegImagePrefix)
jpegImageFilename = jpegImagePrefix + ".jpg"
jpegImageThumbFilename = jpegImagePrefix + "t.jpg"
node = db_lib.getBeamlineConfigParam(beamline, "adxvNode")
comm_s = "ssh -q " + node + " \"convert " + jpegImageFilename + " -resize 40% " + jpegImageThumbFilename + "\"&"
logger.info('resizing image: %s' % comm_s)
os.system(comm_s)
seqNum = int(detSeqNumPV.get())
hdfSampleDataPattern = directory + "/" + filePrefix + "_"
hdfRowFilepattern = hdfSampleDataPattern + str(int(
float(seqNum))) + "_master.h5"
# keep in mind I could do the jpeg conversion here, but maybe best to allow synchWeb on demand.
cbfDir = directory
CBF_conversion_pattern = cbfDir + "/" + filePrefix + "_"
JPEG_conversion_pattern = fullJpegDirectory + "/" + filePrefix + "_"
node = db_lib.getBeamlineConfigParam(beamline, "adxvNode")
adxvComm = os.environ["PROJDIR"] + db_lib.getBeamlineConfigParam(
daq_utils.beamline, "adxvComm")
comm_s = "ssh -q " + node + " \"sleep 6;" + cbfComm + " " + hdfRowFilepattern + " 1:1 " + CBF_conversion_pattern + ";" + adxvComm + " -sa " + CBF_conversion_pattern + "000001.cbf " + JPEG_conversion_pattern + "0001.jpeg;convert " + JPEG_conversion_pattern + "0001.jpeg -resize 10% " + JPEG_conversion_pattern + "0001.thumb.jpeg\"&"
logger.info('diffraction thumbnail image: %s' % comm_s)
os.system(comm_s)
# Create a new data collection group entry:
params = mxacquisition.get_data_collection_group_params()
params['parentid'] = sessionid
if request_type == 'standard':
params['experimenttype'] = 'OSC'
elif request_type == 'vector':
params['experimenttype'] = 'Helical'
return createDataCollection(directory, filePrefix,
jpegImageFilename, params, request_obj,
sessionid)
def createDefaultRequest(sample_id):
"""
Doesn't really create a request, just returns a dictionary
with the default parameters that can be passed to addRequesttoSample().
But note that these then get overwritten anyway, and I no longer expose them in screen params dialog
"""
sample = db_lib.getSampleByID(sample_id)
try:
propNum = sample["proposalID"]
except KeyError:
propNum = 999999
if (propNum == None):
propNum = 999999
if (propNum != getProposalID()):
setProposalID(propNum)
screenPhist = float(db_lib.getBeamlineConfigParam(beamline,"screen_default_phist"))
screenPhiend = float(db_lib.getBeamlineConfigParam(beamline,"screen_default_phi_end"))
screenWidth = float(db_lib.getBeamlineConfigParam(beamline,"screen_default_width"))
screenDist = float(db_lib.getBeamlineConfigParam(beamline,"screen_default_dist"))
screenExptime = float(db_lib.getBeamlineConfigParam(beamline,"screen_default_time"))
screenReso = float(db_lib.getBeamlineConfigParam(beamline,"screen_default_reso"))
screenWave = float(db_lib.getBeamlineConfigParam(beamline,"screen_default_wave"))
screenEnergy = float(db_lib.getBeamlineConfigParam(beamline,"screen_default_energy"))
screenbeamWidth = float(db_lib.getBeamlineConfigParam(beamline,"screen_default_beamWidth"))
screenbeamHeight = float(db_lib.getBeamlineConfigParam(beamline,"screen_default_beamHeight"))
screenTransmissionPercent = float(db_lib.getBeamlineConfigParam(beamline,"screen_transmission_percent"))
sampleName = str(db_lib.getSampleNamebyID(sample_id))
basePath = os.getcwd()
runNum = db_lib.getSampleRequestCount(sample_id)
(puckPosition,samplePositionInContainer,containerID) = db_lib.getCoordsfromSampleID(beamline,sample_id)
request = {"sample": sample_id}
request["beamline"] = beamline
requestObj = {
"sample": sample_id,
"sweep_start": screenPhist, "sweep_end": screenPhiend,
"img_width": screenWidth,
"exposure_time": screenExptime,
"protocol": "standard",
"detDist": screenDist,
"parentReqID": -1,
"basePath": basePath,
"file_prefix": sampleName,
"directory": basePath+"/" + str(getVisitName()) + "/"+sampleName+"/" + str(runNum) + "/" +db_lib.getContainerNameByID(containerID)+"_"+str(samplePositionInContainer+1)+"/",
# "directory": basePath+"/" + str(getProposalID()) + "/"+sampleName+"/" + str(runNum) + "/" +db_lib.getContainerNameByID(containerID)+"_"+str(samplePositionInContainer+1)+"/",
"file_number_start": 1,
"energy":screenEnergy,
"wavelength": energy2wave(screenEnergy),
"resolution": screenReso,
"slit_height": screenbeamHeight, "slit_width": screenbeamWidth,
"attenuation": screenTransmissionPercent,
"pos_x": -999, "pos_y": 0, "pos_z": 0, "pos_type": 'A', "gridStep": 30}
request["request_obj"] = requestObj
return request
