From 98f3aba0ece852e5bacb038d1b267c3d916d7c06 Mon Sep 17 00:00:00 2001 From: vshekar1 Date: Thu, 6 Feb 2025 16:48:35 -0500 Subject: [PATCH] Remove references to PI scanner PI scanner is no longer used at FMX. It also uses old style PV changing to run the collection. If the scanner comes back its worth rewriting using bluesky --- Gen_Commands.py | 60 ----- Gen_Traj_Square.py | 59 ----- daq_macros.py | 590 +------------------------------------------- gui/control_main.py | 94 ++----- 4 files changed, 29 insertions(+), 774 deletions(-) delete mode 100644 Gen_Commands.py delete mode 100644 Gen_Traj_Square.py diff --git a/Gen_Commands.py b/Gen_Commands.py deleted file mode 100644 index 318273dd..00000000 --- a/Gen_Commands.py +++ /dev/null @@ -1,60 +0,0 @@ -import numpy as np -import epics -import logging -logger = logging.getLogger(__name__) - -#12/19 - skinner did not write this. -def gen_commands(traj,exptime): - - # The traj is a 3 x N array which contains the (x,y,z) positions of the trajectory - # The purpose of this function is generating three lists (for x, y, z, repectively). - # Each list contains a series of "WAV ... " commands to write - - size = traj.shape - - if size[0] != 3: - size = traj.transpose().shape - - commands = [ - 'WGC 0 1', - 'STP', - 'WTR 0 %d 1'% (exptime*20000,) - ] - - for j in range(3): - commands.append('WOS %d 0' % (j+1,)) - for i in range(int(np.floor(size[1]/2))): - SegLength = 2 - StartPoint = 0 - Amp = traj[j][i*2+1] - traj[j][i*2] - Offset = traj[j][i*2] - WaveLength = SegLength - SpeedUpDown = 0 - Replace = 'X' if i == 0 else '&' - commands.append("WAV %d %s LIN %d %.3f %.3f %d %d %d" % (j+1, Replace, SegLength, Amp, Offset, WaveLength, StartPoint, SpeedUpDown)) - commands.append('WSL %d %d' % (j+1,j+1)) - - oeos = epics.PV('XF:17IDC-CT:FMX{MC:21}Asyn.OEOS') - aout = epics.PV('XF:17IDC-CT:FMX{MC:21}Asyn.AOUT') - tmod = epics.PV('XF:17IDC-CT:FMX{MC:21}Asyn.TMOD') - - tmod.put('Write') - oeos.put('\n') - - for cmd in commands: -# logger.info(len(cmd),cmd) - aout.put(cmd, wait=True) - - tmod.put('Write/Read') - -def go_all(): - aout = epics.PV('XF:17IDC-CT:FMX{MC:21}Asyn.AOUT') - tmod = epics.PV('XF:17IDC-CT:FMX{MC:21}Asyn.TMOD') - - tmod.put('Write') - for n in range(1, 4): - logger.info("Arming waveform", n) - aout.put('WGO %d 0x102' % (n,), wait=True) - - tmod.put('Write/Read') - diff --git a/Gen_Traj_Square.py b/Gen_Traj_Square.py deleted file mode 100644 index 5d12526b..00000000 --- a/Gen_Traj_Square.py +++ /dev/null @@ -1,59 +0,0 @@ -import logging -logger = logging.getLogger(__name__) - -def gen_traj_square(x_start, x_end, y_start, y_end, z_start, z_end, col, row): -#12/19 skinner did not write this - # x/y/z_start/end are the definitions (in micron) of the raster area - # x_end - x_start should be positive - # step defines the step size of the raster and should be positive - import numpy as np - - # ========================================================================== - # may need a few lines of code to center the (0,0,0) of the piezo stage to - # the center of the raster area - # ========================================================================== - - x = x_end-x_start - # If the X size of the raster area is larger than 180 micron, return an error message - if np.abs(x) > 180: - logger.error('x range error') - return - - y = y_end-y_start - z = z_end-z_start - # If the Y size of the raster area is larger than 150 micron, return an error message - if np.abs(y) > 150: - logger.error('y range error') - return - - # If the Z size of the raster area is larger than 150 micron, return an error message - if np.abs(z) > 150: - logger.error('z range error') - return - - step = x / col - d = np.sqrt(y * y + z * z) - delta_y = y/(row-1) - delta_z = z/(row-1) - - x_traj_odd = np.arange(x_start, x_end, step) # x positions of the odd line - x_traj_even = np.arange(x_end, x_start, -step) # x positions of the even line - y_traj_unit = np.zeros(x_traj_odd.size) + y_start # y positions of the first line - z_traj_unit = np.zeros(x_traj_odd.size) + z_start # z positions of the first line - - x_traj = x_traj_odd # first line of the x - y_traj = y_traj_unit # first line of the y - z_traj = z_traj_unit # first line of the z - for i in range(np.int(row-1)): - if np.remainder(i, 2) == 0: # add (x,y,z) positions for the even lines - x_traj = np.append(x_traj, x_traj_even) - y_traj = np.append(y_traj, y_traj_unit + delta_y * (i+1)) - z_traj = np.append(z_traj, z_traj_unit + delta_z * (i+1)) - if np.remainder(i, 2) == 1: # add (x,y,z) positions for the odd lines - x_traj = np.append(x_traj, x_traj_odd) - y_traj = np.append(y_traj, y_traj_unit + delta_y * (i+1)) - z_traj = np.append(z_traj, z_traj_unit + delta_z * (i+1)) - - Traj = np.append([x_traj], [y_traj], 0) - Traj = np.append(Traj, [z_traj], 0) - return Traj diff --git a/daq_macros.py b/daq_macros.py index fdfbd986..9be51c5a 100644 --- a/daq_macros.py +++ b/daq_macros.py @@ -1,5 +1,3 @@ -import Gen_Commands -import Gen_Traj_Square import beamline_support from beamline_support import getPvValFromDescriptor as getPvDesc, setPvValFromDescriptor as setPvDesc import beamline_lib #did this really screw me if I imported b/c of daq_utils import?? @@ -614,10 +612,6 @@ def autoVector(currentRequest): #12/19 - not tested! return 1 def rasterScreen(currentRequest): - if (daq_utils.beamline == "fmx" and getBlConfig("scannerType") == "PI"): - gridRaster(currentRequest) - return - daq_lib.set_field("xrecRasterFlag","100") sampleID = currentRequest["sample"] reqObj = currentRequest["request_obj"] @@ -718,65 +712,6 @@ def loop_center_xrec_slow(): #now try to get the loopshape starting from here return 1 - -def generateRasterCoords4Traj(rasterRequest): - - reqObj = rasterRequest["request_obj"] - exptimePerCell = reqObj["exposure_time"] - rasterDef = reqObj["rasterDef"] - stepsize = float(rasterDef["stepsize"]) - omega = float(rasterDef["omega"]) - rasterStartX = float(rasterDef["x"]) - rasterStartY = float(rasterDef["y"]) - rasterStartZ = float(rasterDef["z"]) - omegaRad = math.radians(omega) - rasterCellMap = {} - numsteps = float(rasterDef["rowDefs"][0]["numsteps"]) - columns = numsteps - rows = len(rasterDef["rowDefs"]) - firstRow = rasterDef["rowDefs"][0] - sx1 = firstRow["start"]["x"] #startX - sy1 = firstRow["start"]["y"] - logger.info("start x,y") - logger.info(sx1) - logger.info(sy1) - -#9/18 - I think these are crap, but will leave them - xRelativeMove = sx1 - yzRelativeMove = sy1*math.sin(omegaRad) - yyRelativeMove = sy1*cos(omegaRad) - xMotAbsoluteMove1 = xRelativeMove - yMotAbsoluteMove1 = yyRelativeMove - zMotAbsoluteMove1 = yzRelativeMove - - - lastRow= rasterDef["rowDefs"][-1] - ex1 = lastRow["end"]["x"] #endX - ey1 = lastRow["end"]["y"] - logger.info("end x,y") - logger.info(ex1) - logger.info(ey1) - deltax = ex1-sx1 - deltay = ey1-sy1 - xMotAbsoluteMove1 = -(deltax/2.0) - xMotAbsoluteMove2 = (deltax/2.0) - yMotAbsoluteMove1 = -(deltay/2.0)*math.cos(omegaRad) - yMotAbsoluteMove2 = (deltay/2.0)*math.cos(omegaRad) - zMotAbsoluteMove1 = -(deltay/2.0)*math.sin(omegaRad) - zMotAbsoluteMove2 = (deltay/2.0)*math.sin(omegaRad) - - logger.info(xMotAbsoluteMove1) - logger.info(yMotAbsoluteMove1) - logger.info(zMotAbsoluteMove1) - logger.info(xMotAbsoluteMove2) - logger.info(yMotAbsoluteMove2) - logger.info(zMotAbsoluteMove2) - logger.info(stepsize) - genTraj = Gen_Traj_Square.gen_traj_square(xMotAbsoluteMove1, xMotAbsoluteMove2, yMotAbsoluteMove2, yMotAbsoluteMove1, zMotAbsoluteMove2, zMotAbsoluteMove1, columns,rows) - Gen_Commands.gen_commands(genTraj,exptimePerCell) - - - def generateGridMap(rasterRequest,rasterEncoderMap=None): #12/19 - there's some dials vs dozor stuff in here global rasterRowResultsList @@ -1293,363 +1228,11 @@ def getNodeName(node_type, row_index, num_nodes=8): #calculate node name based o return getBlConfig(node_config_name) def snakeRaster(rasterReqID,grain=""): - scannerType = getBlConfig("scannerType") - if (scannerType == "PI"): - snakeRasterFine(rasterReqID,grain) - else: - if daq_utils.beamline == "nyx": - yield from raster_plan_wrapped(rasterReqID) - else: - finalize_plan = finalize_wrapper(snakeRasterBluesky(rasterReqID,grain), bps.mv(raster_flyer.detector.cam.acquire, 0)) - yield from finalize_plan - #RE(snakeRasterBluesky(rasterReqID,grain)) - -def snakeRasterNoTile(rasterReqID,grain=""): - global dialsResultDict,rasterRowResultsList,processedRasterRowCount - - gov_status = gov_lib.setGovRobot(gov_robot, 'DA') - if not gov_status.success: - return - - rasterRequest = db_lib.getRequestByID(rasterReqID) - reqObj = rasterRequest["request_obj"] - parentReqID = reqObj["parentReqID"] - parentReqProtocol = "" - - if (parentReqID != -1): - parentRequest = db_lib.getRequestByID(parentReqID) - parentReqObj = parentRequest["request_obj"] - parentReqProtocol = parentReqObj["protocol"] - detDist = parentReqObj["detDist"] - data_directory_name = str(reqObj["directory"]) - os.system("mkdir -p " + data_directory_name) - filePrefix = str(reqObj["file_prefix"]) - file_number_start = reqObj["file_number_start"] - dataFilePrefix = reqObj["directory"]+"/"+reqObj["file_prefix"] - exptimePerCell = reqObj["exposure_time"] - img_width_per_cell = reqObj["img_width"] - wave = reqObj["wavelength"] - xbeam = getPvDesc("beamCenterX") * 0.075 - ybeam = getPvDesc("beamCenterY") * 0.075 - rasterDef = reqObj["rasterDef"] - stepsize = float(rasterDef["stepsize"]) - omega = float(rasterDef["omega"]) - rasterStartX = float(rasterDef["x"]) #these are real sample motor positions - rasterStartY = float(rasterDef["y"]) - rasterStartZ = float(rasterDef["z"]) - omegaRad = math.radians(omega) - rowCount = len(rasterDef["rowDefs"]) - rasterRowResultsList = [{} for i in range(0,rowCount)] - processedRasterRowCount = 0 - rasterEncoderMap = {} - totalImages = 0 -#get the center of the raster, in screen view, mm, relative to center - rows = rasterDef["rowDefs"] - numrows = len(rows) - rasterCenterScreenX = (rows[0]["start"]["x"]+rows[0]["end"]["x"])/2.0 - rasterCenterScreenY = ((rows[-1]["start"]["y"]+rows[0]["start"]["y"])/2.0)+(stepsize/2.0) - xRelativeMove = rasterCenterScreenX - yzRelativeMove = -(rasterCenterScreenY*math.sin(omegaRad)) - yyRelativeMove = -(rasterCenterScreenY*math.cos(omegaRad)) - - xMotAbsoluteMove = rasterStartX+xRelativeMove #note we convert relative to absolute moves, using the raster center that was saved in x,y,z - yMotAbsoluteMove = rasterStartY+yyRelativeMove - zMotAbsoluteMove = rasterStartZ+yzRelativeMove - - - beamline_lib.mvaDescriptor("sampleX",xMotAbsoluteMove,"sampleY",yMotAbsoluteMove,"sampleZ",zMotAbsoluteMove) - - #raster centered, now zero motors - beamline_lib.mvaDescriptor("fineX",0,"fineY",0,"fineZ",0) - for i in range(len(rasterDef["rowDefs"])): - numsteps = int(rasterDef["rowDefs"][i]["numsteps"]) - totalImages = totalImages+numsteps - rasterFilePrefix = dataFilePrefix + "_Raster" - - det_lib.detector_set_num_triggers(totalImages) - det_lib.detector_set_trigger_mode(3) - det_lib.detector_setImagesPerFile(numsteps) - daq_lib.detectorArm(omega,img_width_per_cell,totalImages,exptimePerCell,rasterFilePrefix,data_directory_name,file_number_start) #this waits - - zebraVecDaqSetup(omega,img_width_per_cell,exptimePerCell,totalImages,rasterFilePrefix,data_directory_name,file_number_start) - procFlag = int(getBlConfig("rasterProcessFlag")) - generateRasterCoords4Traj(rasterRequest) - total_exposure_time = exptimePerCell*totalImages - - setPvDesc("zebraPulseMax",totalImages) - vectorSync() - setPvDesc("vectorStartOmega",omega) - setPvDesc("vectorEndOmega",(img_width_per_cell*totalImages)+omega) - setPvDesc("vectorframeExptime",exptimePerCell*1000.0) - setPvDesc("vectorNumFrames",totalImages) - rasterFilePrefix = dataFilePrefix + "_Raster_" + str(i) - Gen_Commands.go_all() - setPvDesc("vectorGo",1) - vectorActiveWait() - vectorWait() - zebraWait() - #delete these - time.sleep(2.0) - det_lib.detector_stop_acquire() - det_lib.detector_wait() - beamline_lib.mvaDescriptor("fineX",0,"fineY",0,"fineZ",0) - if (daq_utils.beamline == "amxz"): - setPvDesc("zebraReset",1) - - if (procFlag): - if (daq_utils.beamline == "amx"): - rasterRowEncoderVals = {"x":getPvDesc("zebraEncX"),"y":getPvDesc("zebraEncY"),"z":getPvDesc("zebraEncZ"),"omega":getPvDesc("zebraEncOmega")} - for j in range (0,numsteps): - dataFileName = "%s_%06d.cbf" % (reqObj["directory"]+"/cbf/"+reqObj["file_prefix"]+"_Raster_"+str(i),(i*numsteps)+j+1) - imIndexStr = str((i*numsteps)+j+1) - rasterEncoderMap[dataFileName[:-4]] = {"x":rasterRowEncoderVals["x"][j],"y":rasterRowEncoderVals["y"][j],"z":rasterRowEncoderVals["z"][j],"omega":rasterRowEncoderVals["omega"][j]} - seqNum = int(det_lib.detector_get_seqnum()) - for i in range(len(rasterDef["rowDefs"])): - _thread.start_new_thread(runDialsThread,(rasterRequest["uid"], data_directory_name,filePrefix+"_Raster",i,numsteps,seqNum)) - else: - rasterRequestID = rasterRequest["uid"] - db_lib.updateRequest(rasterRequest) - db_lib.updatePriority(rasterRequestID,-1) - if (lastOnSample()): - gov_lib.setGovRobot(gov_robot, 'SA') - return 1 - - rasterTimeout = 600 - timerCount = 0 - while (1): - timerCount +=1 - if (timerCount>rasterTimeout): - break - time.sleep(1) - logger.info('rastering row processed: %s' % processedRasterRowCount) - if (processedRasterRowCount == rowCount): - break - if (daq_utils.beamline == "amx"): - rasterResult = generateGridMap(rasterRequest,rasterEncoderMap) #I think rasterRequest is entire request, of raster type + if daq_utils.beamline == "nyx": + yield from raster_plan_wrapped(rasterReqID) else: - rasterResult = generateGridMap(rasterRequest) - rasterRequest["request_obj"]["rasterDef"]["status"] = 2 - protocol = reqObj["protocol"] - logger.info("protocol = " + protocol) - if (protocol == "multiCol" or parentReqProtocol == "multiColQ"): - if (parentReqProtocol == "multiColQ"): - multiColThreshold = parentReqObj["diffCutoff"] - else: - multiColThreshold = reqObj["diffCutoff"] - gotoMaxRaster(rasterResult,multiColThreshold=multiColThreshold) - rasterRequestID = rasterRequest["uid"] - db_lib.updateRequest(rasterRequest) - - db_lib.updatePriority(rasterRequestID,-1) - daq_lib.set_field("xrecRasterFlag",rasterRequest["uid"]) - if (lastOnSample()): - gov_lib.setGovRobot(gov_robot, 'SA') - return 1 - - - -def snakeRasterFine(rasterReqID,grain=""): #12/19 - This is for the PI scanner. It was challenging to write. It was working the last time the scanner was on. - global dialsResultDict,rasterRowResultsList,processedRasterRowCount - - gov_status = gov_lib.setGovRobot(gov_robot, 'DA') - if not gov_status.success: - return - - rasterRequest = db_lib.getRequestByID(rasterReqID) - reqObj = rasterRequest["request_obj"] - rasterDef = reqObj["rasterDef"] - stepsize = float(rasterDef["stepsize"]) - data_directory_name = str(reqObj["directory"]) - filePrefix = str(reqObj["file_prefix"]) - file_number_start = reqObj["file_number_start"] - dataFilePrefix = reqObj["directory"]+"/"+reqObj["file_prefix"] - wave = reqObj["wavelength"] - xbeam = getPvDesc("beamCenterX") - ybeam = getPvDesc("beamCenterY") - processedRasterRowCount = 0 - totalImages = 0 -#get the center of the raster, in screen view, mm, relative to center - rows = rasterDef["rowDefs"] - numrows = len(rows) - origRasterCenterScreenX = (rows[0]["start"]["x"]+rows[0]["end"]["x"])/2.0 - origRasterCenterScreenY = ((rows[-1]["start"]["y"]+rows[0]["start"]["y"])/2.0)+(stepsize/2.0) - beamline_lib.mvaDescriptor("fineX",0,"fineY",0,"fineZ",0) - exptimePerCell = reqObj["exposure_time"] - img_width_per_cell = reqObj["img_width"] - omega = float(rasterDef["omega"]) - rasterStartX = float(rasterDef["x"]) - rasterStartY = float(rasterDef["y"]) - rasterStartZ = float(rasterDef["z"]) - omegaRad = math.radians(omega) - firstRow = rasterDef["rowDefs"][0] - lastRow= rasterDef["rowDefs"][-1] - sx1 = firstRow["start"]["x"] #startX - sy1 = firstRow["start"]["y"] - ex1 = lastRow["end"]["x"] #endX - ey1 = lastRow["end"]["y"] - rasterLenX = ex1-sx1 - rasterLenY = ey1-sy1 - omegaLimit = 40.0 - xLimit = 180.0 - yLimit = 120.0 - if (rasterLenXrasterTimeout): - break - time.sleep(1) - logger.info(processedRasterRowCount) - if (processedRasterRowCount == numberOfSubrasters): - break - rasterResult = generateGridMapFine(rasterRequest,rowsOfSubrasters=rowsOfSubrasters,columnsOfSubrasters=columnsOfSubrasters,rowsPerSubraster=rowsPerSubraster,cellsPerSubrasterRow=subrasterColumns) - - rasterRequest["request_obj"]["rasterDef"]["status"] = 2 - rasterRequestID = rasterRequest["uid"] - db_lib.updateRequest(rasterRequest) #so that it will fill heatmap? - db_lib.updatePriority(rasterRequestID,-1) - daq_lib.set_field("xrecRasterFlag",rasterRequest["uid"]) - if (lastOnSample()): - gov_lib.setGovRobot(gov_robot, 'SA') - return 1 - - + finalize_plan = finalize_wrapper(snakeRasterBluesky(rasterReqID,grain), bps.mv(raster_flyer.detector.cam.acquire, 0)) + yield from finalize_plan def snakeRasterNormal(rasterReqID,grain=""): global rasterRowResultsList,processedRasterRowCount @@ -2404,57 +1987,6 @@ def snakeStepRaster(rasterReqID,grain=""): #12/19 - only tested recently, but ap return 1 -def setGridRasterParams(xsep,ysep,xstep,ystep,sizex,sizey,stepsize): - """setGridRasterParams(xsep,ysep,xstep,ystep,sizex,sizey,stepsize)""" - db_lib.setBeamlineConfigParam("fmx","gridRasterXSep",float(xsep)) - db_lib.setBeamlineConfigParam("fmx","gridRasterYSep",float(ysep)) - db_lib.setBeamlineConfigParam("fmx","gridRasterXStep",int(xstep)) - db_lib.setBeamlineConfigParam("fmx","gridRasterYStep",int(ystep)) - db_lib.setBeamlineConfigParam("fmx","gridRasterSizeX",float(sizex)) - db_lib.setBeamlineConfigParam("fmx","gridRasterSizeY",float(sizey)) - db_lib.setBeamlineConfigParam("fmx","gridRasterStepsize",float(stepsize)) - -def printGridRasterParams(): - """printGridRasterParams()""" - - logger.info(db_lib.getBeamlineConfigParam("fmx","gridRasterXSep")) - logger.info(db_lib.getBeamlineConfigParam("fmx","gridRasterYSep")) - logger.info(db_lib.getBeamlineConfigParam("fmx","gridRasterXStep")) - logger.info(db_lib.getBeamlineConfigParam("fmx","gridRasterYStep")) - logger.info(db_lib.getBeamlineConfigParam("fmx","gridRasterSizeX")) - logger.info(db_lib.getBeamlineConfigParam("fmx","gridRasterSizeY")) - logger.info(db_lib.getBeamlineConfigParam("fmx","gridRasterStepsize")) - - -def gridRaster(currentRequest): - gov_status = gov_lib.setGovRobot(gov_robot, 'DA') - if not gov_status.success: - return - - sampleID = currentRequest["sample"] - reqObj = currentRequest["request_obj"] - omega = beamline_lib.motorPosFromDescriptor("omega") - omegaRad = math.radians(omega) - xwells = int(db_lib.getBeamlineConfigParam("fmx","gridRasterXStep")) - ywells = int(db_lib.getBeamlineConfigParam("fmx","gridRasterYStep")) - xsep = float(db_lib.getBeamlineConfigParam("fmx","gridRasterXSep")) - ysep = float(db_lib.getBeamlineConfigParam("fmx","gridRasterYSep")) - sizex = float(db_lib.getBeamlineConfigParam("fmx","gridRasterSizeX")) - sizey = float(db_lib.getBeamlineConfigParam("fmx","gridRasterSizeY")) - stepsize = float(db_lib.getBeamlineConfigParam("fmx","gridRasterStepsize")) - rasterStartX = beamline_lib.motorPosFromDescriptor("sampleX") #these are real sample motor positions - rasterStartY = beamline_lib.motorPosFromDescriptor("sampleY") - rasterStartZ = beamline_lib.motorPosFromDescriptor("sampleZ") - yzRelativeMove = ysep*math.sin(omegaRad) - yyRelativeMove = ysep*math.cos(omegaRad) - for i in range (0,ywells): - for j in range (0,xwells): - beamline_lib.mvaDescriptor("sampleX",rasterStartX+(j*xsep),"sampleY",rasterStartY+(i*yyRelativeMove),"sampleZ",rasterStartZ+(i*yzRelativeMove)) - beamline_lib.mvaDescriptor("omega",omega) - rasterReqID = defineRectRaster(currentRequest,sizex,sizey,stepsize) - RE(snakeRaster(rasterReqID)) - - def runRasterScan(currentRequest,rasterType="", width=0, height=0, step_size=10, omega_rel=0): #this actually defines and runs sampleID = currentRequest["sample"] if (rasterType=="Fine"): @@ -2996,113 +2528,10 @@ def eScan(energyScanRequest): daq_lib.set_field("choochResultFlag",choochResultID) def vectorZebraScan(vecRequest): - scannerType = getBlConfig("scannerType") - if (scannerType == "PI"): - vectorZebraScanFine(vecRequest) - else: - finalize_plan = finalize_wrapper(vectorZebraScanNormal(vecRequest), bps.mv(flyer.detector.cam.acquire, 0)) - yield from finalize_plan - - -def vectorZebraScanFine(vecRequest): - gov_status = gov_lib.setGovRobot(gov_robot, 'DA') - if not gov_status.success: - return - - reqObj = vecRequest["request_obj"] - file_prefix = str(reqObj["file_prefix"]) - data_directory_name = str(reqObj["directory"]) - file_number_start = reqObj["file_number_start"] - - sweep_start_angle = reqObj["sweep_start"] - sweep_end_angle = reqObj["sweep_end"] - imgWidth = reqObj["img_width"] - expTime = reqObj["exposure_time"] - numImages = int((sweep_end_angle - sweep_start_angle) / imgWidth) - x_vec_start=reqObj["vectorParams"]["vecStart"]["x"] - y_vec_start=reqObj["vectorParams"]["vecStart"]["y"] - z_vec_start=reqObj["vectorParams"]["vecStart"]["z"] - x_vec_end=reqObj["vectorParams"]["vecEnd"]["x"] - y_vec_end=reqObj["vectorParams"]["vecEnd"]["y"] - z_vec_end=reqObj["vectorParams"]["vecEnd"]["z"] + finalize_plan = finalize_wrapper(vectorZebraScanNormal(vecRequest), bps.mv(flyer.detector.cam.acquire, 0)) + yield from finalize_plan - xCenterCoarse = (x_vec_end+x_vec_start)/2.0 - yCenterCoarse = (y_vec_end+y_vec_start)/2.0 - zCenterCoarse = (z_vec_end+z_vec_start)/2.0 - beamline_lib.mvaDescriptor("sampleX",xCenterCoarse,"sampleY",yCenterCoarse,"sampleZ",zCenterCoarse) - xRelLen = x_vec_end-x_vec_start - xRelStart = -xRelLen/2.0 - xRelEnd = -xRelStart - yRelLen = y_vec_end-y_vec_start - yRelStart = -yRelLen/2.0 - yRelEnd = -yRelStart - zRelLen = z_vec_end-z_vec_start - zRelStart = -zRelLen/2.0 - zRelEnd = -zRelStart - - det_lib.detector_set_num_triggers(numImages) - det_lib.detector_set_trigger_mode(3) - det_lib.detector_setImagesPerFile(1000) - daq_lib.detectorArm(sweep_start_angle,imgWidth,numImages,expTime,file_prefix,data_directory_name,file_number_start) #this waits - - zebraVecDaqSetup(sweep_start_angle,imgWidth,expTime,numImages,file_prefix,data_directory_name,file_number_start) - - - total_exposure_time=expTime*numImages - trajPoints = int(total_exposure_time/.005) - totalScanWidthX = xRelLen - totalScanWidthY = yRelLen - totalScanWidthZ = zRelLen - xRelativeMoveFine = xRelStart - yRelativeMoveFine = yRelStart - zRelativeMoveFine = zRelStart - beamline_lib.mvaDescriptor("fineX",xRelativeMoveFine,"fineY",yRelativeMoveFine,"fineZ",zRelativeMoveFine) - setPvDesc("fineXPoints",trajPoints) - setPvDesc("fineYPoints",trajPoints) - setPvDesc("fineZPoints",trajPoints) - setPvDesc("fineXAmp",totalScanWidthX) - setPvDesc("fineYAmp",totalScanWidthY) - setPvDesc("fineZAmp",totalScanWidthZ) - setPvDesc("fineXOffset",xRelativeMoveFine) - setPvDesc("fineYOffset",yRelativeMoveFine) - setPvDesc("fineZOffset",zRelativeMoveFine) - setPvDesc("fineXSendWave",1) - time.sleep(0.1) - setPvDesc("fineYSendWave",1) - time.sleep(0.1) - setPvDesc("fineZSendWave",1) - time.sleep(0.1) - #move xyz fine mots to relative from centered raster - setPvDesc("fineXVecGo",1) - time.sleep(0.1) - setPvDesc("fineYVecGo",1) - time.sleep(0.1) - setPvDesc("fineZVecGo",1) - time.sleep(0.1) - setPvDesc("zebraPulseMax",numImages) #moved this - vectorSync() - setPvDesc("vectorStartOmega",sweep_start_angle) - setPvDesc("vectorEndOmega",sweep_end_angle) - setPvDesc("vectorframeExptime",expTime*1000.0) - setPvDesc("vectorNumFrames",numImages) - setPvDesc("vectorGo",1) - vectorActiveWait() - vectorWait() - zebraWait() - zebraWaitDownload(numImages) - time.sleep(2.0) - det_lib.detector_stop_acquire() - det_lib.detector_wait() - if (daq_utils.beamline == "amxz"): - setPvDesc("zebraReset",1) - - #raster centered, now zero motors - beamline_lib.mvaDescriptor("fineX",0,"fineY",0,"fineZ",0) - - if (lastOnSample()): - gov_lib.setGovRobot(gov_robot, 'SA') - def vectorZebraScanNormal(vecRequest): reqObj = vecRequest["request_obj"] file_prefix = str(reqObj["file_prefix"]) @@ -4491,10 +3920,6 @@ def fastDPNodes(*args): def setVisitName(vname): setBlConfig("visitName",str(vname)) -def setScannerType(s_type): #either "PI" or "Normal" - """setScannerType(s_type): #either PI or Normal""" - setBlConfig("scannerType",str(s_type)) - def getVisitName(beamline): return db_lib.getBeamlineConfigParam(beamline,"visitName") @@ -4651,8 +4076,6 @@ def HePathOn(): def lsdcHelp(): - print(setGridRasterParams.__doc__) - print(printGridRasterParams.__doc__) print(robotOn.__doc__) print(robotOff.__doc__) print(procOn.__doc__) @@ -4673,7 +4096,6 @@ def lsdcHelp(): print(setAttenRI.__doc__) print(unlockGUI.__doc__) print(collectSpec.__doc__) - print(setScannerType.__doc__) print("recoverRobot()") print("setFastDPNode(nodeName)") print("setDimpleNode(nodeName)") diff --git a/gui/control_main.py b/gui/control_main.py index b5c1c408..a24205c7 100644 --- a/gui/control_main.py +++ b/gui/control_main.py @@ -171,7 +171,6 @@ def __init__(self): self.popupMessage.setStyleSheet("background-color: red") self.popupMessage.setModal(False) self.groupName = "skinner" - self.scannerType = getBlConfig("scannerType") self.centerMarkerCharSize = 20 self.centerMarkerCharOffsetX = 12 self.centerMarkerCharOffsetY = 18 @@ -225,23 +224,12 @@ def __init__(self): self.createSampleTab() self.userScreenDialog = UserScreenDialog(self) self.initCallbacks() - if self.scannerType != "PI": - self.motPos = { - "x": self.gon.x.val(), - "y": self.gon.y.val(), - "z": self.gon.z.val(), - "omega": self.gon.omega.val(), - } - else: - self.motPos = { - "x": self.gon.x.val(), - "y": self.gon.y.val(), - "z": self.gon.z.val(), - "omega": self.gon.omega.val(), - "fineX": self.sampFineX_pv.get(), - "fineY": self.sampFineY_pv.get(), - "fineZ": self.sampFineZ_pv.get(), - } + self.motPos = { + "x": self.gon.x.val(), + "y": self.gon.y.val(), + "z": self.gon.z.val(), + "omega": self.gon.omega.val(), + } self.staffScreenDialog = StaffScreenDialog(self, show=False) if daq_utils.beamline == "nyx": # requires staffScreenDialog to be present self.staffScreenDialog.fastDPCheckBox.setDisabled(True) @@ -1970,14 +1958,8 @@ def calculateNewYCoordPos(self, startYX, startYY): startY_pixels = 0 zMotRBV = self.motPos["y"] yMotRBV = self.motPos["z"] - if self.scannerType == "PI": - fineYRBV = self.motPos["fineY"] - fineZRBV = self.motPos["fineZ"] - deltaYX = startYX - zMotRBV - fineZRBV - deltaYY = startYY - yMotRBV - fineYRBV - else: - deltaYX = startYX - zMotRBV - deltaYY = startYY - yMotRBV + deltaYX = startYX - zMotRBV + deltaYY = startYY - yMotRBV omegaRad = math.radians(self.motPos["omega"]) newYY = ( float(startY_pixels - (self.screenYmicrons2pixels(deltaYY))) @@ -3192,20 +3174,11 @@ def fillPolyRaster( ) return # means a raster failure, and not enough data to cover raster, caused a gui crash - - if ( - lenX > 180 and self.scannerType == "PI" - ): # this is trying to figure out row direction + is_raster_inverted = 1 if daq_utils.beamline == "nyx" else 0 + if i % 2 == is_raster_inverted: # this is trying to figure out row direction cellIndex = spotLineCounter else: - if daq_utils.beamline == "nyx": - is_raster_inverted = 1 - else: - is_raster_inverted = 0 - if i % 2 == is_raster_inverted: # this is trying to figure out row direction - cellIndex = spotLineCounter - else: - cellIndex = rowStartIndex + ((numsteps - 1) - j) + cellIndex = rowStartIndex + ((numsteps - 1) - j) try: my_array[cellIndex] = cellResult[cell_result_key] @@ -3550,32 +3523,18 @@ def definePolyRaster( logger.error("bad value for beam width or beam height") self.popupServerMessage("bad value for beam width or beam height") return - if self.scannerType == "PI": - rasterDef = { - "rasterType": "normal", - "beamWidth": beamWidth, - "beamHeight": beamHeight, - "status": RasterStatus.NEW.value, - "x": self.gon.x.val() + self.sampFineX_pv.get(), - "y": self.gon.y.val() + self.sampFineY_pv.get(), - "z": self.gon.z.val() + self.sampFineZ_pv.get(), - "omega": self.gon.omega.val(), - "stepsize": stepsize, - "rowDefs": [], - } # just storing step as microns, not using her - else: - rasterDef = { - "rasterType": "normal", - "beamWidth": beamWidth, - "beamHeight": beamHeight, - "status": RasterStatus.NEW.value, - "x": self.gon.x.val(), - "y": self.gon.y.val(), - "z": self.gon.z.val(), - "omega": self.gon.omega.val(), - "stepsize": stepsize, - "rowDefs": [], - } # just storing step as microns, not using here + rasterDef = { + "rasterType": "normal", + "beamWidth": beamWidth, + "beamHeight": beamHeight, + "status": RasterStatus.NEW.value, + "x": self.gon.x.val(), + "y": self.gon.y.val(), + "z": self.gon.z.val(), + "omega": self.gon.omega.val(), + "stepsize": stepsize, + "rowDefs": [], + } # just storing step as microns, not using here numsteps_h = int( raster_w / stepsizeXPix ) # raster_w = width,goes to numsteps horizonatl @@ -5445,13 +5404,6 @@ def initCallbacks(self): self.sampz_pv = PV(self.gon.z.readback.pvname) self.sampz_pv.add_callback(self.processSampMoveCB, motID="z") - if self.scannerType == "PI": - self.sampFineX_pv = PV(daq_utils.motor_dict["fineX"] + ".RBV") - self.sampFineX_pv.add_callback(self.processSampMoveCB, motID="fineX") - self.sampFineY_pv = PV(daq_utils.motor_dict["fineY"] + ".RBV") - self.sampFineY_pv.add_callback(self.processSampMoveCB, motID="fineY") - self.sampFineZ_pv = PV(daq_utils.motor_dict["fineZ"] + ".RBV") - self.sampFineZ_pv.add_callback(self.processSampMoveCB, motID="fineZ") self.omega_pv = PV(self.gon.omega.setpoint.pvname) self.omegaTweak_pv = PV(self.gon.omega.setpoint.pvname)