def test_is_Bluesky_specfile():
folder = join("polartools", "tests", "data_for_test")
# Tests with spec loading within polartools.
result = load_data.is_Bluesky_specfile("pressure_calibration.dat",
folder=folder)
assert result is False
result = load_data.is_Bluesky_specfile("bluesky_spec.dat", folder=folder)
assert result is True
result = load_data.is_Bluesky_specfile("absorption.dat", folder=folder)
assert result is False
# Tests loading the spec file here.
spec_file = SpecDataFile(join(folder, "pressure_calibration.dat"))
result = load_data.is_Bluesky_specfile(spec_file)
assert result is False
spec_file = SpecDataFile(join(folder, "bluesky_spec.dat"))
result = load_data.is_Bluesky_specfile(spec_file)
assert result is True
spec_file = SpecDataFile(join(folder, "absorption.dat"))
result = load_data.is_Bluesky_specfile(spec_file)
assert result is False
def setUp(self):
self.specDisplay = SpecDisplay()
self.dataPath = os.environ.get(DATAPATH)
specFileName1 = os.path.join(self.dataPath, FLUORESCENCE_FILE)
try:
self.specFile1 = SpecDataFile(specFileName1)
except Exception as ex:
self.fail(ex)
specFileName2 = os.path.join(self.dataPath, FLUORESCENCE_FILE)
try:
self.specFile2 = SpecDataFile(specFileName2)
except Exception as ex:
self.fail(ex)
def load_spec_file(self):
if self.spec_fname == '':
self.status.showMessage('No file was loaded')
return
self.scan.scans_box.clear()
try:
self._spec_file = SpecDataFile(self.spec_fname)
self._commands_list = self._spec_file.getScanCommands()
for i in range(len(self._commands_list)):
if '#S' in self._commands_list[i]:
self._commands_list[i] = self._commands_list[i].strip(
'#S ')
self.scan.scans_box.addItem(self._commands_list[i])
self.scan.scans_box.setCurrentIndex(len(self._commands_list) - 1)
self.selected_scan(self._commands_list[-1])
self.make_plot()
self.pressure.print_pressure.setText('')
except:
self.status.showMessage('{} is not a spec file!!'.format(
self.spec.fname.text()))
def testScanSelected(self):
selectedScan = 5
specFile = os.path.join(self.dataPath, FLUORESCENCE_FILE)
spyLoaded = QSignalSpy(self.scanBrowser.scanLoaded)
specData = SpecDataFile(specFile)
self.scanBrowser.loadScans(specData.scans)
self.assertEqual(len(spyLoaded), 1)
self.assertEqual(len(self.spySelected), 0)
self.scanBrowser.setCurrentScan(selectedScan)
self.assertEqual(len(spyLoaded), 1)
self.assertEqual(len(self.spySelected), 1)
self.assertEqual(self.scanBrowser.getCurrentScan(), '6')
self.scanBrowser.filterByScanTypes(specData.scans, SCAN_TYPES[2])
self.assertEqual(len(spyLoaded), 2)
self.assertEqual(len(self.spySelected), 1)
# Doesn't register a selection change since row has not changed
self.scanBrowser.setCurrentScan(selectedScan)
self.assertEqual(len(spyLoaded), 2)
self.assertEqual(len(self.spySelected), 1)
self.assertEqual(self.scanBrowser.getCurrentScan(), '12')
# Register a selection change since row changed
self.scanBrowser.setCurrentScan(selectedScan + 1)
self.assertEqual(len(spyLoaded), 2)
self.assertEqual(len(self.spySelected), 2)
self.assertEqual(self.scanBrowser.getCurrentScan(), '13')
def test_xrd_calibrate_pressure():
path = join('polartools', 'tests', 'data_for_test')
# Au calibrant
pressure = xrd_calibrate_pressure(419,
'pressure_calibration.dat',
temperature=9,
energy=12.0,
positioner='4C Two Theta',
detector='CyberMag',
monitor='IC3',
folder=path)
assert allclose(pressure, 0.743387, atol=1e-5)
# Ag calibrant
spec_file = SpecDataFile(join(path, 'pressure_calibration.dat'))
pressure = xrd_calibrate_pressure(419,
spec_file,
temperature=9,
energy=12.0,
calibrant='Ag',
positioner='4C Two Theta',
detector='CyberMag',
monitor='IC3')
assert allclose(pressure, 0.818770, atol=1e-5)
def load_spec(scan_id, spec_file, folder=""):
"""
Load data from spec file.
If `spec_file` is the file name, it will load the spec file internally
which is time consuming.
Parameters
----------
scan_id : int
Scan_id of the scan to be retrieved.
spec_file : string or spec2nexus.spec.SpecDataFile
Either the spec file name or a SpecDataFile instance.
folder : string, optional
Folder where spec file is located.
Returns
-------
data : pandas.DataFrame
Table with the data from scan.
See also
--------
:func:`spec2nexus.spec.SpecDataFile`
"""
if isinstance(spec_file, str):
path = join(folder, spec_file)
spec_file = SpecDataFile(path)
return DataFrame(spec_file.getScan(scan_id).data)
def is_Bluesky_specfile(source, folder=""):
"""
Check if the specfile was created by Bluesky.
It looks for a "Bluesky" comment in the file header.
Parameters
----------
source : string or spec2nexus.spec.SpecDataFile
Either the spec file name or a SpecDataFile instance.
folder : string, optional
Folder where spec file is located.
Returns
-------
y : bool
True if spec_file was generated by Bluesky, False otherwise.
See also
--------
:func:`spec2nexus.spec.SpecDataFile`
"""
if isinstance(source, str):
path = join(folder, source)
source = SpecDataFile(path)
if len(source.headers[0].comments):
return source.headers[0].comments[0].startswith("Bluesky")
else:
return False
def openFile(self):
'''
Open a file, populate the navigator window as appropriate
'''
logger.debug(METHOD_ENTER_STR)
fOptions = qtWidgets.QFileDialog.Options()
fOptions |= qtWidgets.QFileDialog.DontUseNativeDialog
fileName = qtWidgets.QFileDialog.getOpenFileName(
self,
caption="Open Spec File",
directory=self.currentDirectory,
options=fOptions)[0]
specFile = None
if fileName != "":
try:
specFile = SpecDataFile(fileName)
except NotASpecDataFile as ex:
qtWidgets.QMessageBox.warning(
self, "Not a Spec File",
"The file %s does not seem to be a spec file" % fileName)
return
self.currentDirectory = str(os.path.realpath(fileName))
else:
return
self._dataNavigator.addSpecDataFileNode(specFile)
def setUp(self):
self.selection = IntermediateDataSelection()
print(dir (self.selection))
self.dataPath = os.environ.get(DATAPATH)
specDataFileName = os.path.join(self.dataPath, FLUORESCENCE_FILE)
specDataFile = SpecDataFile(specDataFileName)
specNode = SpecFileDataNode(specDataFile)
def __init__(self, specPath):
super(SpecFile, self).__init__(parent=None)
self.specFilePath = specPath
self.specFile = SpecDataFile(specPath)
self.scanBrowser = ScanBrowser()
self.scanBrowser.loadScans(self.getScans(), self)
self.selectedScans = []
def __init__(self, specfile):
if os.path.exists(specfile):
from spec2nexus.spec import SpecDataFile
self.filename = specfile
stat = os.stat(specfile)
self.size = stat.st_size
self.mtime = stat.st_mtime
self.sdf_object = SpecDataFile(specfile)
def specFileInfo(self):
"""This method sets the name, status tip for the spec file, and loads the scan to the list
from the spec file.
"""
self.rdOnlyFileName.setText(self.readSpec.specFileName)
self.rdOnlyFileName.setStatusTip(self.readSpec.specFileName)
specFile = SpecDataFile(self.readSpec.specFileName)
self.readSpec.loadScans(specFile.scans)
def openFile(self):
fileName = qtWidgets.QFileDialog.getOpenFileName(
None, "Open Spec File")[0]
self.specFile = SpecDataFile(fileName)
self.setWindowTitle(APP_NAME + ' - ' + str(fileName))
firstScan = self.specFile.getFirstScanNumber()
self.positionerSelector.loadPositioners(
self.specFile.scans[firstScan].positioner)
def test_contents(self):
spec_data = SpecDataFile(self.fname)
self.assertTrue(isinstance(spec_data, SpecDataFile))
out = writer.Writer(spec_data)
scan_list = [
1,
]
out.save(self.hname, scan_list)
# text that UXML group defined as expected
self.assertTrue(os.path.exists(self.hname))
with h5py.File(self.hname) as h5_file:
self.assertTrue("S1" in h5_file)
nxentry = h5_file["/S1"]
self.assertTrue("UXML" in nxentry)
uxml = nxentry["UXML"]
self.assertTrue("NX_class" in uxml.attrs)
self.assertEqual(uxml.attrs["NX_class"], "NXnote")
# spot-check a couple items
# group: attenuator_set
self.assertTrue("attenuator_set" in uxml)
group = uxml["attenuator_set"]
prefix = group.attrs.get("prefix")
description = group.attrs.get("description")
unique_id = group.attrs.get("unique_id")
self.assertEqual(prefix, "33idd:filter:")
self.assertEqual(description, "33-ID-D Filters")
self.assertEqual(unique_id, None)
# <dataset name="corrdet_counter">corrdet</dataset>
self.assertTrue("corrdet_counter" in group)
ds = group["corrdet_counter"]
# http://docs.h5py.org/en/stable/whatsnew/2.1.html?highlight=dataset#dataset-value-property-is-now-deprecated
value = ds[()] # ds.value deprecated in h5py
self.assertEqual(value, [b"corrdet"])
# <dataset name="wait_time" type="float" units="s">0.500</dataset>
self.assertTrue("wait_time" in group)
ds = group["wait_time"]
attrs = dict(ds.attrs)
self.assertEqual(ds.attrs.get("units"), "s")
value = ds[()] # ds.value deprecated in h5py
self.assertEqual(value, numpy.array([.5]))
# <hardlink name="attenuator1" target_id="33idd:filter:Fi1:"/>
self.assertTrue("attenuator1" in group)
attenuator1 = group["attenuator1"]
target = attenuator1.attrs.get("target")
self.assertNotEqual(target, attenuator1.name)
self.assertEqual(target, uxml["attenuator1"].name)
addr = "/S1/UXML/ad_file_info/file_format"
self.assertTrue(addr in h5_file)
ds = h5_file[addr]
value = ds[()] # ds.value deprecated in h5py
self.assertEqual(value, [b"TIFF"])
def testLoadScans(self):
specFile = os.path.join(self.dataPath, FLUORESCENCE_FILE)
print("SpecDataFile %s" % specFile)
specData = SpecDataFile(specFile)
self.scanBrowser.loadScans(specData.scans, newFile=True)
self.assertEqual(len(self.spyLoaded), 1)
self.assertEqual(len(self.spySelected), 0)
self.assertEqual(self.scanBrowser.scanList.rowCount(),
len(specData.getScanNumbers()))
def testName(self):
spec_data = SpecDataFile(self.fname)
self.assertTrue(isinstance(spec_data, SpecDataFile))
out = writer.Writer(spec_data)
scan_list = [
1,
]
out.save(self.hname, scan_list)
# TODO: make tests of other things in the Writer
dd = out.root_attributes()
self.assertTrue(isinstance(dd, dict))
def testName(self):
spec_data = SpecDataFile(self.fname)
self.assertTrue(isinstance(spec_data, SpecDataFile))
scan = spec_data.getScan(1)
with self.assertRaises(spec2nexus.plugins.uxml.UXML_Error) as context:
scan.interpret()
received = str(context.exception)
expected = "UXML error: Element 'group': "
expected += "Character content other than whitespace is not allowed "
expected += "because the content type is 'element-only'."
self.assertTrue(received.startswith(expected))
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))
all_scans = self.get_scan_numbers()
scan_min = all_scans[0]
self.scanmin.setText(str(scan_min))
scan_max = all_scans[-1]
self.scanmax.setText(str(scan_max))
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 reload(self):
logger.debug(METHOD_ENTER_STR)
scanKeys = sorted(self._specDataFile.scans, key=int)
logger.debug("Unload the old data")
filename = self._specDataFile.fileName
for scan in scanKeys:
logger.debug("scan to remove %s" % self.scans[scan].__class__)
self.removeSpecScan(scan)
for scan in self._specDataFile.scans:
scan = None
self._specDataFile = None
gc.collect
logger.debug("Load current data in the file")
self._specDataFile = SpecDataFile(filename)
self.loadScans()
gc.collect()
def _browseForPathToReplace(self):
if os.path.exists(str(self.projNameTxt.text())) and \
(str(self.scanNumsTxt.text()) != ""):
specFile = str(self.projNameTxt.text())
scans = self.getScanList()
sd = SpecDataFile(specFile)
scan = sd.scans[str(scans[0])]
scan.interpret()
if scan.CCD != None:
try:
filePath = scan.CCD['image_dir'][0]
self.pathToReplaceTxt.setText(filePath)
except:
qtWidgets.QMessageBox.warning(self, "File patgh not Found", \
"File path not found for scan %s" \
% scan)
self.pathToReplaceTxt.editingFinished.emit()
def testFilterByScanTypes(self):
specFile = os.path.join(self.dataPath, FLUORESCENCE_FILE)
spyLoaded = QSignalSpy(self.scanBrowser.scanLoaded)
specData = SpecDataFile(specFile)
self.scanBrowser.loadScans(specData.scans)
self.assertEqual(len(spyLoaded), 1)
self.assertEqual(len(self.spySelected), 0)
self.scanBrowser.filterByScanTypes(specData.scans, SCAN_TYPES[1])
self.assertEqual(self.scanBrowser.scanList.rowCount(),
NUM_SCAN_TYPES[1])
self.scanBrowser.filterByScanTypes(specData.scans, SCAN_TYPES[2])
self.assertEqual(self.scanBrowser.scanList.rowCount(),
NUM_SCAN_TYPES[2])
self.scanBrowser.filterByScanTypes(specData.scans, SCAN_TYPES[3])
self.assertEqual(self.scanBrowser.scanList.rowCount(),
NUM_SCAN_TYPES[3])
self.scanBrowser.filterByScanTypes(specData.scans, SCAN_TYPES[4])
self.assertEqual(self.scanBrowser.scanList.rowCount(),
NUM_SCAN_TYPES[4])
self.scanBrowser.filterByScanTypes(specData.scans, SCAN_TYPES[5])
self.assertEqual(self.scanBrowser.scanList.rowCount(),
NUM_SCAN_TYPES[5])
self.scanBrowser.filterByScanTypes(specData.scans, SCAN_TYPES[6])
self.assertEqual(self.scanBrowser.scanList.rowCount(),
NUM_SCAN_TYPES[6])
self.scanBrowser.filterByScanTypes(specData.scans, SCAN_TYPES[7])
self.assertEqual(self.scanBrowser.scanList.rowCount(),
NUM_SCAN_TYPES[7])
self.scanBrowser.filterByScanTypes(specData.scans, SCAN_TYPES[8])
self.assertEqual(self.scanBrowser.scanList.rowCount(),
NUM_SCAN_TYPES[8])
self.scanBrowser.filterByScanTypes(specData.scans, SCAN_TYPES[1:])
self.assertEqual(self.scanBrowser.scanList.rowCount(),
NUM_SCAN_TYPES[0])
self.scanBrowser.filterByScanTypes(specData.scans, [])
self.assertEqual(self.scanBrowser.scanList.rowCount(),
NUM_SCAN_TYPES[0])
with self.assertRaises(ValueError):
self.scanBrowser.filterByScanTypes(specData.scans, None)
self.assertEqual(NUM_SCAN_TYPES[0], sum(NUM_SCAN_TYPES[1:]))
self.assertEqual(len(spyLoaded), 11)
self.assertEqual(len(self.spySelected), 0)
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 test_contents(self):
spec_data = SpecDataFile(self.fname)
self.assertTrue(isinstance(spec_data, SpecDataFile))
out = writer.Writer(spec_data)
scan_list = [
1,
]
out.save(self.hname, scan_list)
# the ONLY structural difference between test_3.spec
# and test_4.spec is the presence of this hardlink
self.assertTrue(os.path.exists(self.hname))
with h5py.File(self.hname) as h5_file:
source = h5_file["/S1/UXML/ad_detector/beam_center_x"]
link = h5_file["/S1/UXML/beam_center_x"]
target = source.attrs.get("target")
self.assertNotEqual(source.name, link.name)
self.assertNotEqual(target, None)
self.assertEqual(target, source.name)
self.assertEqual(target, link.attrs.get("target"))
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)
from mpl_toolkits.mplot3d import Axes3D, axes3d
import numpy as np
import matplotlib.pyplot as plt
from spec2nexus.spec import SpecDataFile
from PyQt5.QtWidgets import *
import pylab as plab
from matplotlib.backends.backend_qt5 import NavigationToolbar2QT as NavigationToolbar
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
# Loading the data.
data = np.loadtxt("C:\\Users\\escal\\Downloads\\PVvalue.259")
# Loading Spec information for scan#: 259
# ========================================
specFile = SpecDataFile("C:\\Users\\escal\\Downloads\\pmnpt_1.spec")
l = specFile.scans["259"].data["L"]
########################################################################################################################
# Plotting the data in 3D
########################################################################################################################
fig1 = plt.figure()
ax = Axes3D(fig1)
ax.set_ylabel("Data")
ax.set_xlabel("Points")
ax.set_zlabel("L")
x = range(0, 64) # This will have to be replaced by voltage
for i in range(0, 3721):
z = np.full(64, l[i])
y = data[i]
ax.plot(x, y, zs=z)
def openFile(self, filename):
'''open the SPEC file and get its data'''
from spec2nexus.spec import SpecDataFile
if os.path.exists(filename):
self.SPECfile = SpecDataFile(filename)
def openFile(self):
fileName = qtWidgets.QFileDialog.getOpenFileName(
None, "Open Spec File")[0]
self.specFile = SpecDataFile(fileName)
self.setWindowTitle(APP_NAME + " - " + str(fileName))
self.scanBrowser.loadScans(self.specFile.scans)
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 loadSpecFile(self, fileName):
self.specFileName = fileName
self.specFile = SpecDataFile(fileName)
self.specOpen = True
