class DetectorTest(unittest.TestCase):
def setUp(self):
self.d = DetectorData(
shape = (10,10),
pixelsteps_per_buffer = 1,
buffers_per_file = 1,
dirpaths = NETCDF_DIR,
filepattern = NETCDF_PATTERN,
mca_bins = 2048,
first_file_n = 1,
)
def get_spectrum_first_test(self):
pixel_step, row, col = (0, 0, 0)
spectrum = self.d.spectrum(pixel_step, row, col)
self.assertEqual(len(spectrum), 2048)
self.assertEqual(spectrum.sum(), 5445)
def get_spectrum_last_test(self):
pixel_step, row, col = (538, 9, 9)
spectrum = self.d.spectrum(pixel_step, row, col)
self.assertEqual(len(spectrum), 2048)
self.assertEqual(spectrum.sum(), 155276)
def get_statistic_first_test(self):
pixel_step, row, col = (0, 0, 0)
stat = self.d.statistic(pixel_step, row, col, 'realtime')
self.assertEqual(stat, 3125023)
class DetectorTest(unittest.TestCase):
def setUp(self):
self.d = DetectorData(
shape=(10, 10),
pixelsteps_per_buffer=1,
buffers_per_file=1,
dirpaths=NETCDF_DIR,
filepattern=NETCDF_PATTERN,
mca_bins=2048,
first_file_n=1,
)
def get_spectrum_first_test(self):
pixel_step, row, col = (0, 0, 0)
spectrum = self.d.spectrum(pixel_step, row, col)
self.assertEqual(len(spectrum), 2048)
self.assertEqual(spectrum.sum(), 5445)
def get_spectrum_last_test(self):
pixel_step, row, col = (538, 9, 9)
spectrum = self.d.spectrum(pixel_step, row, col)
self.assertEqual(len(spectrum), 2048)
self.assertEqual(spectrum.sum(), 155276)
def get_statistic_first_test(self):
pixel_step, row, col = (0, 0, 0)
stat = self.d.statistic(pixel_step, row, col, 'realtime')
self.assertEqual(stat, 3125023)
def setUp(self):
self.d = DetectorData(
shape=(10, 10),
pixelsteps_per_buffer=1,
buffers_per_file=1,
dirpaths=NETCDF_DIR,
filepattern=NETCDF_PATTERN,
mca_bins=2048,
first_file_n=1,
)
def setUp(self):
self.d = DetectorData(
shape = (10,10),
pixelsteps_per_buffer = 1,
buffers_per_file = 1,
dirpaths = NETCDF_DIR,
filepattern = NETCDF_PATTERN,
mca_bins = 2048,
first_file_n = 1,
)
class DetectorTest(unittest.TestCase):
def setUp(self):
self.d = DetectorData(
shape = (10,10),
pixelsteps_per_buffer = 1,
buffers_per_file = 1,
dirpaths = NETCDF_DIR,
filepattern = NETCDF_PATTERN,
mca_bins = 2048,
first_file_n = 1,
)
def get_all_file_groups_test(self):
fg_dict = self.d._get_all_file_groups()
self.assertTrue(not fg_dict[0]) # 0: entry doesn't exist
self.assertEqual(len(fg_dict[1]), 2) # 1: group has two paths
def get_all_file_groups_len_test(self):
fg_dict = self.d._get_all_file_groups()
self.assertEqual(len(fg_dict), 539) # 539 netCDF pairs
def get_step0_file_paths_test(self):
paths = self.d._get_file_paths_for_pixel_step(pixel_step=0)
self.assertEqual(len(paths), 2)
paths = self.d._get_file_paths_for_pixel_step(pixel_step=538)
self.assertEqual(len(paths), 2)
paths = self.d._get_file_paths_for_pixel_step(pixel_step=539)
self.assertEqual(len(paths), 0)
def get_file_paths_for_all_pixel_steps_test(self):
fg_dict = self.d._get_file_paths_for_all_pixel_steps()
self.assertEqual(len(fg_dict), 539)
self.assertEqual(len(fg_dict[1]), 2)
def build_reverse_file_lookup_test(self):
fg_dict = self.d._get_file_paths_for_all_pixel_steps()
d = self.d._build_reverse_file_lookup(fg_dict)
self.assertEqual(d['ioc53_1.nc'], [0])
self.assertEqual(d['ioc54_1.nc'], [0])
self.assertEqual(d['ioc53_539.nc'], [538])
self.assertEqual(d['ioc54_539.nc'], [538])
def reverse_file_lookup_test(self):
files = self.d._get_file_paths_for_all_pixel_steps()
reverse_dict = self.d._build_reverse_file_lookup(files)
self.assertEqual(len(reverse_dict), 539*2)
self.assertEqual(reverse_dict['ioc53_1.nc'][0], 0)
self.assertEqual(reverse_dict['ioc54_1.nc'][0], 0)
self.assertEqual(reverse_dict['ioc53_539.nc'][0], 538)
def get_data_location_test(self):
tests = [
[(0, 0, 0), (0, 0, 0)],
[(0, 5, 1), (0, 12, 3)],
[(0, 5, 2), (0, 0, 0)],
[(0, 9, 9), (0, 11, 3)],
]
for input, output in tests:
pixel_step, row, col = input
path, buffer_ix, module_ix, channel = self.d._get_data_location(pixel_step, row, col)
self.assertTrue(isinstance(path, basestring))
self.assertEqual((buffer_ix, module_ix, channel), output)
def enumerate_all_data_indices_in_file_test(self):
tests = [
# filename, no. of elements in file,
# first and last (pixel_step, row, col, channel, buffer_ix, module_ix)
['ioc53_1.nc', 52, ( 0, 0, 0, 0, 0, 0), ( 0, 5, 1, 3, 0, 12)],
['ioc54_1.nc', 48, ( 0, 5, 2, 0, 0, 0), ( 0, 9, 9, 3, 0, 11)],
['ioc53_539.nc', 52, (538, 0, 0, 0, 0, 0), (538, 5, 1, 3, 0, 12)],
]
for filename, el, first, last in tests:
d = self.d._enumerate_all_data_indices_in_file(filename)
self.assertEqual(len(d), el)
self.assertEqual(d[0], first)
self.assertEqual(d[-1], last)
def getData(fname):
"""Extract data from mda-ASCII file and distribute into Pixel objects
Returns: XAS scan data in a detector 'object' (variable "det")
energy axis, transmission data array and detector filled with fluo data
(detector object simply full of '0' values if no fluorescence data available)
Transmission data in "trans" comprises encoder_E, I0/1/2, sample_time, encoder_angle
!! I0/1/2 are already normalised to t !!
"""
# get the path to the netCDF files from the mda file
mda = readMDA.readMDA(fname, verbose=False)
netcdf_basename = os.path.splitext(os.path.basename(fname))[0]
netcdf_directory = os.path.join(os.path.dirname(os.path.abspath(fname)),
netcdf_basename)
netcdf_filepattern = '{}_([0-9]*)\.nc'.format(netcdf_basename)
scanData = mda[1]
scanSize = scanData.npts
# create and set the reader for the fluorescence detector
detector_data = DetectorData(shape=(6, 6),
pixelsteps_per_buffer=1,
buffers_per_file=1,
dirpaths=netcdf_directory,
filepattern=netcdf_filepattern,
mca_bins=2048,
first_file_n=1)
detector = Detector(detector_data)
# set scanSize according to the netCDF data that was available
scanSize = highest_available_scandata(detector, scanSize)
detector.steprange = range(scanSize)
# read transmission data
# The PVs listed in pvColumnNames all refer to columnar data such as axis values.
# This is contrasted by thoselisted in pvSingleValues, which are all single values.
pvColumnNames = [
'EncEnergy:ActPos', 'scaler1:S2C', 'scaler1:S3C', 'scaler1:S4C',
'scaler1.T', 'EncAngle:ActPos'
]
trans = np.empty((len(pvColumnNames), scanSize))
for series in scanData.d:
try:
tag = ':'.join(
series.name.split(':')[1:]) # use the PV part after the IOC id
if tag in pvColumnNames:
trans[pvColumnNames.index(tag)] = series.data[:scanSize]
except Exception as e:
print e
print 'missing PV ' + tag
ts = trans[pvColumnNames.index('scaler1.T')] # get the sample time
detector.set_ts(ts)
e = trans[pvColumnNames.index(
'EncEnergy:ActPos')] * 1000.0 # Energy axis (in eV !!)
# normalise I0, I1, I2 to sample_time ts (use string "scaler1:" as identifier)
for i, name in enumerate(pvColumnNames):
if name.startswith('scaler1:'):
trans[i] = trans[i] / ts
## call dead time correction later; should be performed only on
## good spectra ("goodPixels") as bad spectra can contain zeros which
## this function would divide by
## call is via function: detDeadCorr(det, goodPixels)
return e, trans, detector
