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 7045ed93..f79cea88 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,364 +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 == CollectionProtocols.MULTI_COL or - parentReqProtocol == CollectionProtocols.MULTI_COL_Q): - if (parentReqProtocol == CollectionProtocols.MULTI_COL_Q): - 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 @@ -2407,57 +1989,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"): @@ -2999,113 +2530,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"]) @@ -4494,10 +3922,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") @@ -4654,8 +4078,6 @@ def HePathOn(): def lsdcHelp(): - print(setGridRasterParams.__doc__) - print(printGridRasterParams.__doc__) print(robotOn.__doc__) print(robotOff.__doc__) print(procOn.__doc__) @@ -4676,7 +4098,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 2995109e..3906b9ff 100644 --- a/gui/control_main.py +++ b/gui/control_main.py @@ -172,7 +172,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 @@ -226,23 +225,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) @@ -1952,14 +1940,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))) @@ -3166,20 +3148,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] @@ -3524,32 +3497,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 @@ -5405,13 +5364,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)