def saveSRSData(self, numberOfPoints): srsHeader = [ " &SRS\n", " SRSRUN=null,SRSDAT=null,SRSTIM=null,\n", " SRSSTN='null',SRSPRJ='null ',SRSEXP='null ',\n", " SRSTLE=' ',\n", " SRSCN1=' ',SRSCN2=' ',SRSCN3=' ',\n", " &END\n" ] try: runs = NumTracker("tmp") nextNum = runs.getCurrentFileNumber() #nextNum = runs.incrementNumber() path = InterfaceProvider.getPathConstructor().createFromProperty( "gda.data.scan.datawriter.datadir") fileName = path + "/" + str(nextNum + 1) + ".dat" print fileName fh = open(fileName, 'w') #SRS Header for i in range(len(srsHeader)): fh.write(srsHeader[i]) titleLine = '%(v1)s \t %(v2)s \t %(v3)s \t %(v4)s \t %(v5)s \t %(v6)s \n' % { 'v1': 'PGM Energy', 'v2': 'ID GAP Energy', 'v3': 'Channel 1', 'v4': 'Channel 2', 'v5': 'Channel 3', 'v6': 'Channel 4' } fh.write(titleLine) arrayEnergyPGM = self.energyPGM.cagetArrayDouble() arrayEnergyIDGAP = self.energyIDGAP.cagetArrayDouble() arrayChannel01 = self.channel01.cagetArrayDouble() arrayChannel02 = self.channel02.cagetArrayDouble() arrayChannel03 = self.channel03.cagetArrayDouble() arrayChannel04 = self.channel04.cagetArrayDouble() for i in range(numberOfPoints): if arrayEnergyPGM[i] < self.se: continue if arrayEnergyPGM[i] > self.ee: continue #print i, arrayEnergyPGM[i], arrayEnergyIDGAP[i], arrayChannel01[i], arrayChannel02[i], arrayChannel03[i], arrayChannel04[i]; newLine = '%(v1).8f \t %(v2).8f \t %(v3).8f \t %(v4).8f \t %(v5).8f \t %(v6).8f \n' % { 'v1': arrayEnergyPGM[i], 'v2': arrayEnergyIDGAP[i], 'v3': arrayChannel01[i], 'v4': arrayChannel02[i], 'v5': arrayChannel03[i], 'v6': arrayChannel04[i] } fh.write(newLine) fh.close() runs.incrementNumber() except: print "ERROR: Could not save data into file."
def prepare(self, trackerName='xmd', pathPrefix='xmd_'): #To setup the new directory for images self.detector.scanImageDirectory(); #To create a new xmcd folder based on xmcd run number #get current scan number nt = NumTracker(trackerName); r=nt.getCurrentFileNumber(); subDir=pathPrefix + str(r); targetDir = self.createPrecessingDir(subDir); #increase the scan number for next run nt.incrementNumber(); return targetDir;
def postCapture(self): if not self.save: return; runs=NumTracker(self.name); nextNum = NumTracker(self.name).getCurrentFileNumber() + 1; self.fileName = os.path.join(self.filePath, self.filePrefix+str(nextNum)+".png"); # print "New File name is: ----------->" + self.fileName; #My Own PNG file writer # self.saveImageFile(self.fileName); #PNG file writer from GDA Analysis package self.data.save(PNGSaver(self.fileName)); runs.incrementNumber();
def postCapture(self): if not self.save: return runs = NumTracker(self.name) nextNum = runs.getCurrentFileNumber() + 1 fn = "%s%05d.png" % (self.filePrefix, nextNum) self.fileName = os.path.join(self.filePath, fn) # print "Dubug: Saving file started"; t0 = time() #My Own PNG file writer # self.saveImageFile(self.fileName); #PNG file writer from GDA Analysis package dnp.io.save(self.fileName, self.dataset, autoscale=False) # print "Dubug: Saving file finished within %d seconds" %(time()-t0); runs.incrementNumber()
class UViewDetectorClass(DetectorBase): DETECTOR_STATUS_IDLE, DETECTOR_STATUS_BUSY, DETECTOR_STATUS_PAUSED, DETECTOR_STATUS_STANDBY, DETECTOR_STATUS_FAULT, DETECTOR_STATUS_MONITORING = range(6); ImageFileLoaders={ 'TIF' : TIFFImageLoader, 'TIFF': TIFFImageLoader, 'JPG' : JPEGLoader, 'JPEG': JPEGLoader, 'PNG' : PNGLoader }; def __init__(self, name, panelName, detector): self.setName(name); self.setInputNames([name]); self.setExtraNames([]); # self.Units=[strUnit]; self.setLevel(7); self.panel = panelName; self.detector = detector; self.scanNumberTracker = NumTracker("tmp"); self.fileName=None; self.data = ScanFileHolder() self.exposureTime = 0 self.logScale = False; self.alive=True; # To setup the image folder according to I06 requirement self.scanImageDirectory(); self.fastMode=False; self.protection=True; # self.protectCamera(); self.verbose = False #DetectorBase Implementation def getPosition(self): return self.readout(); def asynchronousMoveTo(self,newPos): self.setCollectionTime(newPos); self.collectData(); def getCollectionTime(self): self.exposureTime=self.detector.getCollectionTime(); return self.exposureTime; def setCollectionTime(self, newExpos): self.exposureTime = newExpos; self.detector.setCollectionTime(self.exposureTime); def collectData(self): #self.detector.setCollectionTime(self.exposureTime) self.detector.collectData(); return; def prepareForCollection(self): #To put camera in the "camera mode" self.detector.setCameraInProgress(False); self.detector.prepareForCollection(); def endCollection(self): # self.detector.endCollection(); if self.protection: self.protectCamera(); return; def readout(self): self.fileName = self.detector.readout(); if self.alive: self.display(); return self.fileName; def getStatus(self): return self.detector.getStatus(); def createsOwnFiles(self): return True; def toString(self): self.getPosition(); return "Latest image file: " + self.getFullFileName(); def isBusy(self): return self.detector.getStatus() == Detector.BUSY ## Extra Implementation def setFileFormat(self, fileExt, contents=2): ''' fileExtension: dat: Raw data uncompressed png: PNG compressed tiff: TIFF compressed bmp: BMP uncompressed jpg: JPG compressed tif: TIFF uncompressed imagecontents: 0: RGB 8+8+8 bits x,y,z, as seen on screen 1: RGB 8+8+8 bits,x,y raw, z as seen on screen 2: RAW 16 bits graylevel x, y, z raw data ''' self.detector.setFileFormat(fileExt, contents); def setImageAverage(self, averageParameter): ''' averageParameter: -1: Sliding average. Current does NOT work! 0: No average 1 ~ 99: Number of frames to be averaged ''' self.detector.setImageAverageNumber(averageParameter); def getImageAverage(self): iv=self.detector.getImageAverageNumber(); return iv; def protectCamera(self): #self.detector.setCollectionTime(0.1); self.detector.setCameraInProgress(True); if self.verbose: print "Camera is set to 'Recorder Mode' for protection."; return; def setAlive(self, newAlive=True): self.alive = newAlive; def setLogScale(self, newLogScale=True): self.logScale = newLogScale; def setPanel(self, newPanelName): self.panel = newPanelName; def getDetectorInfo(self): return self.detectorInfo; def singleFastShot(self, newExpos=None): if newExpos is not None: # New exposure time given self.exposureTime = newExpos; self.setCollectionTime(newExpos); return self.detector.shotSingleImage(); def singleShot(self, newExpos=None): """Shot single image with given exposure time"""; #To put camera in the "camera mode" self.detector.setCameraInProgress(False); if self.getStatus() != Detector.IDLE: print 'Camera not available, please try later'; return; if newExpos is not None: # New exposure time given self.exposureTime = newExpos; self.setCollectionTime(self.exposureTime); self.detector.setCameraSequentialMode(True); #self.setNumOfImages(1); self.collectData(); sleep(self.exposureTime); while self.getStatus() != Detector.IDLE: sleep(self.exposureTime/10.0); if self.protection: self.protectCamera(); return self.readout(); def multiShot(self, numberOfImages, newExpos=None, newDir=True): """Shot multiple images with given exposure time"""; #To put camera in the "camera mode" self.detector.setCameraInProgress(False); if self.getStatus() != Detector.IDLE: print 'Camera not available, please try later'; return; if newExpos is not None: # New exposure time given self.exposureTime = newExpos; self.setCollectionTime(self.exposureTime); if newDir: self.newImageDirectory(); self.scanImageDirectory(); else: self.detector.setCameraSequentialMode(True); temp=self.alive; self.alive=False;#To turn off the display if self.fastMode: fn=self.multiFastShot(numberOfImages); else: fn=self.multiSafeShot(numberOfImages); self.alive=temp; #To restoru the display setting if self.protection: self.protectCamera(); return fn; def multiSafeShot(self, numberOfImages): fn=[]; #self.setNumOfImages(numberOfImages); for n in range(numberOfImages): self.collectData(); sleep(self.exposureTime); while self.getStatus() != Detector.IDLE: sleep(self.exposureTime/10.0); fn.append( self.readout() ); return fn; def multiFastShot(self, numberOfImages): fn=[]; #To take the first image self.collectData() sleep(self.exposureTime + 0.15); i=0; while i<numberOfImages-1: self.collectData();#To trigger a new acquisition t0=time.time(); fn.append( self.readout() );#To save the previous picture t1=time.time(); td=t1-t0; if td < self.exposureTime+0.15:#To wait the exposure time, plus a 150ms delay? sleep(self.exposureTime+0.15-td); i+=1; fn.append( self.readout() );#To save the last previous triggered picture return fn; def display(self,file=None): if file==None: file = self.getFullFileName() fileLoader = UViewDetectorClass.ImageFileLoaders[os.path.splitext(file)[-1].split('.')[-1].upper()]; self.data.load( fileLoader(file) ); dataset = self.data.getAxis(0); if self.panel: if self.logScale: RCPPlotter.imagePlot(self.panel, DatasetUtils.lognorm(dataset)); #For RCP GUI else: RCPPlotter.imagePlot(self.panel, dataset); #For RCP GUI else: print "No panel set to display" raise Exception("No panel_name set in %s. Set this or set %s.setAlive(False)" % (self.name,self.name)); def setNumOfImages(self, number): # self.detector.setNumOfImages(number); return; def getNumOfImages(self): return 1 # return self.detector.getNumOfImages(); # To use the directory with scan number to save image, like what scan command does. def scanImageDirectory(self): #increase the scan number for one self.scanNumberTracker.incrementNumber(); self.prepareForCollection(); # To create a new directory following the PEEM image directory rules def newImageDirectory(self, newDir=None): if newDir is not None: self.detector.setImageDir(newDir); self.detector.prepare(); def getFullFileName(self): """Returns file path of the LAST CREATED image""" return self.fileName;
''' Created on 29 Jan 2014 @author: fy65 ''' from time import sleep from gda.configuration.properties import LocalProperties from gda.data import NumTracker scanNumTracker=NumTracker(LocalProperties.get(LocalProperties.GDA_BEAMLINE_NAME)) scanNumTracker.incrementNumber() EXPOSURETIME=120 #seconds TARGETCOUNT=100000 ONEMINUTECOUNT=1000 DELTAMIN=-15.0 DELTAMAX=77.0 scancount=0 Tolerance=0.1 NUMBEROFSCANS=TARGETCOUNT/ONEMINUTECOUNT*60/EXPOSURETIME print "Number of scans to do: %d, total time taken: %f" % (NUMBEROFSCANS, NUMBEROFSCANS*EXPOSURETIME) mythen.configure() # @UndefinedVariable mythen.atScanStart() # @UndefinedVariable mythen.setCollectionTime(EXPOSURETIME+10) # @UndefinedVariable delta.moveTo(DELTAMIN) # @UndefinedVariable delta.setSpeed((DELTAMAX-DELTAMIN)/(EXPOSURETIME)) # @UndefinedVariable target=DELTAMAX for i in range(NUMBEROFSCANS): sleep(5) if scancount % 2==0: target=DELTAMAX else:
class I18ExafsScanClass(ScriptBase): def __init__(self, detectorList=None): # EXAFS PANEL CODE self.scannableNamesVector = Vector() self.scannableNamesVector.add("dcm_mono") self.detectorNamesVector = Vector() self.detectorNamesVector.add("counterTimer01") self.detectorNamesVector.add("counterTimer02") self.controller = Finder.find("ExafsController") self.mcontroller = Finder.find("MicroFocusController") self.title = "TITLE" self.condition1 = "CONDITION1" self.condition2 = "CONDITION2" self.condition3 = "CONDITION3" # Script code self.das = Finder.find("daserver") self.ionchambers = SlaveCounterTimer() self.converter = Finder.find("auto_mDeg_idGap_mm_converter") self.windowValues = [[0, 4095]] * 9 self.windowName = 'ALL' self.ionchamberData = [] self.mcaList = [] self.scalarList = [] self.runs = NumTracker("tmp") self.runprefix = 'i18exafs' self.runext = '.dat' self.fileno = self.runs.getCurrentFileNumber() + 1 self.runs.incrementNumber() self.datadir = InterfaceProvider.getPathConstructor( ).createFromProperty("gda.data.scan.datawriter.datadir") self.datafilename = self.datadir + '/' + str(self.fileno) + self.runext if (detectorList != None): self.detectorMask = detectorList else: self.detectorMask = [1, 1, 1, 1, 1, 1, 1, 1, 1] self.mcadir = self.datadir + '/mca/' + str(self.fileno) + '/' self.mcarootname = self.mcadir + str(self.fileno) if not os.path.isdir(self.mcadir): os.mkdir(self.mcadir) self.tag = 1 self.facade = JythonServerFacade.getInstance() self.scanList = [] self.noOfRepeats = 1 self.noOfPoints = 0 def addAngleScan(self, start, end, step, collectionTime): self.noOfPoints = self.noOfPoints + int((end - start) / step) self.scanList.append(['a', start, end, step, collectionTime]) def addKScan(self, start, end, step, kStartTime, kEndTime, kWeighting, edgeEnergy, twoD): self.noOfPoints = self.noOfPoints + int((end - start) / step) self.scanList.append([ 'k', start, end, step, kStartTime, kEndTime, kWeighting, edgeEnergy, twoD ]) def setNoOfRepeats(self, repeats): self.noOfRepeats = repeats def startScan(self): # # Send repeat and point information to the GUI # then start the scan # self.setupGUI() for i in range(self.noOfRepeats): if (i > 0): self.incrementFilename() for j in range(len(self.scanList)): if (self.scanList[j][0] == 'a'): self.anglescan(self.scanList[j][1], self.scanList[j][2], self.scanList[j][3], self.scanList[j][4]) elif (self.scanList[j][0] == 'k'): self.kscan(self.scanList[j][1],self.scanList[j][2],\ self.scanList[j][3],self.scanList[j][4],self.scanList[j][5],self.scanList[j][6],self.scanList[j][7],self.scanList[j][8]) self.incrementGUIRepeat() def setupGUI(self): scandata = Vector() # Type of scan scandata.add("FluScan") # No of Repeats # No of Points scandata.add(self.noOfPoints) scandata.add(self.noOfRepeats) self.controller.update(None, scandata) self.mcontroller.update(None, scandata) def incrementGUIRepeat(self): scandata = Vector() # Type of scan scandata.add("ScanComplete") self.controller.update(None, scandata) self.mcontroller.update(None, scandata) # ======================================== # Read in a window to be used on the mca files # ======================================== def setWindows(self, filename, desiredWindow): infile = open(filename, 'r') tmpwindowValues = [[0, 4095]] * 9 tmpwindowName = '' while infile: # Read in the line file a = infile.readline() n = len(a) if n == 0: break temp = a.split('\t') tmpwindowName = temp[0].strip().replace(' ', '') if (tmpwindowName.lower().find(desiredWindow.lower()) >= 0): for j in range(len(temp) - 1): index = j + 1 mytemp = temp[index].strip().replace('[', '').replace( ']', '').split(',') mytemp = [int(mytemp[0]), int(mytemp[1])] tmpwindowValues[j] = mytemp print 'window values chosen :', j, tmpwindowValues[j] self.windowValues = tmpwindowValues self.windowName = tmpwindowName if (self.windowName == 'ALL'): print '======================' print '========WARNING========' print 'No window has been found or set' print '======WARNING==========' print '======================' #================================================== # Performs an angle scan in step mode # ================================================== def anglescan(self, start, end, step, collectionTime): i = 0 self.createFile() # create some empty lists self.mcaList = [] self.ionchamberData = [] self.scalarList = [] # find no of points difference = end - start if (difference < 0 and step > 0): step = -step npoints = int(difference / step) # start position currentpos = start print 'Clearing and Preparing Detector' # set collection time self.prepareDetectorForCollection(npoints, collectionTime / 1000.0) # Set the collection time self.ionchambers.setCollectionTime(collectionTime) # loop over npoints print 'Starting angle scan' print 'Bragg Energy Time I0 It Idrain' self.checkForAngleInterrupt(0, start, end, step, collectionTime) #print 'w1',w for i in range(npoints): #print 'w1',w self.checkForAnglePause(i, start, end, step, collectionTime) # Check beam is running while (BeamMonitor.beamOn() == 0): self.checkForAngleInterrupt(i, start, end, step, collectionTime) print 'Beam lost : Pausing until resumed' try: sleep(60) except: self.interrupted = 1 self.checkForAngleInterrupt(i, start, end, step, collectionTime) #print 'w2',w # Move mono to start position self.checkForAngleInterrupt(i, start, end, step, collectionTime) #print 'w3',w try: #print 'w4',w comboDCM_d.moveTo(currentpos) comboDCM_d.waitWhileBusy() self.converter.disableAutoConversion() #ScannableBase.waitForScannable(comboDCM) #print 'w5',w except: self.interrupted = 1 self.converter.enableAutoConversion() self.checkForAngleInterrupt(i, start, end, step, collectionTime) # Ready the ion chambers #print 'w5',w self.ionchambers.clearAndPrepare() #print 'w6',w self.checkForAngleInterrupt(i, start, end, step, collectionTime) # tfg starts paused so tell it to continue self.das.sendCommand("tfg cont") self.checkForAngleInterrupt(i, start, end, step, collectionTime) self.das.sendCommand("tfg wait timebar") self.checkForAngleInterrupt(i, start, end, step, collectionTime) # read out the ion chambers #print 'w7',w while (self.ionchambers.isBusy() >= 1): self.checkForAngleInterrupt(i, start, end, step, collectionTime) try: sleep(0.05) except: self.interrupted = 1 pass #print 'w8',w self.ionchamberData.append(self.ionchambers.collectData()) # print out some progress self.checkForAngleInterrupt(i, start, end, step, collectionTime) #print currentpos,comboDCM.calcEnergy(currentpos/1000.0),collectionTime,self.ionchamberData[i][0],self.ionchamberData[i][1],self.ionchamberData[i][2] print currentpos, comboDCM_eV.getPosition( ), collectionTime, self.ionchamberData[i][0], self.ionchamberData[ i][1], self.ionchamberData[i][2] # Move the mono #print 'w9',w currentpos = currentpos + step # stop detector self.stopDetector() # write out the data self.writeSummary(npoints, start, end, step, collectionTime) self.converter.enableAutoConversion() self.tag = self.tag + 1 print 'Finished angle scan' #================================================== # Performs a kscan in step mode # ================================================== def kscan(self, start, end, step, kStartTime, kEndTime, kWeighting, edgeEnergy, twoD): i = 0 #try: self.createFile() self.mcaList = [] self.ionchamberData = [] self.scalarList = [] # check that step is negative when moving downwards to stop difference = end - start if (difference < 0 and step > 0): step = -step npoints = int(difference / step) currentpos = start # prepare detector for collection print 'Clearing and Preparing Detector' self.prepareDetectorForKScan(start, step, end, kWeighting, kEndTime, kStartTime) print 'Starting k scan' print 'Bragg Energy Time I0 It Idrain' self.checkForKScanInterrupt(0, start, end, step, edgeEnergy, twoD, kStartTime, kEndTime, kWeighting) for i in range(npoints): # Check for pause! self.checkForKScanPause(i, start, end, step, edgeEnergy, twoD, kStartTime, kEndTime, kWeighting) # Check beam is running while (BeamMonitor.beamOn() == 0): print 'Beam lost : Pausing until resumed' self.checkForKScanInterrupt(i, start, end, step, edgeEnergy, twoD, kStartTime, kEndTime, kWeighting) try: sleep(60) except: self.interrupted = 1 mdegPosition = self.mDegForK(currentpos, edgeEnergy, twoD) secTime = self.timeForK(currentpos, start, end, kWeighting, kEndTime, kStartTime) self.checkForKScanInterrupt(i, start, end, step, edgeEnergy, twoD, kStartTime, kEndTime, kWeighting) # Set the collection time self.ionchambers.setCollectionTime(secTime) # Move mono to start position try: comboDCM_d.moveTo(mdegPosition) #comboDCM.waitWhileBusy() self.converter.disableAutoConversion() #ScannableBase.waitForScannable(comboDCM) except: self.interrupted = 1 self.converter.enableAutoConversion() self.checkForKScanInterrupt(i, start, end, step, edgeEnergy, twoD, kStartTime, kEndTime, kWeighting) # Ready the ion chambers self.ionchambers.clearAndPrepare() self.checkForKScanInterrupt(i, start, end, step, edgeEnergy, twoD, kStartTime, kEndTime, kWeighting) # tfg starts paused so tell it to continue self.das.sendCommand("tfg cont") self.checkForKScanInterrupt(i, start, end, step, edgeEnergy, twoD, kStartTime, kEndTime, kWeighting) self.das.sendCommand("tfg wait timebar") self.checkForKScanInterrupt(i, start, end, step, edgeEnergy, twoD, kStartTime, kEndTime, kWeighting) while (self.ionchambers.isBusy() >= 1): self.checkForKScanInterrupt(i, start, end, step, edgeEnergy, twoD, kStartTime, kEndTime, kWeighting) try: sleep(0.05) except: self.interrupted = 1 pass self.ionchamberData.append(self.ionchambers.collectData()) self.checkForKScanInterrupt(i, start, end, step, edgeEnergy, twoD, kStartTime, kEndTime, kWeighting) #print mdegPosition,comboDCM.calcEnergy(mdegPosition/1000.0),secTime,self.ionchamberData[i][0],self.ionchamberData[i][1],self.ionchamberData[i][2] print mdegPosition, comboDCM_eV.getPosition( ), secTime, self.ionchamberData[i][0], self.ionchamberData[i][ 1], self.ionchamberData[i][2] # Move the mono currentpos = currentpos + step # write out at end self.checkForKScanInterrupt(i, start, end, step, edgeEnergy, twoD, kStartTime, kEndTime, kWeighting) self.stopDetector() self.checkForKScanInterrupt(i, start, end, step, edgeEnergy, twoD, kStartTime, kEndTime, kWeighting) self.converter.enableAutoConversion() self.writeKScanSummary(npoints, start, end, step, edgeEnergy, twoD, kStartTime, kEndTime, kWeighting) self.tag = self.tag + 1 print 'Finished k scan' #================================================== # Disables, Clears and enables the detector # Sets up tfg for a given noOfFrames and collectionTime # pausing in the dead frame and dead port=1 for adc triggering # and finally starts the tfg which means it sits waiting for a software based continue command #================================================== def prepareDetectorForCollection(self, noOfFrames, collectionTime): self.das.sendCommand("disable 0") self.das.sendCommand("clear 0") self.das.sendCommand("enable 0") self.das.sendCommand("tfg init") command = "tfg setup-groups cycles 1 \n%d 0.01 %f 0 1 1 0 \n-1 0 0 0 0 0 0 " % ( noOfFrames, collectionTime) self.das.sendCommand(command) self.das.sendCommand("tfg start") #================================================== # Disables, Clears and enables the detector # Sets up tfg for a set of possibly variable length time frames # and finally starts the tfg which means it sits waiting for a software based continue command #================================================== def prepareDetectorForKScan(self, start, step, end, kWeighting, kEndTime, kStartTime): self.das.sendCommand("disable 0") self.das.sendCommand("clear 0") self.das.sendCommand("enable 0") self.das.sendCommand("tfg init") self.das.sendCommand("tfg auto-cont 0") command = self.getTFGCommandForKScan(start, step, end, kWeighting, kEndTime, kStartTime) self.das.sendCommand(command) self.das.sendCommand("tfg start") #================================================== # Stop the tfg and disable the detector #================================================== def stopDetector(self): self.das.sendCommand("tfg init") self.das.sendCommand("disable 0") #================================================== # Write the detector data to files #================================================== def writeDetectorFile(self, npoints): for i in range(npoints): name = "%s_scan_%d_index_%d.dat" % (self.mcarootname, self.tag, i) sname = "%s_scan_%d_index_%d_scalar.dat" % (self.mcarootname, self.tag, i) print 'Writing scan point', i, 'to', name self.mcaList.append(name) self.scalarList.append(sname) command = "read 0 0 %d 4096 9 1 from 0 to-local-file \"%s\" raw intel" % ( i, name) self.das.sendCommand(command) command = "read 0 0 %d 9 2 1 from 1 to-local-file \"%s\" raw intel" % ( i, sname) self.das.sendCommand(command) #================================================== # Write the data to a file #================================================== def writeSummary(self, npoints, start, end, step, collectionTime): self.writeDetectorFile(npoints) # lets window this mofo fid = open(self.datafilename, 'a') current = start for i in range(npoints): windowedData = [0.0] * 9 print 'Reading and windowing:', self.mcaList[i] frameData = Xspress2Utilities.interpretDataFile(self.mcaList[i], 0) totalw = 0.0 for j in range(9): sumgrades = frameData[j] windowedData[j] = windowedData[j] + self.windowData( sumgrades, self.windowValues[j][0], self.windowValues[j][1]) for j in range(9): if (self.detectorMask[j] == 1): totalw = totalw + windowedData[j] # # now read scalar data # scalarData = [] for j in range(2): scalarData.append(range(9)) fis = FileInputStream(self.scalarList[i]) dis = DataInputStream(fis) scalerBytes = jarray.zeros(18 * 4, 'b') dis.read(scalerBytes, 0, 18 * 4) fis.close() offset = 0 for j in range(2): for l in range(0, 36, 4): scalarData[j][l/4]= (0x000000FF & scalerBytes[offset+l+0]) +\ ((0x000000FF & scalerBytes[offset+l+1])<<8)+\ ((0x000000FF & scalerBytes[offset+l+2])<<16)+((0x000000FF & scalerBytes[offset+l+3])<<24) offset = offset + 36 liveTime = collectionTime / 1000.0 corrCounts = self.getCorrectedCounts(scalarData[0], scalarData[1], liveTime) measuredCounts = scalarData[0] relinCounts = self.reLinearizeCounts(corrCounts) factor = [] for j in range(len(relinCounts)): if (relinCounts[j] == 0 or measuredCounts[j] == 0): val = 1 factor.append(1.0) else: val = (relinCounts[j] / measuredCounts[j]) factor.append(val * liveTime) correctWindows = [] corrWindTot = 0.0 for j in range(9): correctW = float(windowedData[j]) * factor[j] corrWindTot = corrWindTot + correctW correctWindows.append(correctW) #print >>fid,current,comboDCM.calcEnergy(current/1000.0),collectionTime,self.ionchamberData[i][0],\ # self.ionchamberData[i][1],self.ionchamberData[i][2],str(windowedData[0:]).strip('[]').replace(',',''), \ # totalw,str(correctWindows[0:]).strip('[]').replace(',',''),corrWindTot print >>fid,current,comboDCM_eV.getPosition(),collectionTime,self.ionchamberData[i][0],\ self.ionchamberData[i][1],self.ionchamberData[i][2],str(windowedData[0:]).strip('[]').replace(',',''), \ totalw,str(correctWindows[0:]).strip('[]').replace(',',''),corrWindTot # pdq added for plotting current = current + step # SDP Stuff detectorVector = Vector() detectorVector.add(self.ionchamberData[i]) detectorVector.add(windowedData) positionVector = Vector() positionVector.add(str(current)) #sdp = ScanDataPoint("scan name",self.scannableNamesVector,self.detectorNamesVector,positionVector,detectorVector,"Panel Name","I18 Custom SDP","Header String",self.datafilename) sdp = ScanDataPoint("Exafs FluAngleScan", self.scannableNamesVector, self.detectorNamesVector, None, None, None, None, positionVector, detectorVector, None, "Panel Name", "I18 Custom SDP", "Header String", self.datafilename, 0) self.controller.update(None, sdp) self.mcontroller.update(None, sdp) fid.close() #================================================== # Write the data to a file #================================================== def writeKScanSummary(self, npoints, start, end, step, edgeEnergy, twoD, kStartTime, kEndTime, kWeighting): self.writeDetectorFile(npoints) current = start # lets window this mofo fid = open(self.datafilename, 'a') current = start for i in range(npoints): windowedData = [0.0] * 9 print 'Reading and windowing:', self.mcaList[i] frameData = Xspress2Utilities.interpretDataFile( self.mcaList[i].strip(), 0) totalw = 0.0 for j in range(9): sumgrades = frameData[j] windowedData[j] = windowedData[j] + self.windowData( sumgrades, self.windowValues[j][0], self.windowValues[j][1]) for j in range(9): totalw = totalw + windowedData[j] # # now read scalar data # scalarData = [] for j in range(2): scalarData.append(range(9)) fis = FileInputStream(self.scalarList[i]) dis = DataInputStream(fis) scalerBytes = jarray.zeros(18 * 4, 'b') dis.read(scalerBytes, 0, 18 * 4) fis.close() offset = 0 for j in range(2): for l in range(0, 36, 4): scalarData[j][l / 4] = ( 0x000000FF & scalerBytes[offset + l + 0] ) + ((0x000000FF & scalerBytes[offset + l + 1]) << 8) + ( (0x000000FF & scalerBytes[offset + l + 2]) << 16) + ( (0x000000FF & scalerBytes[offset + l + 3]) << 24) offset = offset + 36 secTime = self.timeForK(current, start, end, kWeighting, kEndTime, kStartTime) liveTime = secTime / 1000.0 corrCounts = self.getCorrectedCounts(scalarData[0], scalarData[1], liveTime) measuredCounts = scalarData[0] relinCounts = self.reLinearizeCounts(corrCounts) factor = [] for j in range(len(relinCounts)): if (relinCounts[j] == 0 or measuredCounts[j] == 0): val = 1 factor.append(1.0) else: val = (relinCounts[j] / measuredCounts[j]) factor.append(val * liveTime) correctWindows = [] corrWindTot = 0.0 for j in range(9): correctW = float(windowedData[j]) * factor[j] corrWindTot = corrWindTot + correctW correctWindows.append(correctW) #print>>fid,self.mDegForK(current,edgeEnergy,twoD),comboDCM.calcEnergy(self.mDegForK(current,edgeEnergy,twoD)/1000.0),\ # secTime,self.ionchamberData[i][0],self.ionchamberData[i][1],self.ionchamberData[i][2],str(windowedData[0:]).strip('[]').replace(',',''), \ # totalw,str(correctWindows[0:]).strip('[]').replace(',',''),corrWindTot print>>fid,self.mDegForK(current,edgeEnergy,twoD),comboDCM.calcEnergy(self.mDegForK(current,edgeEnergy,twoD)/1000.0),\ secTime,self.ionchamberData[i][0],self.ionchamberData[i][1],self.ionchamberData[i][2],str(windowedData[0:]).strip('[]').replace(',',''), \ totalw,str(correctWindows[0:]).strip('[]').replace(',',''),corrWindTot current = current + step # SDP Stuff detectorVector = Vector() detectorVector.add(self.ionchamberData[i]) detectorVector.add(windowedData[0:]) positionVector = Vector() positionVector.add(str(self.mDegForK(current, edgeEnergy, twoD))) #sdp = ScanDataPoint("scan name",self.scannableNamesVector,self.detectorNamesVector,positionVector,detectorVector,"Panel Name","I18 Custom SDP","Header String",self.datafilename) sdp = ScanDataPoint("Exafs FluKScan", self.scannableNamesVector, self.detectorNamesVector, None, None, None, None, positionVector, detectorVector, None, "Panel Name", "I18 Custom SDP", "Header String", self.datafilename, 0) self.controller.update(None, sdp) self.mcontroller.update(None, sdp) fid.close() #================================================== # Window an mca contained in data between two values, start and end #================================================== def windowData(self, data, start, end): sum = 0.0 for i in range(start, end): sum = sum + data[i] return sum #================================================== # mDegForK converts k value (in inverse angstroms) to mDeg by using the java # Converter class. #================================================== def mDegForK(self, k, edgeEnergy, twoD): return gda.gui.exafs.Converter.convert( k, gda.gui.exafs.Converter.PERANGSTROM, gda.gui.exafs.Converter.MDEG, edgeEnergy, twoD) #================================================== # timeForK calculates the appropriate counting time for a particular k value # ================================================== def timeForK(self, k, start, end, kWeighting, kEndTime, kStartTime): a = Math.pow(k - start, kWeighting) b = Math.pow(end - start, kWeighting) c = (kEndTime - kStartTime) time = kStartTime + (a * c) / b # round to nearest 10milliseconds as this is all the ion chambers can collect in time = Math.round(time / 1.0) * 1.0 return time #================================================== # # Produces the tfg setup-groups used for kscans # In kscans you may want a time increase from start to finish # This method produces a series of individual tfg time frames for each time step in the scan #================================================== def getTFGCommandForKScan(self, start, step, end, kWeighting, kEndTime, kStartTime): difference = end - start if (difference < 0 and step > 0): step = -step npoints = int(difference / step) currentpos = start tfglist = "tfg setup-groups cycles 1 \n" for j in range(npoints + 1): secTime = self.timeForK(currentpos, start, end, kWeighting, kEndTime, kStartTime) tfglist = tfglist + "1 0.01 %f 0 1 1 0 \n" % (secTime / 1000.0) currentpos = currentpos + step tfglist = tfglist + "-1 0 0 0 0 0 0 " return tfglist #================================================== # # Creates the file used for the EXAFS # #================================================== def createFile(self): if (os.path.exists(self.datafilename) == 0): fid = open(self.datafilename, 'w') df = SimpleDateFormat('hh.mm.dd.MM.yyyy') today = df.format(Date()) print "Writing data to file:" + self.datafilename print "Writing mca file to:" + self.mcadir # write datetime line = " I18_EXAFS_RUN=" + str(self.fileno) + " " + today print >> fid, line print >> fid, self.title print >> fid, self.condition1 print >> fid, self.condition2 print >> fid, self.condition3 print >> fid, 'Sample X=', MicroFocusSampleX.getPosition( ), 'Sample Y=', MicroFocusSampleY.getPosition() print >> fid, 'comboDCM energy time I0 It drain flu1 flu2 flu3 flu4 flu5 flu6 flu7 flu8 flu9 flutot' fid.close() #================================================== # # Checks to see if an angle scan has been interrupted # #================================================== def checkForAngleInterrupt(self, npoints, start, end, step, collectionTime): #if(self.facade.getScanStatus()==0 and self.facade.getScriptStatus()==0): if (self.interrupted): print 'Stopping angle scan:Writing out data taken' # write the data we have so far and return self.stopDetector() self.writeSummary(npoints, start, end, step, collectionTime) self.interrupted = Boolean(0) self.paused = Boolean(0) JythonServerFacade.getInstance().setScriptStatus(JythonStatus.IDLE) scandata = Vector() scandata.add("STOP") self.controller.update(None, scandata) self.mcontroller.update(None, scandata) print 'Now the nasty bit: throw an exception to stop running' raise lang.InterruptedException() raise lang.InterruptedException() #================================================== # # Checks to see if an angle scan has been paused # #================================================== def checkForAnglePause(self, npoints, start, end, step, collectionTime): if (self.paused): JythonServerFacade.getInstance().setScriptStatus( JythonStatus.PAUSED) while (self.paused): try: print 'Angle Scan paused - Awaiting resume' java.lang.Thread.sleep(10000) except lang.InterruptedException: self.checkForAngleInterrupt(npoints, start, end, step, collectionTime) #================================================== # # Checks to see if an angle scan has been paused # #================================================== def checkForKScanInterrupt(self, npoints, start, end, step, edgeEnergy, twoD, kStartTime, kEndTime, kWeighting): #if(self.facade.getScanStatus()==0 and self.facade.getScriptStatus()==0): if (self.interrupted): print 'Stopping k scan:Writing out data taken' # write the data we have so far and return self.stopDetector() self.writeKScanSummary(npoints, start, end, step, edgeEnergy, twoD, kStartTime, kEndTime, kWeighting) self.interrupted = Boolean(0) self.paused = Boolean(0) JythonServerFacade.getInstance().setScriptStatus(JythonStatus.IDLE) scandata = Vector() scandata.add("STOP") self.controller.update(None, scandata) self.mcontroller.update(None, scandata) print 'Now the nasty bit: throw an exception to stop running' raise lang.InterruptedException() #================================================== # # Checks to see if an angle scan has been paused # #================================================== def checkForKScanPause(self, npoints, start, end, step, edgeEnergy, twoD, kStartTime, kEndTime, kWeighting): if (self.paused): JythonServerFacade.getInstance().setScriptStatus( JythonStatus.PAUSED) while (self.paused): try: print 'K Scan Scan paused - Awaiting resume' java.lang.Thread.sleep(10000) except lang.InterruptedException: self.checkForKScanInterrupt(npoints, start, end, step, edgeEnergy, twoD, kStartTime, kEndTime, kWeighting) #================================================== # To set the resolution binning used by xspress # Usage # setResMode(0) .. all grades processed # setResMode(1) .. variable all grades summed into 1 grade # setResMode(1,8) variable all grades from 0-7 put in one grade and 8-15 in next grade #================================================== def setResMode(self, mode, map=None): if (mode == 0): command = "xspress2 set-resmode \"xsp1\" 0 0" self.das.sendCommand(command) else: if (map == None or map < 0 or map > 15): command = "xspress2 set-resmode \"xsp1\" 1 0" else: command = "xspress2 set-resmode \"xsp1\" 1 %d" % (map) self.das.sendCommand(command) #================================================== # # To set the header info used in the script # #================================================== def setHeaderInfo(self, title, condition1, condition2, condition3): self.title = title self.condition1 = condition1 self.condition2 = condition2 self.condition3 = condition3 #================================================== # # Get corrected counts # #================================================== def getCorrectedCounts(self, countData, resetData, liveTime): realCounts = [] for i in range(len(countData)): realCounts.append(countData[i] * (1.0 / (liveTime - ((12.5e-9) * resetData[i])))) return realCounts #================================================== # # Get corrected counts # #================================================== def reLinearizeCounts(self, corrCounts): process_times = [ 3.4e-07, 3.8e-07, 3.7e-07, 3.0e-07, 3.4e-07, 3.5e-07, 3.3e-07, 3.0e-07, 3.3e-07 ] realCounts = [] for i in range(len(process_times)): a = process_times[i] * corrCounts[i] aa = a * a eqn1 = (-10.0 + 27.0 * a + 5.196152423 * sqrt(4 - 20.0 * a + 27.0 * aa))**(1.0 / 3.0) eqn2 = (1.0 / (3.0 * process_times[i])) eqn3 = eqn2 * eqn1 - 2 * eqn2 / eqn1 + 2 * eqn2 realCounts.append(eqn3) return realCounts #================================================== # # Read in a scalar data file and return array # #================================================== def readScalarDataFile(self, scalarfile): scalarData = [] for j in range(2): scalerData.append(range(9)) fis = FileInputStream(self.scalarList[i]) dis = DataInputStream(fis) scalerBytes = jarray.zeros(18 * 4, 'b') dis.read(scalerBytes, 0, 18 * 4) fis.close() offset = 0 for j in range(2): for l in range(0, 36, 4): scalarData[j][ l / 4] = (0x000000FF & scalerBytes[offset + l + 0]) + ( (0x000000FF & scalerBytes[offset + l + 1]) << 8 ) + ((0x000000FF & scalerBytes[offset + l + 2]) << 16) + ( (0x000000FF & scalerBytes[offset + l + 3]) << 24) offset = offset + 36 fis.close() return scalarData # # In a scan you create a new scan object for each scan # You can reuse the i18exafs scan # This simply increments the file no.s etc. # def incrementFilename(self): self.fileno = self.runs.getCurrentFileNumber() + 1 self.runs.incrementNumber() self.datadir = InterfaceProvider.getPathConstructor( ).createFromProperty("gda.data.scan.datawriter.datadir") self.datafilename = self.datadir + '/' + str(self.fileno) + self.runext self.mcadir = self.datadir + '/mca/' + str(self.fileno) + '/' self.mcarootname = self.mcadir + str(self.fileno) if not os.path.isdir(self.mcadir): os.mkdir(self.mcadir) self.tag = 1 self.interrupted = Boolean(0)
#How to use Track Number (Scan number) from gda.data import NumTracker nt = NumTracker("tmp") #get current scan number nt.getCurrentFileNumber() #increase the scan number for one nt.incrementNumber() #set new scan number #nt.setFileNumber(2000) del nt
class PilatusOverSocket(Pilatus, SingleSessionSocketDeviceClass): terminators = '\n\x15\x18' def __init__(self, name): Pilatus.__init__(self, name) self.detectorInfo = 'Pilatus Over Socket' self.setFilePrefix('pilatusImage') serverHost = 'localhost' serverPort = 41234 # super(SockteDeviceClass, self).__init__(self, serverHost, serverPort); SingleSessionSocketDeviceClass.__init__(self, serverHost, serverPort) def turnOn(self): self.status = PilatusInfo.DETECTOR_STATUS_IDLE self.connect() def turnOff(self): self.send("exit ") self.disconnect() def getNumOfImages(self): reply = self.sendAndReply('nimages') # The reply should be something like: '15 OK N images (frames) set to: 1' print reply rlist = reply.split(' ', 9) if rlist[1] == 'OK': self.numImages = int(rlist[7].rstrip( PilatusOverSocket.terminators)) else: print "Get detector information failed." return self.numImages def setNumOfImages(self, number): self.numImages = number self.sendAndReply('nimages ' + str(number)) return self.numImages def setFilePath(self, newFilePath): """Set file path""" self.filePath = newFilePath self.sendAndReply('imgpath ' + newFilePath) def getFilePath(self): if self.filePath != None: return self.filePath reply = self.sendAndReply('imgpath ') print reply # The reply should be something like: '10 OK' /home/det/p2_det/images/' rlist = reply.split(' ', 3) if rlist[1] == 'OK': self.filePath = rlist[2].rstrip(PilatusOverSocket.terminators) else: print "Get detector information failed." return self.filePath def setFilePrefix(self, filePrefix): self.filePrefix = filePrefix self.runs = NumTracker(self.filePrefix) self.fileNumber = self.runs.getCurrentFileNumber() def getFileNumberOld(self): """Restore the pickled file number for persistence""" try: inStream = file(self.filePath + 'simPilatusFileNumber.txt', 'rb') self.fileNumber = pickle.load(inStream) inStream.close() except IOError: print "No previous pickled file numbers. Create new one" self.fileNumber = 0 return self.fileNumber def saveFileNumberOld(self): """Save the file number for persistence""" outStream = file(self.filePath + 'simPilatusFileNumber.txt', 'wb') try: #Pickle the file number and dump to a file stream pickle.dump(self.fileNumber, outStream) outStream.close() except IOError: print "Can not preserve file numbers." # Palitus Detector Interface Implementation def getCollectionTime(self): reply = self.sendAndReply("exptime") # The reply should be something like: '15 OK Exposure time set to: 2.000000 sec.' print reply rlist = reply.split(' ', 9) if rlist[1] == 'OK': self.exposureTime = float(rlist[8]) else: print "Get detector information failed." return self.exposureTime def setCollectionTime(self, newExpos): reply = self.sendAndReply("exptime " + str(newExpos)) print reply rlist = reply.split(' ', 9) if rlist[1] == 'OK': self.exposureTime = float(rlist[8]) else: print "Set detector information failed." return self.exposureTime def collectData(self): # newFileName = self.filePrefix + "%04.0f" % self.fileNumber + self.fileFormat[-4:] newFileName = self.getNextFullFileName() self.status = PilatusInfo.DETECTOR_STATUS_BUSY try: reply01 = self.sendAndReply('exposure ' + newFileName) reply02 = self.receive() print reply01 print reply02 self.runs.incrementNumber() except SocketError, msg: print 'Socket Connection Error: ' + str(msg) self.status = PilatusInfo.DETECTOR_STATUS_IDLE return
def incScanNumber(self): from gda.data import NumTracker nt = NumTracker("tmp") nt.incrementNumber() del nt return