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!")