def add(self, space, source, value, unit, upd_date, bottom=None, top=None):
if self.databaseAvailable:
try:
if is_Q(value):
value, unit = value.m, "{:~}".format(value.units)
if is_Q(bottom):
bottom = bottom.m_as(unit)
if is_Q(top):
top = top.m_as(unit)
if space is not None and source is not None:
paramObj = self.getSource(space, source)
if is_Q(value):
value, unit = value.m, "{:~}".format(value.units)
elem = ValueHistoryEntry(paramObj, value, unit, upd_date)
self.session.add(elem)
elem.value = value
if bottom is not None:
elem.bottom = bottom
if top is not None:
elem.top = top
self.commit()
except (InvalidRequestError, IntegrityError) as e:
self.session.rollback()
self.session = self.Session()
self.refreshSourceDict()
logging.getLogger(__name__).error(str(e))
def add(self, space, source, value, unit, upd_date, bottom=None, top=None):
if self.databaseAvailable:
try:
if is_Q(value):
value, unit = value.m, "{:~}".format(value.units)
if is_Q(bottom):
bottom = bottom.m_as(unit)
if is_Q(top):
top = top.m_as(unit)
if space is not None and source is not None:
paramObj = self.getSource(space, source)
if is_Q(value):
value, unit = value.m, "{:~}".format(value.units)
elem = ValueHistoryEntry(paramObj, value, unit, upd_date)
self.session.add(elem)
elem.value = value
if bottom is not None:
elem.bottom = bottom
if top is not None:
elem.top = top
self.commit()
except (InvalidRequestError, IntegrityError) as e:
self.session.rollback()
self.session = self.Session()
self.refreshSourceDict()
logging.getLogger(__name__).error(str(e))
def addPoint(self, traceui, plot, data, source):
takentime, value, minval, maxval = data
if is_Q(value):
value, unit = value.m, "{:~}".format(value.units)
if is_Q(minval):
minval = minval.m, "{:~}".format(minval.units)
if is_Q(maxval):
maxval = maxval.m, "{:~}".format(maxval.units)
if not isinstance(value, str): #ignore erroneous values like 'oor'
if self.trace is None:
self.trace = TraceCollection(record_timestamps=True)
self.trace.name = source
self.trace.x = numpy.array([takentime])
self.trace.y = numpy.array([value])
if maxval is not None:
self.trace.top = numpy.array([maxval - value])
if minval is not None:
self.trace.bottom = numpy.array([value - minval])
self.plottedTrace = PlottedTrace(self.trace,
plot,
pens.penList,
xAxisUnit="s",
xAxisLabel="time",
windowName=self.plotName)
# self.plottedTrace.trace.filenameCallback = functools.partial( WeakMethod.ref(self.plottedTrace.traceFilename), self.filename )
traceui.addTrace(self.plottedTrace, pen=-1)
traceui.resizeColumnsToContents()
else:
if self.maximumPoints == 0 or len(
self.trace.x) < self.maximumPoints:
self.trace.x = numpy.append(self.trace.x, takentime)
self.trace.y = numpy.append(self.trace.y, value)
if maxval is not None:
self.trace.top = numpy.append(self.trace.top,
maxval - value)
if minval is not None:
self.trace.bottom = numpy.append(
self.trace.bottom, value - minval)
else:
maxPoints = int(self.maximumPoints)
self.trace.x = numpy.append(self.trace.x[-maxPoints:],
takentime)
self.trace.y = numpy.append(self.trace.y[-maxPoints:],
value)
if maxval is not None:
self.trace.top = numpy.append(
self.trace.top[-maxPoints:], maxval - value)
if minval is not None:
self.trace.bottom = numpy.append(
self.trace.bottom[-maxPoints:], value - minval)
self.plottedTrace.replot()
def persistCallback(self, source, data):
time, value, minval, maxval = data
if is_Q(value):
value, unit = value.m, "{:~}".format(value)
else:
value, unit = value, None
self.persistence.persist(self.persistSpace, source, time, value, minval, maxval, unit)
def onStartScan(self, globalOverrides=list()):
"""Start the scan
globalOverrrides is list of (name, magnitude) values or list of (name, (value, unit)) values
that will override global variables during the scan
"""
logger = logging.getLogger(__name__)
with QtCore.QMutexLocker(self.script.mutex):
self.script.scanIsRunning = True
self.script.analysisReady = False
self.script.dataReady = False
self.script.allDataReady = False
# make sure we hand on a list of (key, magnitude) pairs
myGlobalOverrides = list()
for key, value in globalOverrides:
if not is_Q(value):
if isinstance(value, collections.Sized):
value = Q(value[0], value[1])
else:
value = Q(value)
myGlobalOverrides.append((key, value))
self.experimentUi.onStart(globalOverrides=myGlobalOverrides)
scan = self.scanControlWidget.settingsName
evaluation = self.evaluationControlWidget.settingsName
analysis = self.analysisControlWidget.currentAnalysisName
message = "Scan started at {0} with scan = {1}, evaluation = {2}, analysis = {3}".format(str(datetime.now()), scan, evaluation, analysis)
logger.info(message)
self.writeToConsole(message, color='green')
return (False, None)
def persistCallback(self, source, data):
time, value, minval, maxval = data
unit = None
if is_Q(value):
value, unit = value.m, "{:~}".format(value.unit)
self.persistence.persist(self.persistSpace, source, time, value,
minval, maxval, unit)
def onStartScan(self, globalOverrides=list()):
"""Start the scan
globalOverrrides is list of (name, magnitude) values or list of (name, (value, unit)) values
that will override global variables during the scan
"""
logger = logging.getLogger(__name__)
with QtCore.QMutexLocker(self.script.mutex):
self.script.scanIsRunning = True
self.script.analysisReady = False
self.script.dataReady = False
self.script.allDataReady = False
# make sure we hand on a list of (key, magnitude) pairs
myGlobalOverrides = list()
for key, value in globalOverrides:
if not is_Q(value):
if isinstance(value, collections.Sized):
value = Q(value[0], value[1])
else:
value = Q(value)
myGlobalOverrides.append((key, value))
self.experimentUi.onStart(globalOverrides=myGlobalOverrides)
scan = self.scanControlWidget.settingsName
evaluation = self.evaluationControlWidget.settingsName
analysis = self.analysisControlWidget.currentAnalysisName
message = "Scan started at {0} with scan = {1}, evaluation = {2}, analysis = {3}".format(
str(datetime.now()), scan, evaluation, analysis)
logger.info(message)
self.writeToConsole(message, color='green')
return (False, None)
def value(self, v):
self._value = v
if v is None:
self.setText("None")
elif is_Q(v):
self.setText(self.formatStrQ.format(v))
else:
self.setText(self.formatStr.format(v))
def value(self, v):
self._value = v
if v is None:
self.setText("None")
elif is_Q(v):
self.setText(self.formatStrQ.format(v))
else:
self.setText(self.formatStr.format(v))
def update(self, pushlist, upd_time=None):
upd_time = time.time() if upd_time is None else upd_time
for _, variable, value in pushlist:
if is_Q(value):
value, unit = value.m, "{:~}".format(value.units)
else:
unit = None
self.persist.persist(self.space, variable, upd_time, value, unit)
def value(self, magValue ):
if self.unit is None:
if is_Q(magValue):
self._value, self.unit = magValue.m, "{:~}".format(magValue.units)
else:
self._value = magValue
else:
self._value = magValue.m_as(self.unit)
def xValue(self, index, data):
value = self.scan.list[index]
if self.scan.xExpression:
value = self.expression.evaluate( self.scan.xExpression, {"x": value} )
if not is_Q(value):
return value
if (not self.scan.xUnit and not value.dimensionless) or not value.dimensionality == Q(1, self.scan.xUnit).dimensionality:
self.scan.xUnit = str(value.to_compact().units)
return value.m_as(self.scan.xUnit)
def top(self, magValue ):
if magValue is None:
self._bottom = None
elif self.unit is None:
if is_Q(magValue):
self._top, self.unit = magValue.m, "{:~}".format(magValue.units)
else:
self._top = magValue
else:
self._top = magValue.m_as(self.unit)
def encode(self, v):
if is_Q(v) and v.dimensionless:
v = v.m # TODO: do we want to warn here?
else:
v = value(v, self.unit)
if self.minvalue <= v < self.maxvalue:
v += self.offsetValue
return int(round(v / self.step)) & self.mask
else:
raise EncodingError("Value {0} out of range {1}, {2}".format(v, Q(self.minvalue, self.unit), Q(self.maxvalue, self.unit)))
def encode(self, v):
if is_Q(v) and v.dimensionless:
v = v.m # TODO: do we want to warn here?
else:
v = value(v, self.unit)
if self.minvalue <= v < self.maxvalue:
v += self.offsetValue
return int(round(v / self.step)) & self.mask
else:
raise EncodingError("Value {0} out of range {1}, {2}".format(
v, Q(self.minvalue, self.unit), Q(self.maxvalue, self.unit)))
def xValue(self, index, data):
value = self.scan.list[index]
if self.scan.xExpression:
value = self.expression.evaluate(self.scan.xExpression,
{"x": value})
if not is_Q(value):
return value
if (not self.scan.xUnit
and not value.dimensionless) or not value.dimensionality == Q(
1, self.scan.xUnit).dimensionality:
self.scan.xUnit = value.to_compact()
return value.m_as(self.scan.xUnit)
def addPoint(self, traceui, plot, data, source ):
takentime, value, minval, maxval = data
if is_Q(value):
value, unit = value.m, "{:~}".format(value.units)
if is_Q(minval):
minval = minval.m, "{:~}".format(minval.units)
if is_Q(maxval):
maxval = maxval.m, "{:~}".format(maxval.units)
if not isinstance(value, str): #ignore erroneous values like 'oor'
if self.trace is None:
self.trace = TraceCollection(record_timestamps=True)
self.trace.name = source
self.trace.x = numpy.array( [takentime] )
self.trace.y = numpy.array( [value] )
if maxval is not None:
self.trace.top = numpy.array( [maxval - value])
if minval is not None:
self.trace.bottom = numpy.array( [value - minval])
self.plottedTrace = PlottedTrace(self.trace, plot, pens.penList, xAxisUnit = "s", xAxisLabel = "time", windowName=self.plotName)
# self.plottedTrace.trace.filenameCallback = functools.partial( WeakMethod.ref(self.plottedTrace.traceFilename), self.filename )
traceui.addTrace( self.plottedTrace, pen=-1)
traceui.resizeColumnsToContents()
else:
if self.maximumPoints==0 or len(self.trace.x)<self.maximumPoints:
self.trace.x = numpy.append( self.trace.x, takentime )
self.trace.y = numpy.append( self.trace.y, value )
if maxval is not None:
self.trace.top = numpy.append( self.trace.top, maxval - value )
if minval is not None:
self.trace.bottom = numpy.append( self.trace.bottom, value - minval )
else:
maxPoints = int(self.maximumPoints)
self.trace.x = numpy.append( self.trace.x[-maxPoints:], takentime )
self.trace.y = numpy.append( self.trace.y[-maxPoints:], value )
if maxval is not None:
self.trace.top = numpy.append( self.trace.top[-maxPoints:], maxval - value )
if minval is not None:
self.trace.bottom = numpy.append( self.trace.bottom[-maxPoints:], value - minval )
self.plottedTrace.replot()
def encode(self, v):
if not is_Q(v):
v = v + self.offsetValue
elif not v.dimensionless:
v = v.m + self.offsetValue
else:
v = value(v, self.unit) + self.offsetValue
if type(v) != int:
v = int(round(v))
if self.minvalue <= v <= self.maxvalue:
return v & self.mask
else:
raise EncodingError("Value {0} out of range {1}, {2}".format(v, Q(self.minvalue, self.unit), Q(self.maxvalue, self.unit)))
def encode(self, v):
if not is_Q(v):
v = v + self.offsetValue
elif not v.dimensionless:
v = v.m + self.offsetValue
else:
v = value(v, self.unit) + self.offsetValue
if type(v) != int:
v = int(round(v))
if self.minvalue <= v <= self.maxvalue:
return v & self.mask
else:
raise EncodingError("Value {0} out of range {1}, {2}".format(
v, Q(self.minvalue, self.unit), Q(self.maxvalue, self.unit)))
def onValueChanged(self, record, name, value, string, origin):
if origin == 'recalculate':
self.tableModel.valueRecalcualted(record)
if is_Q(record.gain._value):
if not callable(record.gain._value.m):
record.gain._value = float(record.gain._value)
else:
record.gain._value = record.gain._value.m
else:
if not callable(record.gain._value):
record.gain._value = float(record.gain._value)
else:
record.gain._value = record.gain._value
self.updateOutput.emit(self.localAdjustList, 0)
def onValueChanged(self, record, name, value, string, origin):
if origin=='recalculate':
self.tableModel.valueRecalcualted(record)
if is_Q(record.gain._value):
if not callable(record.gain._value.m):
record.gain._value = float(record.gain._value)
else:
record.gain._value = record.gain._value.m
else:
if not callable(record.gain._value):
record.gain._value = float(record.gain._value)
else:
record.gain._value = record.gain._value
self.updateOutput.emit(self.localAdjustList, 0)
def _updateGainValue(self):
try:
if is_Q(self.gain._value):
if not callable(self.gain._value.m):
self.gainValue = float(self.gain._value)
else:
self.gainValue = float(self.gain._value.m())
else:
if not callable(self.gain._value):
self.gainValue = float(self.gain._value)
else:
self.gainValue = float(self.gain._value())
except:
self.gainValue = 0
def _updateGainValue(self):
try:
if is_Q(self.gain._value):
if not callable(self.gain._value.m):
self.gainValue = float(self.gain._value)
else:
self.gainValue = float(self.gain._value.m())
else:
if not callable(self.gain._value):
self.gainValue = float(self.gain._value)
else:
self.gainValue = float(self.gain._value())
except:
self.gainValue = 0
def value(self, newvalue):
"""set the value and record the change"""
if isinstance(newvalue, tuple):
v, o = newvalue
else:
v, o = newvalue, None
if self._value != v or not (type(self._value) is type(v)) or (
is_Q(v) and (type(self._value.m) is type(v.m))):
self._value = v
self.valueChanged.emit(self.name, v, o)
self.history.appendleft((v, time.time(), o))
if o is not None:
self.persistCallback((time.time(), v, None, None))
else:
self.decimation.decimate(time.time(), v, self.persistCallback)
def convertParameter(self, mag, encoding=None ):
""" convert a dimensioned parameter to the binary value
expected by the hardware. The conversion is determined by the variable encoding
"""
if is_Q(mag):
if mag.dimensionality == Dimensions.time:
result = int(round(mag / self.timestep))
else:
step, unit, _, mask = encodings[encoding]
result = int(round(mag.m_as(unit) / step)) & mask
else:
if encoding:
step, unit, _, mask = encodings[encoding]
result = int(round(mag/step)) & mask
else:
result = mag
return result
def convertParameter(self, mag, encoding=None):
""" convert a dimensioned parameter to the binary value
expected by the hardware. The conversion is determined by the variable encoding
"""
if is_Q(mag):
if mag.dimensionality == Dimensions.time:
result = int(round(mag / self.timestep))
else:
step, unit, _, mask = encodings[encoding]
result = int(round(mag.m_as(unit) / step)) & mask
else:
if encoding:
step, unit, _, mask = encodings[encoding]
result = int(round(mag / step)) & mask
else:
result = mag
return result
def onData(self, data):
self.tick += 1
self.displayUi.values = data.data[0:4]
self.displayUi2.values = data.data[4:8]
self.displayUiADC.values = self.convertAnalog(data.analog())
data.analogValues = self.displayUiADC.values
# if data.data[16] is not None and data.data[16] in self.integrationTimeLookup:
# self.dataIntegrationTime = self.integrationTimeLookup[ data.data[16] ]
# else:
self.dataIntegrationTime = self.settings.integrationTime
data.integrationTime = self.dataIntegrationTime
self.plotDisplayData = self.settingsUi.settings.plotDisplayData
msIntegrationTime = self.dataIntegrationTime.m_as('ms')
for index, value in enumerate(data.data[:16]):
if value is not None:
y = self.settings.displayUnit.convert(value, msIntegrationTime)
self.yData[index] = rollingUpdate(self.yData[index], y, self.settings.pointsToKeep)
self.xData[index] = rollingUpdate(self.xData[index], data.timestamp, self.settings.pointsToKeep)
for index, value in enumerate(data.analogValues):
if value is not None:
myindex = 16 + index
refValue = self.refValue[myindex]
if is_Q(value):
if refValue is not None and refValue.dimensionality == value.dimensionality:
y = value.m_as(refValue)
else:
self.refValue[myindex] = value
y = value.m
else:
y = value
self.yData[myindex] = rollingUpdate(self.yData[myindex], y, self.settings.pointsToKeep)
self.xData[myindex] = rollingUpdate(self.xData[myindex], data.timestamp, self.settings.pointsToKeep)
for name, plotwin in self.curvesDict.items():
if plotwin:
with BlockAutoRange(next(iter(plotwin.values()))):
for index, plotdata in plotwin.items():
plotdata.setData(self.xData[index], self.yData[index])
self.statusDisplay.setData(data)
self.dataAvailable.emit(data)
# logging.getLogger(__name__).info("Max bytes read {0}".format(data.maxBytesRead))
self.statusDisplay.setData(data)
self.dataAvailable.emit(data)
def values(self, values):
if self.settings.average:
for stat, value in zip(self.stat, values):
stat.add(value)
for index, label in enumerate([self.label0, self.label1, self.label2, self.label3]):
if self.stat[index].count == 0:
self._values[index] = None
label.setText("None")
else:
if is_Q(self.stat[index].mean):
self._values[index] = self.stat[index].mean
label.value = self._values[index].m # TODO: needs fixing
else:
self._values[index] = self.stat[index].mean
label.precision = int(math.ceil(-math.log10(self.stat[index].stddev))) if self.stat[index].stddev else 0
label.value = self._values[index]
self.numPointsLabel.setText("{0} points".format(self.stat[0].count))
else:
for value, label in zip(values, self.labelWidgets):
label.value = value
self._values = values
def dimension(self, dim):
if is_Q(dim) or dim is None:
self._dimension = dim
else:
self._dimension = Q(0, dim)
def setCounter(self, index, value):
self.evalList[index.row()].counter = int(value) if is_Q(
value) else self.counterIndex.get(str(value), 0)
self.dataChanged.emit(index, index)
return True
def retfun(x):
if (not is_Q(x)) or x.dimensionless:
return fun(x)
else:
raise ValueError("Must be dimensionless!")
def retfun(x):
if (not is_Q(x)) or x.dimensionless:
return fun(x)
else:
raise ValueError("Must be dimensionless!")
