class Sector33SpecDataSource(SpecXMLDrivenDataSource): ''' Class to load data from spec file and configuration xml files from for the way that data is collected at sector 33. :members ''' def __init__(self, projectDir, projectName, projectExtension, instConfigFile, detConfigFile, **kwargs): ''' Constructor :param projectDir: Directory holding the project file to open :param projectName: First part of file name for the project :param projectExt: File extension for the project file. :param instConfigFile: Full path to Instrument configuration file. :param detConfigFile: Full path to the detector configuration file :param kwargs: Assorted keyword arguments :rtype: Sector33SpecDataSource ''' super(Sector33SpecDataSource, self).__init__(projectDir, projectName, projectExtension, instConfigFile, detConfigFile, **kwargs) def _calc_eulerian_from_kappa(self, primaryAngles=None, referenceAngles = None): """ Calculate the eulerian sample angles from the kappa stage angles. :param primaryAngles: list of sample axis numbers to be handled by the conversion :param referenceAngles: list of reference angles to be used in angle conversion """ keta = np.deg2rad(referenceAngles[:,0]) kappa = np.deg2rad(referenceAngles[:,1]) kphi = np.deg2rad(referenceAngles[:,2]) kappaParam = self.instConfig.getSampleAngleMappingParameter('kappa') try: if kappaParam != None: self.kalpha = np.deg2rad(float(kappaParam)) else: self.kalpha = np.deg2rad(50.000) kappaInvertedParam = \ self.instConfig.getSampleAngleMappingParameter('kappaInverted') if kappaInvertedParam != None: self.kappa_inverted = self.to_bool(kappaInvertedParam) else: self.kappa_inverted = False except Exception as ex: raise RSMap3DException("Error trying to get parameter for " + \ "sampleAngleMappingFunction " + \ "_calc_eulerian_from_kappa in inst config " + \ "file\n" + \ str(ex)) _t1 = np.arctan(np.tan(kappa / 2.0) * np.cos(self.kalpha)) if self.kappa_inverted: eta = np.rad2deg(keta + _t1) phi = np.rad2deg(kphi + _t1) else: eta = np.rad2deg(keta - _t1) phi = np.rad2deg(kphi - _t1) chi = 2.0 * np.rad2deg(np.arcsin(np.sin(kappa / 2.0) * \ np.sin(self.kalpha))) return eta, chi, phi def _calc_replace_angle_values(self , primaryAngles=None, referenceAngles=None): ''' Fix a situation were some constant angle values have been recorded incorrectly and need to be fixed. :param primaryAngles: list of sample axis numbers to be handled by the conversion :param referenceAngles: list of reference angles to be used in angle conversion ''' logger.info( "Running " + __name__) angles = [] logger.debug("referenceAngles " + str(referenceAngles)) mappingAngles = self.instConfig.getSampleAngleMappingReferenceAngles() logger.debug( "mappingAngles" + str(mappingAngles)) for ii in range(len(referenceAngles)): replaceVal = \ float(self.instConfig.getSampleAngleMappingReferenceAngleAttrib( \ number= str(mappingAngles[ii]), \ attribName='replaceValue')) logger.debug( "primary Angles" + str(referenceAngles)) angles.append(replaceVal* np.ones(len(referenceAngles[:,ii]),)) logger.debug("Angles" + str( angles)) return angles def fixGeoAngles(self, scan, angles): ''' Fix the angles using a user selected function. :param scan: scan to set the angles for :param angles: Array of angles to set for this scan ''' logger.debug( "starting " + __name__) needToCorrect = False refAngleNames = self.instConfig.getSampleAngleMappingReferenceAngles() for refAngleName in refAngleNames: alwaysFix = self.instConfig.getSampleAngleMappingAlwaysFix() if refAngleName in scan.L or alwaysFix: needToCorrect = True if needToCorrect: logger.debug( __name__ + ": Fixing angles") refAngles = self.getScanAngles(scan, refAngleNames) primaryAngles = self.instConfig.getSampleAngleMappingPrimaryAngles() functionName = self.instConfig.getSampleAngleMappingFunctionName() functionModuleName = self.instConfig.getSampleAngleMappingFunctionModule() logger.debug("sampleMappingFunction moduleName %s" % functionModuleName) #Call a defined method to calculate angles from the reference angles. moduleSource = self if functionModuleName != None: functionModule = importlib.import_module(functionModuleName) logger.debug("dir(functionModule)" % dir(functionModule)) moduleSource = functionModule method = getattr(moduleSource, functionName) fixedAngles = method(primaryAngles=primaryAngles, referenceAngles=refAngles) logger.debug ("fixed Angles: " + str(fixedAngles)) for i in range(len(primaryAngles)): logger.debug ("Fixing primaryAngles: %d " % primaryAngles[i]) angles[:,primaryAngles[i]-1] = fixedAngles[i] def getGeoAngles(self, scan, angleNames): """ This function returns all of the geometry angles for the for the scan as a N-by-num_geo array, where N is the number of scan points and num_geo is the number of geometry motors. """ # scan = self.sd[scanNo] geoAngles = self.getScanAngles(scan, angleNames) if not (self.instConfig.getSampleAngleMappingFunctionName() == ""): tb = None try: self.fixGeoAngles(scan, geoAngles) except Exception as ex: tb = traceback.format_exc() raise RSMap3DException("Handling exception in getGeoAngles." + \ "\n" + \ str(ex) + \ "\n" + \ str(tb)) logger.debug("getGeoAngles:\n" + str(geoAngles)) return geoAngles def getUBMatrix(self, scan): """ Read UB matrix from the #G3 line from the spec file. """ try: g3 = scan.G["G3"].strip().split() g3 = np.array(list(map(float, g3))) ub = g3.reshape(-1,3) logger.debug("ub " +str(ub)) return ub except: logger.error("Unable to read UB Matrix from G3") logger.error( '-'*60) traceback.print_exc(file=sys.stdout) logger.error('-'*60) def hotpixelkill(self, areaData): """ function to remove hot pixels from CCD frames ADD REMOVE VALUES IF NEEDED! :param areaData: area detector data """ for pixel in self.getBadPixels(): badLoc = pixel.getBadLocation() replaceLoc = pixel.getReplacementLocation() areaData[badLoc[0],badLoc[1]] = \ areaData[replaceLoc[0],replaceLoc[1]] return areaData def loadSource(self, mapHKL=False): ''' This method does the work of loading data from the files. This has been split off from the constructor to allow this to be threaded and later canceled. :param mapHKL: boolean to mark if the data should be mapped to HKL ''' # Load up the instrument configuration file self.loadInstrumentXMLConfig() #Load up the detector configuration file self.loadDetectorXMLConfig() self.specFile = os.path.join(self.projectDir, self.projectName + \ self.projectExt) imageDir = os.path.join(self.projectDir, \ IMAGE_DIR_MERGE_STR % self.projectName) self.imageFileTmp = os.path.join(imageDir, \ TIFF_FILE_MERGE_STR % (self.projectName)) # if needed load up the bad pixel file. if not (self.badPixelFile is None): badPixelFile = PilatusBadPixelFile(self.badPixelFile) self.badPixels = badPixelFile.getBadPixels() # id needed load the flat field file if not (self.flatFieldFile is None): self.flatFieldData = np.array(Image.open(self.flatFieldFile)).T # Load scan information from the spec file try: self.sd = SpecDataFile(self.specFile) self.mapHKL = mapHKL maxScan = int(self.sd.getMaxScanNumber()) logger.debug("Number of Scans" + str(maxScan)) if self.scans is None: self.scans = range(1, maxScan+1) imagePath = os.path.join(self.projectDir, IMAGE_DIR_MERGE_STR % self.projectName) self.imageBounds = {} self.imageToBeUsed = {} self.availableScans = [] self.incidentEnergy = {} self.ubMatrix = {} self.scanType = {} self.progress = 0 self.progressInc = 1 # Zero the progress bar at the beginning. if self.progressUpdater is not None: self.progressUpdater(self.progress, self.progressMax) for scan in self.scans: if (self.cancelLoad): self.cancelLoad = False raise LoadCanceledException(CANCEL_STR) else: if (os.path.exists(os.path.join(imagePath, \ SCAN_NUMBER_MERGE_STR % scan))): try: curScan = self.sd.scans[str(scan)] self.scanType[scan] = \ self.sd.scans[str(scan)].scanCmd.split()[0] angles = self.getGeoAngles(curScan, self.angleNames) self.availableScans.append(scan) if self.mapHKL==True: self.ubMatrix[scan] = self.getUBMatrix(curScan) if self.ubMatrix[scan] is None: raise Sector33SpecFileException("UB matrix " + \ "not found.") else: self.ubMatrix[scan] = None self.incidentEnergy[scan] = 12398.4 /float(curScan.G['G4'].split()[3]) _start_time = time.time() self.imageBounds[scan] = \ self.findImageQs(angles, \ self.ubMatrix[scan], \ self.incidentEnergy[scan]) if self.progressUpdater is not None: self.progressUpdater(self.progress, self.progressMax) logger.info (('Elapsed time for Finding qs for scan %d: ' + '%.3f seconds') % \ (scan, (time.time() - _start_time))) except ScanDataMissingException: logger.error( "Scan " + str(scan) + " has no data") #Make sure to show 100% completion if self.progressUpdater is not None: self.progressUpdater(self.progressMax, self.progressMax) except IOError: raise IOError( "Cannot open file " + str(self.specFile)) if len(self.getAvailableScans()) == 0: raise ScanDataMissingException("Could not find scan data for " + \ "input file \n" + self.specFile + \ "\nOne possible reason for this " + \ "is that the image files are " + \ "missing. Images are assumed " + \ "to be in " + \ os.path.join(self.projectDir, IMAGE_DIR_MERGE_STR % self.projectName)) self.availableScanTypes = set(self.scanType.values()) def to_bool(self, value): """ Note this method found in answer to: http://stackoverflow.com/questions/715417/converting-from-a-string-to-boolean-in-python Converts 'something' to boolean. Raises exception if it gets a string it doesn't handle. Case is ignored for strings. These string values are handled: True: 'True', "1", "TRue", "yes", "y", "t" False: "", "0", "faLse", "no", "n", "f" Non-string values are passed to bool. """ if type(value) == type(''): if value.lower() in ("yes", "y", "true", "t", "1"): return True if value.lower() in ("no", "n", "false", "f", "0", ""): return False raise Exception('Invalid value for boolean conversion: ' + value) return bool(value) def rawmap(self,scans, angdelta=[0,0,0,0,0], adframes=None, mask = None): """ read ad frames and and convert them in reciprocal space angular coordinates are taken from the spec file or read from the edf file header when no scan number is given (scannr=None) """ if mask is None: mask_was_none = True #mask = [True] * len(self.getImageToBeUsed()[scans[0]]) else: mask_was_none = False #sd = spec.SpecDataFile(self.specFile) intensity = np.array([]) # fourc goniometer in fourc coordinates # convention for coordinate system: # x: upwards; # y: along the incident beam; # z: "outboard" (makes coordinate system right-handed). # QConversion will set up the goniometer geometry. # So the first argument describes the sample rotations, the second the # detector rotations and the third the primary beam direction. qconv = xu.experiment.QConversion(self.getSampleCircleDirections(), \ self.getDetectorCircleDirections(), \ self.getPrimaryBeamDirection()) # define experimental class for angle conversion # # ipdir: inplane reference direction (ipdir points into the primary beam # direction at zero angles) # ndir: surface normal of your sample (ndir points in a direction # perpendicular to the primary beam and the innermost detector # rotation axis) en = self.getIncidentEnergy() hxrd = xu.HXRD(self.getInplaneReferenceDirection(), \ self.getSampleSurfaceNormalDirection(), \ en=en[self.getAvailableScans()[0]], \ qconv=qconv) # initialize area detector properties if (self.getDetectorPixelWidth() != None ) and \ (self.getDistanceToDetector() != None): hxrd.Ang2Q.init_area(self.getDetectorPixelDirection1(), \ self.getDetectorPixelDirection2(), \ cch1=self.getDetectorCenterChannel()[0], \ cch2=self.getDetectorCenterChannel()[1], \ Nch1=self.getDetectorDimensions()[0], \ Nch2=self.getDetectorDimensions()[1], \ pwidth1=self.getDetectorPixelWidth()[0], \ pwidth2=self.getDetectorPixelWidth()[1], \ distance=self.getDistanceToDetector(), \ Nav=self.getNumPixelsToAverage(), \ roi=self.getDetectorROI()) else: hxrd.Ang2Q.init_area(self.getDetectorPixelDirection1(), \ self.getDetectorPixelDirection2(), \ cch1=self.getDetectorCenterChannel()[0], \ cch2=self.getDetectorCenterChannel()[1], \ Nch1=self.getDetectorDimensions()[0], \ Nch2=self.getDetectorDimensions()[1], \ chpdeg1=self.getDetectorChannelsPerDegree()[0], \ chpdeg2=self.getDetectorChannelsPerDegree()[1], \ Nav=self.getNumPixelsToAverage(), roi=self.getDetectorROI()) angleNames = self.getAngles() scanAngle = {} for i in range(len(angleNames)): scanAngle[i] = np.array([]) offset = 0 imageToBeUsed = self.getImageToBeUsed() monitorName = self.getMonitorName() monitorScaleFactor = self.getMonitorScaleFactor() filterName = self.getFilterName() filterScaleFactor = self.getFilterScaleFactor() for scannr in scans: if self.haltMap: raise ProcessCanceledException("Process Canceled") scan = self.sd.scans[str(scannr)] angles = self.getGeoAngles(scan, angleNames) scanAngle1 = {} scanAngle2 = {} for i in range(len(angleNames)): scanAngle1[i] = angles[:,i] scanAngle2[i] = [] if monitorName != None: monitor_data = scan.data.get(monitorName) if monitor_data is None: raise IOError("Did not find Monitor source '" + \ monitorName + \ "' in the Spec file. Make sure " + \ "monitorName is correct in the " + \ "instrument Config file") if filterName != None: filter_data = scan.data.get(filterName) if filter_data is None: raise IOError("Did not find filter source '" + \ filterName + \ "' in the Spec file. Make sure " + \ "filterName is correct in the " + \ "instrument Config file") # read in the image data arrayInitializedForScan = False foundIndex = 0 if mask_was_none: mask = [True] * len(self.getImageToBeUsed()[scannr]) for ind in range(len(scan.data[list(scan.data.keys())[0]])): if imageToBeUsed[scannr][ind] and mask[ind]: # read tif image im = Image.open(self.imageFileTmp % (scannr, scannr, ind)) img = np.array(im.getdata()).reshape(im.size[1],im.size[0]).T img = self.hotpixelkill(img) ff_data = self.getFlatFieldData() if not (ff_data is None): img = img * ff_data # reduce data siz img2 = xu.blockAverage2D(img, self.getNumPixelsToAverage()[0], \ self.getNumPixelsToAverage()[1], \ roi=self.getDetectorROI()) # apply intensity corrections if monitorName != None: img2 = img2 / monitor_data[ind] * monitorScaleFactor if filterName != None: img2 = img2 / filter_data[ind] * filterScaleFactor # initialize data array if not arrayInitializedForScan: imagesToProcess = [imageToBeUsed[scannr][i] and mask[i] for i in range(len(imageToBeUsed[scannr]))] if not intensity.shape[0]: intensity = np.zeros((np.count_nonzero(imagesToProcess),) + img2.shape) arrayInitializedForScan = True else: offset = intensity.shape[0] intensity = np.concatenate( (intensity, (np.zeros((np.count_nonzero(imagesToProcess),) + img2.shape))), axis=0) arrayInitializedForScan = True # add data to intensity array intensity[foundIndex+offset,:,:] = img2 for i in range(len(angleNames)): # logger.debug("appending angles to angle2 " + # str(scanAngle1[i][ind])) scanAngle2[i].append(scanAngle1[i][ind]) foundIndex += 1 if len(scanAngle2[0]) > 0: for i in range(len(angleNames)): scanAngle[i] = \ np.concatenate((scanAngle[i], np.array(scanAngle2[i])), \ axis=0) # transform scan angles to reciprocal space coordinates for all detector pixels angleList = [] for i in range(len(angleNames)): angleList.append(scanAngle[i]) if self.ubMatrix[scans[0]] is None: qx, qy, qz = hxrd.Ang2Q.area(*angleList, \ roi=self.getDetectorROI(), Nav=self.getNumPixelsToAverage()) else: qx, qy, qz = hxrd.Ang2Q.area(*angleList, \ roi=self.getDetectorROI(), Nav=self.getNumPixelsToAverage(), \ UB = self.ubMatrix[scans[0]]) # apply selected transform qxTrans, qyTrans, qzTrans = \ self.transform.do3DTransform(qx, qy, qz) return qxTrans, qyTrans, qzTrans, intensity
class ImportDialog(BaseImportDialog): """Dialog to import SPEC Scans""" def __init__(self, parent=None): super(ImportDialog, self).__init__(parent) self.accepted = False from nexpy.gui.consoleapp import _mainwindow self.default_directory = _mainwindow.default_directory self.import_file = None # must set in self.get_data() self.spec = None # progress bar is updated via calls to pdate_progress() self.progress_bar = QtGui.QProgressBar() self.progress_bar.setVisible(False) status_layout = QtGui.QHBoxLayout() status_layout.addWidget(self.progress_bar) status_layout.addStretch() status_layout.addWidget(self.close_buttons()) self.layout = QtGui.QVBoxLayout() self.layout.addLayout(self.filebox()) self.layout.addLayout(self.scanbox()) self.layout.addLayout(status_layout) self.setLayout(self.layout) self.setWindowTitle("Import " + str(filetype)) def scanbox(self): """create widgets for specifying scan range to import""" scanminlabel = QtGui.QLabel("Min. Scan") self.scanmin = QtGui.QLineEdit() self.scanmin.setFixedWidth(100) self.scanmin.setAlignment(QtCore.Qt.AlignRight) scanmaxlabel = QtGui.QLabel("Max. Scan") self.scanmax = QtGui.QLineEdit() self.scanmax.setFixedWidth(100) self.scanmax.setAlignment(QtCore.Qt.AlignRight) scanbox = QtGui.QHBoxLayout() scanbox.addWidget(scanminlabel) scanbox.addWidget(self.scanmin) scanbox.addWidget(scanmaxlabel) scanbox.addWidget(self.scanmax) return scanbox def choose_file(self): """ Opens file dialog, set file text box to the chosen path """ from spec2nexus.spec import SpecDataFile dirname = self.get_default_directory(self.filename.text()) filename = getOpenFileName(self, "Open file", dirname) if os.path.exists(filename): self.filename.setText(str(filename)) self.spec = SpecDataFile(self.get_filename()) self.set_default_directory(os.path.dirname(filename)) scan_min = self.spec.getMinScanNumber() self.scanmin.setText(str(scan_min)) scan_max = self.spec.getMaxScanNumber() self.scanmax.setText(str(scan_max)) def get_data(self): """read the data and return either :class:`NXroot` or :class:`NXentry`""" self.import_file = self.get_filename() if not os.path.exists(self.import_file): return None if self.spec is None: return None scan_min = int(self.scanmin.text()) scan_max = int(self.scanmax.text()) all_scans = self.spec.getScanNumbers() scans = [s for s in all_scans if scan_min <= s <= scan_max] self.spec.progress_bar = self.progress_bar self.spec.update_progress = self.update_progress return Parser(self.spec).toTree(scans)
class XPCSSpecDataSource(SpecXMLDrivenDataSource): def __init__(self, projectDir, projectName, projectExtension, instConfigFile, detConfigFile, **kwargs): self.pathToReplace = None self.replacePathWith = None if kwargs[PATH_TO_REPLACE] != None: self.pathToReplace = kwargs[PATH_TO_REPLACE] logger.debug("pathToReplace: %s" % self.pathToReplace) if kwargs[REPLACE_PATH_WITH] != None: self.replacePathWith = kwargs[REPLACE_PATH_WITH] logger.debug("replacePathWith: %s" % self.replacePathWith) del kwargs[PATH_TO_REPLACE] del kwargs[REPLACE_PATH_WITH] super(XPCSSpecDataSource, self).__init__(projectDir, projectName, projectExtension, instConfigFile, detConfigFile, **kwargs) # self.immDataFile = immDataFile logger.debug(METHOD_ENTER_STR) self.cancelLoad = False logger.debug(METHOD_EXIT_STR) def getGeoAngles(self, scan, angleNames): """ This function returns all of the geometry angles for the for the scan as a N-by-num_geo array, where N is the number of scan points and num_geo is the number of geometry motors. """ # scan = self.sd[scanNo] geoAngles = self.getScanAngles(scan, angleNames) return geoAngles def getUBMatrix(self, scan): """ Read UB matrix from the #G3 line from the spec file. """ try: g3 = scan.G["G3"].strip().split() g3 = np.array(list(map(float, g3))) ub = g3.reshape(-1, 3) logger.debug("ub " + str(ub)) return ub except: logger.error("Unable to read UB Matrix from G3") logger.error('-' * 60) traceback.print_exc(file=sys.stdout) logger.error('-' * 60) def imagesBeforeScan(self, scanNo): numImages = 0 scan = self.sd.scans[str(scanNo)] numImages = int(scan.data["img_n"][0]) return numImages def imagesInScan(self, scanNo): scan = self.sd.scans[str(scanNo)] numImages = len(scan.data_lines) return numImages def loadSource(self, mapHKL=False): logger.debug(METHOD_ENTER_STR) #Load up the instrument config XML file self.loadInstrumentXMLConfig() #Load up the detector configuration file self.loadDetectorXMLConfig() # lastScan = None self.specFile = os.path.join(self.projectDir, self.projectName + \ self.projectExt) try: self.sd = SpecDataFile(self.specFile) self.mapHKL = mapHKL maxScan = int(self.sd.getMaxScanNumber()) logger.debug("%s scans" % str(maxScan)) if self.scans is None: self.scans = range(1, maxScan + 1) imagePath = os.path.join(self.projectDir, IMAGE_DIR_MERGE_STR % self.projectName) self.imageBounds = {} self.imageToBeUsed = {} self.availableScans = [] self.incidentEnergy = {} self.ubMatrix = {} self.scanType = {} self.scanDataFile = {} self.immDataFileName = {} self.progress = 0 self.progressInc = 1 self.isCcdScan = {} self.dataFilePrefix = {} self.containsDark = {} self.numberOfDarks = {} self.containsRoi = {} self.roi = {} self.repeatsPoints = {} self.numberOfRepeatPoints = {} # Zero the progress bar at the beginning. if self.progressUpdater is not None: self.progressUpdater(self.progress, self.progressMax) for scan in self.scans: if (self.cancelLoad): self.cancelLoad = False raise LoadCanceledException(CANCEL_STR) else: # if (os.path.exists(os.path.join(imagePath, \ # SCAN_NUMBER_MERGE_STR % scan))): curScan = self.sd.scans[str(scan)] curScan.interpret() logger.debug("scan: %s" % scan) # if int(scan) > 1: # lastScan = self.sd.scans[str(int(scan)-1)] # lastScan.interpret() # logger.debug("dir(lastScan) = %s" % dir(lastScan) ) # logger.debug("lastScan.CCD %s" % lastScan.CCD) try: angles = self.getGeoAngles(curScan, self.angleNames) self.availableScans.append(scan) self.scanType[scan] = \ self.sd.scans[str(scan)].scanCmd.split()[0] logger.debug("Scan %s scanType %s" % (scan, self.scanType[scan])) if self.scanType[scan] == 'xpcsscan': #print dir(self.sd) d = curScan.data h = curScan.header dataFile = curScan.XPCS['batch_name'][0] self.immDataFileName[scan] = dataFile logger.debug("curScan.XPCS %s" % curScan.XPCS) if not (dataFile in self.scanDataFile.keys()): self.scanDataFile[dataFile] = {} numImagesInScan = self.imagesInScan(scan) self.scanDataFile[dataFile][scan] = \ range(0, numImagesInScan) self.scanDataFile[dataFile]['maxIndexImage'] = \ numImagesInScan logger.debug( "scanDataFile for " + \ str(dataFile) + " at scan " + str(scan) + \ " " + str(self.scanDataFile[dataFile][scan])) else: startingImage = \ self.scanDataFile[dataFile]['maxIndexImage'] numImagesInScan = self.imagesInScan(scan) self.scanDataFile[dataFile][scan] = \ range(startingImage, \ startingImage + numImagesInScan) self.scanDataFile[dataFile]['maxIndexImage'] = \ startingImage + numImagesInScan logger.debug( "scanDataFile for " + str(dataFile) + \ " at scan " + str(scan) + " " + \ str(self.scanDataFile[dataFile][scan] )) logger.debug("dataFile %s" % dataFile) elif curScan.CCD != None and \ 'ccdscan' in curScan.CCD.keys(): # this is a ccdscan where the defining #CCD lines # were above the #S lines in spec file #TODO d = curScan.data h = curScan.header ccdPart = curScan.CCD COUNTER_ROI_STR = 'counter_roi' REPEAT_POINTS_STR = 'repeats_per_point' self.isCcdScan[scan] = True self.dataFilePrefix[scan] = ccdPart['image_dir'][0] #If the data has moved from the original location # then we need to change the prefixPath if (self.pathToReplace != None) and \ (self.replacePathWith !=None): self.dataFilePrefix[scan] = self.dataFilePrefix[scan].\ replace(self.pathToReplace, \ self.replacePathWith) self.containsDark[scan] = DARK_STR in ccdPart.keys( ) self.numberOfDarks[scan] = int( ccdPart[DARK_STR][0]) self.containsRoi[ scan] = COUNTER_ROI_STR in ccdPart.keys() self.roi[scan] = map(int, ccdPart[COUNTER_ROI_STR]) self.repeatsPoints[ scan] = REPEAT_POINTS_STR in ccdPart.keys() self.numberOfRepeatPoints[scan] = ccdPart[ REPEAT_POINTS_STR] logger.debug("isCcdScan[%s] %s" % (scan, self.isCcdScan[scan])) logger.debug("dataFilePrefix[%s] %s" % (scan, self.dataFilePrefix[scan])) if self.containsDark[scan]: logger.debug("containsDark[%s] %s" % (scan, self.containsDark[scan])) logger.debug("numberOfDarks[%s] %s" % (scan, self.numberOfDarks[scan])) logger.debug("containsRoi[%s] %s" % (scan, self.containsRoi[scan])) if self.containsRoi[scan]: self.detectorROI = self.roi[scan] self.detectorROI[0] = self.roi[scan][0] self.detectorROI[ 1] = self.roi[scan][0] + self.roi[scan][1] self.detectorROI[2] = self.roi[scan][2] self.detectorROI[ 3] = self.roi[scan][2] + self.roi[scan][3] logger.debug("roi[%s] %s" % (scan, self.roi[scan])) logger.debug("repeatsPoints[%s] %s" % (scan, self.repeatsPoints[scan])) if self.repeatsPoints[scan]: logger.debug( "numberOfRepeatPoints[%s] %s" % (scan, self.numberOfRepeatPoints[scan])) if self.mapHKL == True: self.ubMatrix[scan] = self.getUBMatrix(curScan) if self.ubMatrix[scan] is None: raise Sector33SpecFileException("UB matrix " + \ "not found.") else: self.ubMatrix[scan] = None self.incidentEnergy[scan] = \ 12398.4 /float(curScan.G['G4'].split()[3]) _start_time = time.time() self.imageBounds[scan] = \ self.findImageQs(angles, \ self.ubMatrix[scan], \ self.incidentEnergy[scan]) if self.progressUpdater is not None: self.progressUpdater(self.progress, self.progressMax) logger.debug (('Elapsed time for Finding qs for scan %d: ' + '%.3f seconds') % \ (scan, (time.time() - _start_time))) #Make sure to show 100% completion except ScanDataMissingException: logger.debug("scan %s" % scan) if self.progressUpdater is not None: self.progressUpdater(self.progressMax, self.progressMax) except IOError: raise IOError("Cannot open file " + str(self.specFile)) # if len(self.getAvailableScans()) == 0: # raise ScanDataMissingException("Could not find scan data for " + \ # "input file \n" + self.specFile + \ # "\nOne possible reason for this " + \ # "is that the image files are " + \ # "missing. Images are assumed " + \ # "to be in " + \ # os.path.join(self.projectDir, # IMAGE_DIR_MERGE_STR % self.projectName)) #Load config information from the imm file self.availableScanTypes = set(self.scanType.values()) logger.debug(METHOD_EXIT_STR) def rawmap(self, scans, mask=None): if mask is None: mask_was_none = True #mask = [True] * len(self.getImageToBeUsed()[scans[0]]) else: mask_was_none = False intensity = np.array([]) # fourc goniometer in fourc coordinates # convention for coordinate system: # x: upwards; # y: along the incident beam; # z: "outboard" (makes coordinate system right-handed). # QConversion will set up the goniometer geometry. # So the first argument describes the sample rotations, the second the # detector rotations and the third the primary beam direction. qconv = xu.experiment.QConversion(self.getSampleCircleDirections(), \ self.getDetectorCircleDirections(), \ self.getPrimaryBeamDirection()) # define experimental class for angle conversion # # ipdir: inplane reference direction (ipdir points into the primary beam # direction at zero angles) # ndir: surface normal of your sample (ndir points in a direction # perpendicular to the primary beam and the innermost detector # rotation axis) en = self.getIncidentEnergy() hxrd = xu.HXRD(self.getInplaneReferenceDirection(), \ self.getSampleSurfaceNormalDirection(), \ en=en[self.getAvailableScans()[0]], \ qconv=qconv) if (self.getDetectorPixelWidth() != None ) and \ (self.getDistanceToDetector() != None): hxrd.Ang2Q.init_area(self.getDetectorPixelDirection1(), \ self.getDetectorPixelDirection2(), \ cch1=self.getDetectorCenterChannel()[0], \ cch2=self.getDetectorCenterChannel()[1], \ Nch1=self.getDetectorDimensions()[0], \ Nch2=self.getDetectorDimensions()[0], \ pwidth1=self.getDetectorPixelWidth()[0], \ pwidth2=self.getDetectorPixelWidth()[1], \ distance=self.getDistanceToDetector(), \ Nav=self.getNumPixelsToAverage(), \ roi=self.getDetectorROI()) else: hxrd.Ang2Q.init_area(self.getDetectorPixelDirection1(), \ self.getDetectorPixelDirection2(), \ cch1=self.getDetectorCenterChannel()[0], \ cch2=self.getDetectorCenterChannel()[1], \ Nch1=self.getDetectorDimensions()[0], \ Nch2=self.getDetectorDimensions()[0], \ chpdeg1=self.getDetectorChannelsPerDegree()[0], \ chpdeg2=self.getDetectorChannelsPerDegree()[1], \ Nav=self.getNumPixelsToAverage(), roi=self.getDetectorROI()) angleNames = self.getAngles() scanAngle = {} for i in range(len(angleNames)): scanAngle[i] = np.array([]) imageToBeUsed = self.getImageToBeUsed() #get startIndex and length for each image in the immFile imageDir = os.path.join(self.projectDir, IMAGES_STR) self.progressMax = len(self.scans) * 100 self.progressInc = 1.0 * 100.0 self.progress = 0 for scannr in scans: curScan = self.sd.scans[str(scannr)] curScan.interpret() logger.debug("scan: %s" % scannr) # if int(scannr) > 1: # lastScan = self.sd.scans[str(int(scannr)-1)] # lastScan.interpret() # logger.debug("dir(lastScan) = %s" % dir(curS) ) # logger.debug("lastScan.CCD %s" % lastScan.CCD) if curScan.CCD != None and \ 'ccdscan' in curScan.CCD.keys(): darkImage = None darksToSkip = 1 if self.containsDark[scannr]: numDarks = self.numberOfDarks[scannr] namePrefix = self.dataFilePrefix[scannr] darkName = namePrefix + DARK_STR + \ ("_00001-%.5d" % numDarks) + \ IMM_STR[1:] try: fp = open(darkName, 'rb') numImagesInFile = getNumberOfImages(fp) fp.close() if numImagesInFile < numDarks: raise RSMap3DException("dark file %s contains " + \ "only %d images. Spec " + \ "file says there should " + \ "be %d" % \ (darkName, \ numImagesInFile, \ numDarks)) imageStartIndex, dlen = \ GetStartPositions(darkName, numDarks) images = OpenMultiImm(darkName, darksToSkip -1, \ numDarks - darksToSkip, imageStartIndex, dlen) darkImage = np.average(images, axis=0) except Exception as ex: logger.exception(ex) # End reading dark Images # start reading sample images numScanPoints = len(curScan.data_lines) angles = self.getGeoAngles(curScan, angleNames) scanAngle1 = {} scanAngle2 = {} for i in range(len(angleNames)): scanAngle1[i] = angles[:, i] scanAngle2[i] = [] arrayInitializedForScan = False if mask_was_none: mask = True * len(self.getImageToBeUsed()[scannr]) mask1 = np.array(mask) logger.debug("mask1.shape %s" % str(mask1.shape)) indexesToProcess = (np.where(mask1 == True))[0] logger.debug("indexesToProcess.shape %s" % str(indexesToProcess.shape)) logger.debug("indexesToProcess %s" % str(indexesToProcess)) foundIndex = 0 minorProgressInc = self.progressInc / indexesToProcess.shape[ 0] minorProgress = self.progress for scanno in indexesToProcess: if self.progressUpdater is not None: self.progressUpdater(minorProgress, self.progressMax) minorProgress += minorProgressInc fileName = namePrefix + \ "%d_%.5d-%.5d" % (scanno, 1,1) + \ IMM_STR[1:] logger.debug("Reading filename %s fileName" % fileName) imageStartIndex, dlen = GetStartPositions(fileName, \ 1) # read single image from file with one image startImage = 0 numImages = 1 image = OpenMultiImm(fileName, startImage, \ numImages, imageStartIndex, dlen)[0] if not arrayInitializedForScan: if not intensity.shape[0]: offset = 0 intensity = np.zeros(( indexesToProcess.shape[0], ) + image.shape) arrayInitializedForScan = True else: offset = intensity.shape[0] intensity = np.concatenate((intensity, \ (np.zeros((indexesToProcess.shape[0],) + image.shape))), \ axis=0) logger.debug("foundIndex %s" % foundIndex) logger.debug(" instensity.shape %s" % str(intensity.shape)) logger.debug("image.shape %s" % str(image.shape)) if self.containsDark[scannr]: intensity[foundIndex + offset, :, :] = image - darkImage else: intensity[foundIndex + offset, :, :] = image - darkImage for i in range(len(angleNames)): scanAngle2[i].append(scanAngle1[i][scanno]) foundIndex += 1 if len(scanAngle2[0]) > 0: for i in range(len(angleNames)): scanAngle[i] = np.concatenate( (scanAngle[i], np.array(scanAngle2[i])), axis=0) else: immDataFile = self.immDataFileName[scannr] dataDir = os.path.join(imageDir, immDataFile) fullFileName = (glob.glob(os.path.join( dataDir, IMM_STR))[0]).replace('\\', '\\\\').replace('/', '\\\\') fullFileName = (glob.glob(os.path.join(dataDir, IMM_STR))[0]) imageStartIndex = [] dlen = [] try: fp = open(fullFileName, "rb") numImages = getNumberOfImages(fp) fp.close() imageStartIndex, dlen = GetStartPositions(fullFileName, \ numImages) fp = open(fullFileName, "rb") header = readHeader( fp, imageStartIndex[self.scanDataFile[immDataFile] [scannr][0]]) self.detectorROI = [ header['row_beg'], header['row_end'], header['col_beg'], header['col_end'] ] except IOError as ex: logger.error( "Problem opening IMM file to get the start indexes" + str(ex)) finally: fp.close() if self.haltMap: raise ProcessCanceledException("Process Canceled") scan = self.sd.scans[str(scannr)] angles = self.getGeoAngles(scan, angleNames) scanAngle1 = {} scanAngle2 = {} for i in range(len(angleNames)): scanAngle1[i] = angles[:, i] scanAngle2[i] = [] arrayInitializedForScan = False foundIndex = 0 if mask_was_none: mask = True * len(self.getImageToBeUsed()[scannr]) imagesToSkip = \ self.imagesBeforeScan(scannr) imagesInScan = \ self.imagesInScan(scannr) mask1 = np.array(mask) indexesToProcess = (np.where(mask1 == True))[0] startIndex = indexesToProcess[0] numberToProcess = len(indexesToProcess) images = OpenMultiImm(fullFileName, \ imagesToSkip + startIndex - 1, numberToProcess, imageStartIndex, dlen) minorProgressInc = self.progressInc / indexesToProcess.shape[0] minorProgress = self.progress for ind in indexesToProcess: if self.progressUpdater is not None: self.progressUpdater(minorProgress, self.progressMax) minorProgress += minorProgressInc if imageToBeUsed[scannr][ind] and mask[ind]: img = images[ind - startIndex, :, :] img2 = img #initialize data Array if not arrayInitializedForScan: imagesToProcess = [imageToBeUsed[scannr][i] and mask[i] \ for i in range(len(imageToBeUsed[scannr]))] if not intensity.shape[0]: offset = 0 intensity = np.zeros( (np.count_nonzero(imagesToProcess), ) + img2.shape) arrayInitializedForScan = True else: offset = intensity.shape[0] intensity = np.concatenate( (intensity, (np.zeros( (np.count_nonzero(imagesToProcess), ) + img2.shape))), axis=0) #add data to intensity array intensity[foundIndex + offset, :, :] = img2 for i in range(len(angleNames)): scanAngle2[i].append(scanAngle1[i][ind]) foundIndex += 1 if len(scanAngle2[0]) > 0: for i in range(len(angleNames)): scanAngle[i] = \ np.concatenate((scanAngle[i], np.array(scanAngle2[i])), \ axis=0) self.progress += self.progressInc if self.progressUpdater is not None: self.progressUpdater(self.progress, self.progressMax) # transform scan angles to reciprocal space coordinates for all detector # pixels angleList = [] for i in range(len(angleNames)): angleList.append(scanAngle[i]) if self.ubMatrix[scans[0]] is None: qx, qy, qz = hxrd.Ang2Q.area( *angleList, \ roi = self.getDetectorROI(), Nav=self.getNumPixelsToAverage()) else: qx, qy, qz = hxrd.Ang2Q.area( *angleList, \ roi=self.getDetectorROI(), \ Nav=self.getNumPixelsToAverage(), UB=self.ubMatrix[scans[0]]) # apply selected transform qxTrans, qyTrans, qzTrans = \ self.transform.do3DTransform(qx, qy, qz) logger.debug( "Shape of qxTrans %s, qyTrans %s, qzTrans %s, intensity %s" % (str(qxTrans.shape), str(qyTrans.shape), str( qzTrans.shape), str(intensity.shape))) return qxTrans, qyTrans, qzTrans, intensity def rawmapSingle(self, scan): intensity = np.array([]) # fourc goniometer in fourc coordinates # convention for coordinate system: # x: upwards; # y: along the incident beam; # z: "outboard" (makes coordinate system right-handed). # QConversion will set up the goniometer geometry. # So the first argument describes the sample rotations, the second the # detector rotations and the third the primary beam direction. qconv = xu.experiment.QConversion(self.getSampleCircleDirections(), \ self.getDetectorCircleDirections(), \ self.getPrimaryBeamDirection()) # define experimental class for angle conversion # # ipdir: inplane reference direction (ipdir points into the primary beam # direction at zero angles) # ndir: surface normal of your sample (ndir points in a direction # perpendicular to the primary beam and the innermost detector # rotation axis) en = self.getIncidentEnergy() hxrd = xu.HXRD(self.getInplaneReferenceDirection(), \ self.getSampleSurfaceNormalDirection(), \ en=en[self.getAvailableScans()[0]], \ qconv=qconv) if (self.getDetectorPixelWidth() != None ) and \ (self.getDistanceToDetector() != None): hxrd.Ang2Q.init_area(self.getDetectorPixelDirection1(), \ self.getDetectorPixelDirection2(), \ cch1=self.getDetectorCenterChannel()[0], \ cch2=self.getDetectorCenterChannel()[1], \ Nch1=self.getDetectorDimensions()[0], \ Nch2=self.getDetectorDimensions()[0], \ pwidth1=self.getDetectorPixelWidth()[0], \ pwidth2=self.getDetectorPixelWidth()[1], \ distance=self.getDistanceToDetector(), \ Nav=self.getNumPixelsToAverage(), \ roi=self.getDetectorROI()) else: hxrd.Ang2Q.init_area(self.getDetectorPixelDirection1(), \ self.getDetectorPixelDirection2(), \ cch1=self.getDetectorCenterChannel()[0], \ cch2=self.getDetectorCenterChannel()[1], \ Nch1=self.getDetectorDimensions()[0], \ Nch2=self.getDetectorDimensions()[0], \ chpdeg1=self.getDetectorChannelsPerDegree()[0], \ chpdeg2=self.getDetectorChannelsPerDegree()[1], \ Nav=self.getNumPixelsToAverage(), roi=self.getDetectorROI()) # Setup list of angles to produce transform angleNames = self.getAngles() scanAngle = {} for i in range(len(angleNames)): scanAngle[i] = np.array([]) logger.debug("scan %s" % scan) angles = self.getGeoAngles(self.sd.scans[str(scan)], angleNames) angles = np.array([ angles[0], ]) logger.debug("angles %s" % angles) for i in range(len(angleNames)): scanAngle[i] = np.concatenate((scanAngle[i], np.array(angles[:,i])), \ axis=0) # transform scan angles to reciprocal space coordinates for all detector # pixels angleList = [] for i in range(len(angleNames)): angleList.append(scanAngle[i]) if self.ubMatrix[scan] is None: qx, qy, qz = hxrd.Ang2Q.area( *angleList, \ roi = self.getDetectorROI(), Nav=self.getNumPixelsToAverage()) else: qx, qy, qz = hxrd.Ang2Q.area( *angleList, \ roi=self.getDetectorROI(), \ Nav=self.getNumPixelsToAverage(), UB=self.ubMatrix[scan]) # apply selected transform qxTrans, qyTrans, qzTrans = \ self.transform.do3DTransform(qx, qy, qz) return qxTrans, qyTrans, qzTrans
class ImportDialog(BaseImportDialog): """Dialog to import SPEC Scans""" def __init__(self, parent=None): super(ImportDialog, self).__init__(parent) self.accepted = False from nexpy.gui.consoleapp import _mainwindow self.default_directory = _mainwindow.default_directory self.import_file = None # must set in self.get_data() self.spec = None # progress bar is updated via calls to pdate_progress() self.progress_bar = QtGui.QProgressBar() self.progress_bar.setVisible(False) status_layout = QtGui.QHBoxLayout() status_layout.addWidget(self.progress_bar) status_layout.addStretch() status_layout.addWidget(self.close_buttons()) self.layout = QtGui.QVBoxLayout() self.layout.addLayout(self.filebox()) self.layout.addLayout(self.scanbox()) self.layout.addLayout(status_layout) self.setLayout(self.layout) self.setWindowTitle("Import " + str(filetype)) def scanbox(self): '''create widgets for specifying scan range to import''' scanminlabel = QtGui.QLabel("Min. Scan") self.scanmin = QtGui.QLineEdit() self.scanmin.setFixedWidth(100) self.scanmin.setAlignment(QtCore.Qt.AlignRight) scanmaxlabel = QtGui.QLabel("Max. Scan") self.scanmax = QtGui.QLineEdit() self.scanmax.setFixedWidth(100) self.scanmax.setAlignment(QtCore.Qt.AlignRight) scanbox = QtGui.QHBoxLayout() scanbox.addWidget(scanminlabel) scanbox.addWidget(self.scanmin) scanbox.addWidget(scanmaxlabel) scanbox.addWidget(self.scanmax) return scanbox def choose_file(self): ''' Opens file dialog, set file text box to the chosen path ''' from spec2nexus.spec import SpecDataFile dirname = self.get_default_directory(self.filename.text()) filename = getOpenFileName(self, 'Open file', dirname) if os.path.exists(filename): self.filename.setText(str(filename)) self.spec = SpecDataFile(self.get_filename()) self.set_default_directory(os.path.dirname(filename)) scan_min = self.spec.getMinScanNumber() self.scanmin.setText(str(scan_min)) scan_max = self.spec.getMaxScanNumber() self.scanmax.setText(str(scan_max)) def get_data(self): '''read the data and return either :class:`NXroot` or :class:`NXentry`''' self.import_file = self.get_filename() if not os.path.exists(self.import_file): return None if self.spec is None: return None scan_min = int(self.scanmin.text()) scan_max = int(self.scanmax.text()) all_scans = self.spec.getScanNumbers() scans = [s for s in all_scans if scan_min <= s <= scan_max] self.spec.progress_bar = self.progress_bar self.spec.update_progress = self.update_progress return Parser(self.spec).toTree(scans)
class ReadSpec(): """Loads spec file and gets appropriate information from it for a certain image. """ def __init__(self, parent=None): self.mon = [] self.mainWindow = parent self.detectorDialog = DetectorDialog(self) def loadSpec(self, specFile, directory): """This method loads the spec file and creates the widgets on the control QDockWidget. """ self.chambers = [] self.specFile = SpecDataFile(specFile) self.specHeader = SpecDataFileHeader(specFile) self.scans = self.specFile.scans self.scan = str(int(os.path.basename(directory))) self.specFileOpened = True self.maxScans = self.specFile.getMaxScanNumber() # Gets possible normalizer values for key in self.scans[self.scan].data.keys(): if key.find("Ion_Ch_") == 0: self.chambers.append(key) self.chambers.sort() self.MonDialog() self.mainWindow.controlDockWidget.close() self.mainWindow.ControlDockWidget() def MonDialog(self): """Dialog produce for the user to select the mon value. """ self.monDialog = QDialog(self.mainWindow) dialogBox = QVBoxLayout() buttonLayout = QHBoxLayout() vBox = QVBoxLayout() groupBox = QGroupBox("Mon") self.buttonGroup = QButtonGroup(groupBox) for norm in self.chambers: chamberRB = QRadioButton(norm) self.buttonGroup.addButton(chamberRB, int(norm[-1])) vBox.addWidget(chamberRB) groupBox.setLayout(vBox) ok = QPushButton("Ok") ok.clicked.connect(self.SetMon) buttonLayout.addStretch(1) buttonLayout.addWidget(ok) dialogBox.addWidget(groupBox) dialogBox.addLayout(buttonLayout) self.monDialog.setWindowTitle("Select chamber") self.monDialog.setLayout(dialogBox) self.monDialog.resize(250, 250) self.monDialog.exec_() def SetMon(self): """Sets the mon. """ if self.buttonGroup != -1: self.monDialog.close() for cham in self.chambers: if cham.endswith(str(self.buttonGroup.checkedId())): self.mon = self.scans[str(self.scan)].data[cham] def DataControlLabels(self): """Gets the appropriate labels for the spec file info display in the control's QDockWidget. """ controls = [] for key in self.scans[self.scan].L: if key == 'L': controls.append(key) break else: controls.append(key) return controls def setSpecData(self): """Sets the spec data into the self.specInfoValue. """ try: self.specInfoValue = [] for n in self.specInfo: if n == "E": self.specInfoValue.append(self.getEnergy()) elif n == "MON": self.specInfoValue.append(self.mon) elif n == "Trans": self.specInfoValue.append(self.scans[self.scan].data["transm"]) else: self.specInfoValue.append(self.scans[self.scan].data[str(n)]) except: QMessageBox.warning(self.mainWindow, "Warning", "Error loading the values from the spec. Please make sure " "they follow the appropriate format.") def getSpecData(self, i): """Gets the appropriate spec value for the selected image. """ try: specValue = [] for n in self.specInfoValue: if isinstance(n, list): specValue.append(n[i]) else: specValue.append(n) j = 0 for n in specValue: self.specInfoBoxes[j].setText(str(n)) j += 1 except IndexError: QMessageBox.warning(self.mainWindow, "Error", 'Please make sure you have the correct spec file, and/or have have the ' 'images folder named properly with the scan number.') def SpecDataInfo(self): """Creates the labels and text boxes for the spec info display in the Controls QDockWidget. """ self.specInfo = [] self.specInfoLabels = [] self.specInfoBoxes = [] self.specInfoLayout = [] self.specInfo = self.DataControlLabels() self.specInfo.append("E") self.specInfo.append("MON") self.specInfo.append("Trans") for s in self.specInfo: label = QLabel(str(s), alignment=Qt.AlignCenter) textBox = QLineEdit() textBox.setReadOnly(True) textBox.setMaximumWidth(50) self.specInfoLabels.append(label) self.specInfoBoxes.append(textBox) j = 0 vBoxLayout = QVBoxLayout() while j < len(self.specInfo): if len(self.specInfo) - j >= 3: s = 0 hBox = QHBoxLayout() while s < 3: hBox.addWidget(self.specInfoLabels[j]) hBox.addWidget(self.specInfoBoxes[j]) j += 1 s += 1 vBoxLayout.addLayout(hBox) else: hBox1 = QHBoxLayout() while len(self.specInfo) - j > 0: hBox1.addWidget(self.specInfoLabels[j]) hBox1.addWidget(self.specInfoBoxes[j]) j += 1 hBox1.addStretch(1) vBoxLayout.addLayout(hBox1) self.setSpecData() return vBoxLayout def getEnergy(self): """Gets the energy from the spec file. """ data = self.scans[str(self.scan)].raw UE = data.split("#UE") ue = UE[1].split(" ") energy = ue[1] return float(energy) * 1000 def getUBMatrix(self): """Read UB matrix from the #G3 line from the spec file. :return: 2D array, with 1D arrays size 3 """ try: g3 = self.scans[self.scan].G["G3"].strip().split() g3 = np.array(map(float, g3)) ub = g3.reshape(-1, 3) return ub except: print ("Unable to read the UB Matrix from G3.") def getListSpecDataForAngles(self): """Gets the eta, chi and phi from the spec file. :return: returns eta, chi and phi """ angleListInfo = [] angles = self.detectorDialog.getAngles() for angle in angles: try: angleListInfo.append(self.specFile.scans[self.scan].data[angle]) except KeyError: try: motorValue = self.motorSpecInfoDic[angle] angList = np.full((self.totalScans, 1), float(motorValue), dtype=float) angleListInfo.append(angList) except: print ("Make sure there's reference of the angles provided in the spec file..") return angleListInfo def getSpecHeaderO(self, specFile): """Gets the values for the spec motors/angles input by the user. :param specFile: :return: Dictionary with spec anlge and value """ self.totalScans = 0 self.motorSpecInfoDic = {} buf = open(specFile, 'r').read() buf.replace('\r\n', '\n').replace('\r', '\n') lines = buf.splitlines() for line in lines: if line.startswith("#O0"): lineO = line break O = lineO.split() O.pop(0) lineP = self.specFile.scans[self.scan].P[0] P = lineP.split() if len(O) != len(P): raise Exception ("Please make sure the spec file contains matching information in the header #O0 and under" " the scan #P0.\n\n" "#O0: " + O + "\n#P0: " + P) else: for i in xrange(len(P)): self.motorSpecInfoDic.update({O[i]: P[i]}) try: s = self.scans[self.scan].S.split() self.totalScans = int(s[len(s)-2]) except: pass # Make the user input the total scans. def rawMap(self): """Gets the hkl for each image in the scan :return: """ # Some stuff to add for the future: # - Doing the data in chunks if the data is too big try: intensity = np.array([]) angleList = self.getListSpecDataForAngles() qconv = xu.experiment.QConversion(self.detectorDialog.getSampleCircleDirections(), self.detectorDialog.getDetectorCircleDirections(), self.detectorDialog.getPrimaryBeamDirection()) offset = 0 scan = self.scans[self.scan] en = self.getEnergy() hxrd = xu.HXRD(self.detectorDialog.getInplaneReferenceDirection(), self.detectorDialog.getSampleSurfaceNormalDirection(), en=en, qconv=qconv) hxrd.Ang2Q.init_area(self.detectorDialog.getDetectorPixelDirection1(), self.detectorDialog.getDetectorPixelDirection2(), cch1=self.detectorDialog.getDetectorCenterChannel()[0], cch2=self.detectorDialog.getDetectorCenterChannel()[1], Nch1=self.detectorDialog.getDetectorDimensions()[0], Nch2=self.detectorDialog.getDetectorDimensions()[1], pwidth1=self.detectorDialog.getDetectorPixelWidth()[0], pwidth2=self.detectorDialog.getDetectorPixelWidth()[1], distance=self.detectorDialog.getDistanceToDetector(), Nav=self.detectorDialog.getNumPixelsToAverage(), roi=self.detectorDialog.getDetectorROI()) arrayInitializedForScan = False """ foundIndex = 0 for ind in xrange(len(scan.data[scan.data.keys()[0]])): im = Image.open(self.mainWindow.fileList[ind]) img = np.array(im.getdata()).reshape(im.size[1], im.size[0]).T img2 = xu.blockAverage2D(img, self.detectorDialog.getNumPixelsToAverage()[0], self.detectorDialog.getNumPixelsToAverage()[1], roi=self.detectorDialog.getDetectorROI())""" h, k, l = hxrd.Ang2Q.area(*angleList, roi=self.detectorDialog.getDetectorROI(), Nav=self.detectorDialog.getNumPixelsToAverage(), UB = self.getUBMatrix()) print 'H' print h print 'k' print k print 'L' print l print l[:, 0] plt.imshow(l[120]) plt.colorbar() plt.show() print l.shape except Exception as ex: QMessageBox.warning(self.mainWindow, "Error", "Something went wrong while getting the rawmap. \n\n Exception: " + str(ex))