def get_position_from_events(events, mdh):
from PYME.Analysis import piecewiseMapping
x0 = mdh.getOrDefault('Positioning.x', 0)
y0 = mdh.getOrDefault('Positioning.y', 0)
xm = piecewiseMapping.GeneratePMFromEventList(events, mdh, mdh['StartTime'], x0, b'ScannerXPos', 0)
ym = piecewiseMapping.GeneratePMFromEventList(events, mdh, mdh['StartTime'], y0, b'ScannerYPos', 0)
return xm, ym
def _processEvents(self):
'''Read data from events table and translate it into variables for,
e.g. z position'''
if not self.events == None:
evKeyNames = set()
for e in self.events:
evKeyNames.add(e['EventName'])
self.eventCharts = []
if 'ProtocolFocus' in evKeyNames:
self.zm = piecewiseMapping.GeneratePMFromEventList(
self.events, self.mdh, self.mdh.getEntry('StartTime'),
self.mdh.getEntry('Protocol.PiezoStartPos'))
self.z_focus = 1.e3 * self.zm(self.selectedDataSource['t'])
self.selectedDataSource.z_focus = self.z_focus
self.selectedDataSource.setMapping('focus', 'z_focus')
self.eventCharts.append(
('Focus [um]', self.zm, 'ProtocolFocus'))
if 'ScannerXPos' in evKeyNames:
x0 = 0
if 'Positioning.Stage_X' in self.mdh.getEntryNames():
x0 = self.mdh.getEntry('Positioning.Stage_X')
self.xm = piecewiseMapping.GeneratePMFromEventList(
self.elv.eventSource, self.mdh,
self.mdh.getEntry('StartTime'), x0, 'ScannerXPos', 0)
self.selectedDataSource.scan_x = 1.e3 * self.xm(
self.selectedDataSource['t'] - .01)
self.selectedDataSource.setMapping('ScannerX', 'scan_x')
self.selectedDataSource.setMapping('x', 'x + scan_x')
self.eventCharts.append(('XPos [um]', self.xm, 'ScannerXPos'))
if 'ScannerYPos' in evKeyNames:
y0 = 0
if 'Positioning.Stage_Y' in self.mdh.getEntryNames():
y0 = self.mdh.getEntry('Positioning.Stage_Y')
self.ym = piecewiseMapping.GeneratePMFromEventList(
self.elv.eventSource, self.mdh,
self.mdh.getEntry('StartTime'), y0, 'ScannerYPos', 0)
self.selectedDataSource.scan_y = 1.e3 * self.ym(
self.selectedDataSource['t'] - .01)
self.selectedDataSource.setMapping('ScannerY', 'scan_y')
self.selectedDataSource.setMapping('y', 'y + scan_y')
self.eventCharts.append(('YPos [um]', self.ym, 'ScannerYPos'))
if 'ScannerXPos' in evKeyNames or 'ScannerYPos' in evKeyNames:
self.imageBounds = ImageBounds.estimateFromSource(
self.selectedDataSource)
def Plug(dsviewer):
image = dsviewer.image
if 'events' in dir(image) and len(image.events) > 0:
st = min(image.events['Time'].min() - image.mdh['StartTime'], 0)
stt = image.mdh.getEntry('StartTime')
if 'EndTime' in image.mdh.getEntryNames():
et = image.mdh.getEntry('EndTime')
else:
et = piecewiseMapping.frames_to_times(image.data.getNumSlices(),
image.events, image.mdh)
dsviewer.elv = eventLogViewer.eventLogTPanel(dsviewer,
image.events,
image.mdh, [st, et - stt],
activate=True)
dsviewer.AddPage(dsviewer.elv, False, 'Events')
charts = []
if b'ProtocolFocus' in dsviewer.elv.evKeyNames:
dsviewer.zm = piecewiseMapping.GeneratePMFromEventList(
dsviewer.elv.eventSource, image.mdh,
image.mdh.getEntry('StartTime'),
image.mdh.getEntry('Protocol.PiezoStartPos'))
charts.append(('Focus [um]', dsviewer.zm, b'ProtocolFocus'))
if b'ScannerXPos' in dsviewer.elv.evKeyNames:
x0 = 0
if 'Positioning.Stage_X' in image.mdh.getEntryNames():
x0 = image.mdh.getEntry('Positioning.Stage_X')
dsviewer.xm = piecewiseMapping.GeneratePMFromEventList(
dsviewer.elv.eventSource, image.mdh,
image.mdh.getEntry('StartTime'), x0, b'ScannerXPos', 0)
charts.append(('XPos [um]', dsviewer.xm, b'ScannerXPos'))
if b'ScannerYPos' in dsviewer.elv.evKeyNames:
y0 = 0
if 'Positioning.Stage_Y' in image.mdh.getEntryNames():
y0 = image.mdh.getEntry('Positioning.Stage_Y')
dsviewer.ym = piecewiseMapping.GeneratePMFromEventList(
dsviewer.elv.eventSource, image.mdh,
image.mdh.getEntry('StartTime'), y0, b'ScannerYPos', 0)
charts.append(('YPos [um]', dsviewer.ym, b'ScannerYPos'))
if b'ScannerZPos' in dsviewer.elv.evKeyNames:
z0 = 0
if 'Positioning.PIFoc' in image.mdh.getEntryNames():
z0 = image.mdh.getEntry('Positioning.PIFoc')
dsviewer.zm = piecewiseMapping.GeneratePMFromEventList(
dsviewer.elv.eventSource, image.mdh,
image.mdh.getEntry('StartTime'), z0, b'ScannerZPos', 0)
charts.append(('ZPos [um]', dsviewer.zm, b'ScannerZPos'))
dsviewer.elv.SetCharts(charts)
dsviewer.updateHooks.append(Update)
def get_position_from_events(events, mdh):
"""Use acquisition events to create a mapping between frame number and
stage position
"""
from PYME.Analysis import piecewiseMapping
x0 = mdh.getOrDefault('Positioning.x', 0)
y0 = mdh.getOrDefault('Positioning.y', 0)
xm = piecewiseMapping.GeneratePMFromEventList(events, mdh,
mdh['StartTime'], x0,
b'ScannerXPos', 0)
ym = piecewiseMapping.GeneratePMFromEventList(events, mdh,
mdh['StartTime'], y0,
b'ScannerYPos', 0)
return xm, ym
def dsRefresh(self):
#zp = self.vp.do.zp #save z -position
self.do.SetDataStack(self.image.dataSource)
#self.vp.do.zp = zp #restore z position
self.elv.SetEventSource(self.image.dataSource.getEvents())
self.elv.SetRange([0, self.image.dataSource.getNumSlices()])
if b'ProtocolFocus' in self.elv.evKeyNames:
self.zm = piecewiseMapping.GeneratePMFromEventList(self.elv.eventSource, self.mdh.getEntry('Camera.CycleTime'), self.mdh.getEntry('StartTime'), self.mdh.getEntry('Protocol.PiezoStartPos'))
self.elv.SetCharts([('Focus [um]', self.zm, b'ProtocolFocus'),])
self.update()
def map_corrected_focus(events, metadata):
"""
ProtocolFocus event descriptions list the intended focus target. Some piezos have a target tolerance and log their
landing position with PiezoOnTarget. PiezoOffsetUpdate events are also accounted for.
Parameters
----------
events: list or structured ndarray
acquisition events
metadata: PYME.IO.MetaDataHandler.MDHandlerBase
metadata with 'Camera.CycleTime' and 'StartTime' entries
Returns
-------
focus_mapping: PYME.Analysis.piecewiseMapping.piecewiseMap
callable function to return focus positions for each input frame number
"""
# FIXME - this is only used below in correct_target_positions - is it needed?
normalized_events = spoof_focus_events_from_ontarget(events, metadata)
return piecewise_mapping.GeneratePMFromEventList(
normalized_events, metadata, metadata['StartTime'],
metadata.getOrDefault('Protocol.PiezoStartPos', 0.))
def _processEvents(ds, events, mdh):
"""Read data from events table and translate it into mappings for,
e.g. z position"""
eventCharts = []
ev_mappings = {}
if not events is None:
evKeyNames = set()
for e in events:
evKeyNames.add(e['EventName'])
if b'ProtocolFocus' in evKeyNames:
zm = piecewiseMapping.GeneratePMFromEventList(
events,
mdh,
mdh['StartTime'],
mdh['Protocol.PiezoStartPos'],
eventName=b'ProtocolFocus')
ev_mappings['z_command'] = zm
if b'PiezoOnTarget' in evKeyNames:
# Sometimes we also emit PiezoOnTarget events with the actual piezo position, rather than where we
# told it to go, use these preferentially
# TODO - deprecate in favour of, e.g. 'FocusOnTarget' events which are offset-corrected - see issue 766
from PYME.Analysis import piezo_movement_correction
spoofed_evts = piezo_movement_correction.spoof_focus_events_from_ontarget(
events, mdh)
zm = piecewiseMapping.GeneratePMFromEventList(
spoofed_evts,
mdh,
mdh['StartTime'],
mdh['Protocol.PiezoStartPos'],
eventName=b'ProtocolFocus')
ev_mappings['z_ontarget'] = zm
ev_mappings[
'piezo_moving'] = piecewiseMapping.bool_map_between_events(
events,
mdh,
b'ProtocolFocus',
b'PiezoOnTarget',
default=False)
# the z position we use for localizations gets the ontarget info if present
ev_mappings['zm'] = zm
eventCharts.append(('Focus [um]', zm, b'ProtocolFocus'))
if b'ScannerXPos' in evKeyNames:
x0 = 0
if 'Positioning.Stage_X' in mdh.getEntryNames():
x0 = mdh.getEntry('Positioning.Stage_X')
xm = piecewiseMapping.GeneratePMFromEventList(
events, mdh, mdh['StartTime'], x0, b'ScannerXPos', 0)
ev_mappings['xm'] = xm
eventCharts.append(('XPos [um]', xm, 'ScannerXPos'))
if b'ScannerYPos' in evKeyNames:
y0 = 0
if 'Positioning.Stage_Y' in mdh.getEntryNames():
y0 = mdh.getEntry('Positioning.Stage_Y')
ym = piecewiseMapping.GeneratePMFromEventList(
events, mdh, mdh.getEntry('StartTime'), y0, b'ScannerYPos', 0)
ev_mappings['ym'] = ym
eventCharts.append(('YPos [um]', ym, 'ScannerYPos'))
if b'ShiftMeasure' in evKeyNames:
driftx = piecewiseMapping.GeneratePMFromEventList(
events, mdh, mdh.getEntry('StartTime'), 0, b'ShiftMeasure', 0)
drifty = piecewiseMapping.GeneratePMFromEventList(
events, mdh, mdh.getEntry('StartTime'), 0, b'ShiftMeasure', 1)
driftz = piecewiseMapping.GeneratePMFromEventList(
events, mdh, mdh.getEntry('StartTime'), 0, b'ShiftMeasure', 2)
ev_mappings['driftx'] = driftx
ev_mappings['drifty'] = drifty
ev_mappings['driftz'] = driftz
eventCharts.append(('X Drift [px]', driftx, 'ShiftMeasure'))
eventCharts.append(('Y Drift [px]', drifty, 'ShiftMeasure'))
eventCharts.append(('Z Drift [px]', driftz, 'ShiftMeasure'))
# self.eventCharts = eventCharts
# self.ev_mappings = ev_mappings
elif all(k in mdh.keys() for k in [
'StackSettings.FramesPerStep', 'StackSettings.StepSize',
'StackSettings.NumSteps', 'StackSettings.NumCycles'
]):
# TODO - Remove this code - anytime we get here it's generally the result of an error in the input data
# This should be handled upstream when spooling
logger.warning(
'Spoofing focus from metadata: this usually implies an error in the input data (missing events) and results might vary'
)
try:
# if we dont have events file, see if we can use metadata to spoof focus
from PYME.experimental import labview_spooling_hacks
position, frames = labview_spooling_hacks.spoof_focus_from_metadata(
mdh)
zm = piecewiseMapping.piecewiseMap(0,
frames,
position,
mdh['Camera.CycleTime'],
xIsSecs=False)
ev_mappings['z_command'] = zm
eventCharts.append(('Focus [um]', zm, b'ProtocolFocus'))
except:
# It doesn't really matter if this fails, print our traceback anyway
logger.exception('Error trying to fudge focus positions')
return ev_mappings, eventCharts
def _processEvents(ds, events, mdh):
"""Read data from events table and translate it into mappings for,
e.g. z position"""
eventCharts = []
ev_mappings = {}
if not events is None:
evKeyNames = set()
for e in events:
evKeyNames.add(e['EventName'])
if b'ProtocolFocus' in evKeyNames:
zm = piecewiseMapping.GeneratePMFromEventList(events, mdh, mdh['StartTime'], mdh['Protocol.PiezoStartPos'])
ev_mappings['zm'] = zm
eventCharts.append(('Focus [um]', zm, b'ProtocolFocus'))
if b'ScannerXPos' in evKeyNames:
x0 = 0
if 'Positioning.Stage_X' in mdh.getEntryNames():
x0 = mdh.getEntry('Positioning.Stage_X')
xm = piecewiseMapping.GeneratePMFromEventList(events, mdh, mdh['StartTime'], x0, b'ScannerXPos', 0)
ev_mappings['xm'] = xm
eventCharts.append(('XPos [um]', xm, 'ScannerXPos'))
if b'ScannerYPos' in evKeyNames:
y0 = 0
if 'Positioning.Stage_Y' in mdh.getEntryNames():
y0 = mdh.getEntry('Positioning.Stage_Y')
ym = piecewiseMapping.GeneratePMFromEventList(events, mdh, mdh.getEntry('StartTime'), y0, b'ScannerYPos', 0)
ev_mappings['ym'] = ym
eventCharts.append(('YPos [um]', ym, 'ScannerYPos'))
if b'ShiftMeasure' in evKeyNames:
driftx = piecewiseMapping.GeneratePMFromEventList(events, mdh, mdh.getEntry('StartTime'), 0, b'ShiftMeasure',
0)
drifty = piecewiseMapping.GeneratePMFromEventList(events, mdh, mdh.getEntry('StartTime'), 0, b'ShiftMeasure',
1)
driftz = piecewiseMapping.GeneratePMFromEventList(events, mdh, mdh.getEntry('StartTime'), 0, b'ShiftMeasure',
2)
ev_mappings['driftx'] = driftx
ev_mappings['drifty'] = drifty
ev_mappings['driftz'] = driftz
eventCharts.append(('X Drift [px]', driftx, 'ShiftMeasure'))
eventCharts.append(('Y Drift [px]', drifty, 'ShiftMeasure'))
eventCharts.append(('Z Drift [px]', driftz, 'ShiftMeasure'))
# self.eventCharts = eventCharts
# self.ev_mappings = ev_mappings
elif all(k in mdh.keys() for k in ['StackSettings.FramesPerStep', 'StackSettings.StepSize',
'StackSettings.NumSteps', 'StackSettings.NumCycles']):
# TODO - Remove this code - anytime we get here it's generally the result of an error in the input data
# This should be handled upstream when spooling
logger.warning('Spoofing focus from metadata: this usually implies an error in the input data (missing events) and results might vary')
try:
# if we dont have events file, see if we can use metadata to spoof focus
from PYME.experimental import labview_spooling_hacks
position, frames = labview_spooling_hacks.spoof_focus_from_metadata(mdh)
zm = piecewiseMapping.piecewiseMap(0, frames, position, mdh['Camera.CycleTime'], xIsSecs=False)
ev_mappings['zm'] = zm
eventCharts.append(('Focus [um]', zm, b'ProtocolFocus'))
except:
# It doesn't really matter if this fails, print our traceback anyway
logger.exception('Error trying to fudge focus positions')
return ev_mappings, eventCharts
def spoof_focus_events_from_ontarget(events, metadata):
"""
Generates a acquisition event array where events from (offset) piezo's with on-target events are spoofed to
look like standard ProtocolFocus events.
Parameters
----------
events: list or structured ndarray
acquisition events
metadata: PYME.IO.MetaDataHandler.MDHandlerBase
metadata with 'Camera.CycleTime' and 'StartTime' entries
Returns
-------
bonus_events: ndarray
events with piezo offsets accounted for and PiezoOnTarget events spoofed as ProtocolFocus events
Notes
-----
The on-target events are fired from standard piezo classes, not the OffsetPiezo subclasses, so the PiezoOnTarget
positions and ProtocolFocus events have an offset between them which we remove in the output normalized events if
there are PiezoOffsetUpdate events available to do so.
"""
ontarget_times, ontarget_positions = [], []
offset_start, first_offset_time = 0, np.finfo(float).max
for event in events:
if event['EventName'] == b'PiezoOnTarget':
ontarget_times.append(float(event['Time']))
ontarget_positions.append(float(event['EventDescr']))
elif event['EventName'] == b'PiezoOffsetUpdate':
if float(event['Time']) < first_offset_time:
first_offset_time = float(event['Time'])
offset_start = float(
event['EventDescr'].decode('ascii').split(', ')[0])
if len(ontarget_times) == 0:
# nothing to do
return events
offset_map = piecewise_mapping.GeneratePMFromEventList(
events,
metadata,
0,
offset_start,
eventName=b'PiezoOffsetUpdate',
dataPos=0)
ontarget_times = np.asarray(ontarget_times)
ontarget_frames = piecewise_mapping.times_to_frames(
ontarget_times, events, metadata).astype(int)
# spoof ProtocolFocus events from PiezoOnTarget events
bonus_events = np.empty(len(events) + len(ontarget_times),
dtype=[('EventName', 'S32'), ('Time', '<f8'),
('EventDescr', 'S256')])
bonus_events[:len(events)][:] = events[:]
bonus_events[len(events):]['EventName'] = b'ProtocolFocus'
bonus_events[len(events):]['Time'] = ontarget_times
bonus_events[len(events):]['EventDescr'] = [
', '.join((str(f), str(p - offset_map(np.asarray([f]))[0])))
for f, p in zip(ontarget_frames, ontarget_positions)
]
return bonus_events
def OpenFile(self, filename):
self.dataSources = []
if 'zm' in dir(self):
del self.zm
self.filter = None
self.mapping = None
self.colourFilter = None
self.filename = filename
self.selectedDataSource = inpFilt.H5RSource(filename)
self.dataSources.append(self.selectedDataSource)
self.mdh = MetaDataHandler.HDFMDHandler(self.selectedDataSource.h5f)
if 'Camera.ROIWidth' in self.mdh.getEntryNames():
x0 = 0
y0 = 0
x1 = self.mdh.getEntry(
'Camera.ROIWidth') * 1e3 * self.mdh.getEntry('voxelsize.x')
y1 = self.mdh.getEntry(
'Camera.ROIHeight') * 1e3 * self.mdh.getEntry('voxelsize.y')
if 'Splitter' in self.mdh.getEntry('Analysis.FitModule'):
y1 = y1 / 2
self.imageBounds = ImageBounds(x0, y0, x1, y1)
else:
self.imageBounds = ImageBounds.estimateFromSource(
self.selectedDataSource)
if 'fitResults_Ag' in self.selectedDataSource.keys():
#if we used the splitter set up a mapping so we can filter on total amplitude and ratio
#if not 'fitError_Ag' in self.selectedDataSource.keys():
if 'fitError_Ag' in self.selectedDataSource.keys():
self.selectedDataSource = inpFilt.MappingFilter(
self.selectedDataSource,
A='fitResults_Ag + fitResults_Ar',
gFrac='fitResults_Ag/(fitResults_Ag + fitResults_Ar)',
error_gFrac=
'sqrt((fitError_Ag/fitResults_Ag)**2 + (fitError_Ag**2 + fitError_Ar**2)/(fitResults_Ag + fitResults_Ar)**2)*fitResults_Ag/(fitResults_Ag + fitResults_Ar)'
)
sg = self.selectedDataSource['fitError_Ag']
sr = self.selectedDataSource['fitError_Ar']
g = self.selectedDataSource['fitResults_Ag']
r = self.selectedDataSource['fitResults_Ar']
I = self.selectedDataSource['A']
self.selectedDataSource.colNorm = np.sqrt(
2 * np.pi) * sg * sr / (2 * np.sqrt(sg**2 + sr**2) * I) * (
scipy.special.erf(
(sg**2 * r + sr**2 * (I - g)) /
(np.sqrt(2) * sg * sr * np.sqrt(sg**2 + sr**2))) -
scipy.special.erf(
(sg**2 * (r - I) - sr**2 * g) /
(np.sqrt(2) * sg * sr * np.sqrt(sg**2 + sr**2))))
self.selectedDataSource.setMapping('ColourNorm', '1.0*colNorm')
else:
self.selectedDataSource = inpFilt.MappingFilter(
self.selectedDataSource,
A='fitResults_Ag + fitResults_Ar',
gFrac='fitResults_Ag/(fitResults_Ag + fitResults_Ar)',
error_gFrac='0*x + 0.01')
self.selectedDataSource.setMapping('fitError_Ag',
'1*sqrt(fitResults_Ag/1)')
self.selectedDataSource.setMapping('fitError_Ar',
'1*sqrt(fitResults_Ar/1)')
sg = self.selectedDataSource['fitError_Ag']
sr = self.selectedDataSource['fitError_Ar']
g = self.selectedDataSource['fitResults_Ag']
r = self.selectedDataSource['fitResults_Ar']
I = self.selectedDataSource['A']
self.selectedDataSource.colNorm = np.sqrt(
2 * np.pi) * sg * sr / (2 * np.sqrt(sg**2 + sr**2) * I) * (
scipy.special.erf(
(sg**2 * r + sr**2 * (I - g)) /
(np.sqrt(2) * sg * sr * np.sqrt(sg**2 + sr**2))) -
scipy.special.erf(
(sg**2 * (r - I) - sr**2 * g) /
(np.sqrt(2) * sg * sr * np.sqrt(sg**2 + sr**2))))
self.selectedDataSource.setMapping('ColourNorm', '1.0*colNorm')
self.dataSources.append(self.selectedDataSource)
elif 'fitResults_sigxl' in self.selectedDataSource.keys():
self.selectedDataSource = inpFilt.MappingFilter(
self.selectedDataSource)
self.dataSources.append(self.selectedDataSource)
self.selectedDataSource.setMapping(
'sig', 'fitResults_sigxl + fitResults_sigyu')
self.selectedDataSource.setMapping(
'sig_d', 'fitResults_sigxl - fitResults_sigyu')
self.selectedDataSource.dsigd_dz = -30.
self.selectedDataSource.setMapping('fitResults_z0',
'dsigd_dz*sig_d')
else:
self.selectedDataSource = inpFilt.MappingFilter(
self.selectedDataSource)
self.dataSources.append(self.selectedDataSource)
if 'Events' in self.selectedDataSource.resultsSource.h5f.root:
self.events = self.selectedDataSource.resultsSource.h5f.root.Events[:]
evKeyNames = set()
for e in self.events:
evKeyNames.add(e['EventName'])
if b'ProtocolFocus' in evKeyNames:
self.zm = piecewiseMapping.GeneratePMFromEventList(
self.events, self.mdh, self.mdh.getEntry('StartTime'),
self.mdh.getEntry('Protocol.PiezoStartPos'))
self.z_focus = 1.e3 * self.zm(self.selectedDataSource['t'])
#self.elv.SetCharts([('Focus [um]', self.zm, 'ProtocolFocus'),])
self.selectedDataSource.z_focus = self.z_focus
self.selectedDataSource.setMapping('focus', 'z_focus')
if 'ScannerXPos' in evKeyNames:
x0 = 0
if 'Positioning.Stage_X' in self.mdh.getEntryNames():
x0 = self.mdh.getEntry('Positioning.Stage_X')
self.xm = piecewiseMapping.GeneratePMFromEventList(
self.elv.eventSource, self.mdh,
self.mdh.getEntry('StartTime'), x0, 'ScannerXPos', 0)
self.selectedDataSource.scan_x = 1.e3 * self.xm(
self.selectedDataSource['t'] - .01)
self.selectedDataSource.setMapping('ScannerX', 'scan_x')
self.selectedDataSource.setMapping('x', 'x + scan_x')
if 'ScannerYPos' in evKeyNames:
y0 = 0
if 'Positioning.Stage_Y' in self.mdh.getEntryNames():
y0 = self.mdh.getEntry('Positioning.Stage_Y')
self.ym = piecewiseMapping.GeneratePMFromEventList(
self.elv.eventSource, self.mdh,
self.mdh.getEntry('StartTime'), y0, 'ScannerYPos', 0)
self.selectedDataSource.scan_y = 1.e3 * self.ym(
self.selectedDataSource['t'] - .01)
self.selectedDataSource.setMapping('ScannerY', 'scan_y')
self.selectedDataSource.setMapping('y', 'y + scan_y')
if 'ScannerXPos' in evKeyNames or 'ScannerYPos' in evKeyNames:
self.imageBounds = ImageBounds.estimateFromSource(
self.selectedDataSource)
if not 'foreShort' in dir(self.selectedDataSource):
self.selectedDataSource.foreShort = 1.
if not 'focus' in self.selectedDataSource.mappings.keys():
self.selectedDataSource.focus = np.zeros(
self.selectedDataSource['x'].shape)
if 'fitResults_z0' in self.selectedDataSource.keys():
self.selectedDataSource.setMapping(
'z', 'fitResults_z0 + foreShort*focus')
else:
self.selectedDataSource.setMapping('z', 'foreShort*focus')
#if we've done a 3d fit
#print self.selectedDataSource.keys()
for k in self.filterKeys.keys():
if not k in self.selectedDataSource.keys():
self.filterKeys.pop(k)
#print self.filterKeys
self.RegenFilter()
if 'Sample.Labelling' in self.mdh.getEntryNames():
self.SpecFromMetadata()
