def refreshVarDict(self): """refresh the variable dictionary by checking all waveform dependencies""" allDependencies = set() [ channelUi.waveform.updateDependencies() for channelUi in self.awgChannelUiList ] [ allDependencies.update(channelUi.waveform.dependencies) for channelUi in self.awgChannelUiList ] default = lambda varname: { 'value': Q(1, 'us'), 'text': None } if varname.startswith('Duration') else { 'value': Q(0), 'text': None } deletions = [ varname for varname in self.settings.varDict if varname not in allDependencies ] [self.settings.varDict.pop(varname) for varname in deletions ] #remove all values that aren't dependencies anymore [ self.settings.varDict.setdefault(varname, default(varname)) for varname in allDependencies ] #add missing values self.settings.varDict.sort(key=lambda val: -1 if val[0].startswith( 'Duration') else ord(str(val[0])[0])) self.varDictChanged.emit(self.varAsOutputChannelDict) for channelUi in self.awgChannelUiList: channelUi.replot()
def getValue(self, channel): if channel == 'Freq': answer = self.synthesizer.query(":FREQ:CW?") return Q(float(answer), "Hz") elif channel == 'Power_dBm': answer = self.synthesizer.query(":POWER?") return Q(float(answer), "")
def __init__(self, name, value=Q(0), categories=None): super(GlobalVariable, self).__init__() self.decimation = StaticDecimation(Q(10, 's')) self.history = deque(maxlen=10) self._value = value self._name = name self.categories = categories
def testPickle(self): expr = CounterSetting(name='Count 7', minValue=Q(12, 'kHz'), maxValue=Q(123, 'kHz')) pickled = pickle.dumps(expr) unpickled = pickle.loads(pickled) self.assertEqual(expr, unpickled)
def setDefault(self): self.settings.setdefault('SetPoint', Q(0)) self.settings.setdefault('P', Q(0)) self.settings.setdefault('I', Q(0)) self.settings.setdefault('AveragingTime', Q(10, 's')) self.settings.setdefault('GlobalVariable', "") self.settings.setdefault('Reset', False)
def __init__(self): self.samples = Q(2000) self.subsample = Q(0) self.triggerLevel = Q(0, 'V') self.triggerMode = 0 self.frequencyPlot = None self.errorSigPlot = None
def __init__(self): self.zeroCheck = True self.zeroCheck_2 = True self.zeroCheck_3 = True self.voltageEnabled = False self.voltageEnabled_2 = False self.voltageEnabled_3 = False self.voltageRange = 0 self.voltageRange_2 = 0 self.voltageRange_3 = 0 self.currentLimit = 0 self.currentLimit_2 = 0 self.currentLimit_3 = 0 self.voltage = 0 self.voltage_2 = 0 self.voltage_3 = 0 self.autoRange = False self.autoRange_2 = False self.autoRange_3 = False self.instrument = "" self.instrument_2 = "" self.instrument_3 = "" self.start = Q(0, "V") self.stop = Q(10, "V") self.steps = Q(10) self.scanType = 0 self.filename = "IV.txt" self.timeDelta = Q(1, "s") self.settlingDelay = Q(100, 'ms')
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 setDefaults(self): super(SlowAdjustOutputChannel, self).setDefaults() self.settings.__dict__.setdefault('delay', Q( 100, 'ms')) # s delay between subsequent updates self.settings.__dict__.setdefault( 'jump', False) # if True go to the target value in one jump self.settings.__dict__.setdefault('stepsize', Q( 1, self.outputUnit)) # if True go to the target value in one jump
def __init__(self): self.enable = False self.channel = 0 self.min = Q(1, 'GHz') self.max = Q(1, 'GHz') self.current = 0 self.inRange = False self.identicalCount = 0 self.lastReading = 0 # same as current only this one has full precision
def convertMagnitude(self, volt): if volt is None: return None if volt < self.minimum or volt > self.maximum: # return "oor" return Q(-0.001, 'W') dBm = self.p * volt**2 + self.m * volt + self.c value = Q(10**((dBm / 10) - 3), 'W') value.significantDigits = self.digits return value
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 setDefaults(self): self.settings.__dict__.setdefault('value', Q( 0, self.outputUnit)) # the current value self.settings.__dict__.setdefault('persistDelay', Q(60, 's')) # delay for persistency self.settings.__dict__.setdefault( 'strValue', None) # requested value as string (formula) self.settings.__dict__.setdefault('targetValue', Q( 0, self.outputUnit)) # requested value as string (formula) for d in self.device._channelParams.get(self.channelName, tuple()): self.settings.__dict__.setdefault(d['name'], d['value'])
def var_action(self, text, loc, arg): print("var_action", self.currentFile, lineno(loc, text), arg[0:2], arg[2].split(",") if len(arg) > 2 else "") """ add a variable to the self.variablesdict """ logger = logging.getLogger(__name__) logger.debug("{0}:{1} Variable {2}".format(self.currentFile, lineno(loc, text), arg)) var = Variable() label, data = arg[:2] fields = arg[2].split(",") if len(arg) > 2 else [None] * 3 fields += [None] * (3 - len(fields)) var.type, unit, var.encoding = [ x if x is None or '' else x.strip() for x in fields ] var.name = label var.origin = self.currentFile var.enabled = True if var.encoding not in encodings: raise ppexception( "unknown encoding {0} in file '{1}':{2}".format( var.encoding, self.currentFile, lineno(loc, text)), self.currentFile, lineno, var.encoding) try: data = str(eval(data, globals(), self.defines)) except Exception: logger.exception( "Evaluation error in file '{0}' on line: '{1}'".format( self.currentFile, data)) if unit is not None: var.value = Q(float(data), unit) data = self.convertParameter(var.value, var.encoding) else: var.value = Q(float(data)) data = int(round(float(data))) if label in self.defines: logger.error( "Error in file '%s': attempted to reassign '%s' to '%s' (from prev. value of '%s') in a var statement." % (self.currentFile, label, data, self.defines[label])) raise ppexception("variable redifinition", self.currentFile, lineno, label) else: self.defines[ label] = label # add the variable to the dictionary of definitions to prevent identifiers and variables from having the same name # however, we do not want it replaced with a number but keep the name for the last stage of compilation pass var.data = data self.variabledict.update({label: var}) if var.type == "exitcode": self._exitcodes[data & 0x0000ffff] = var
def __init__(self): self.frequency = Q(0, 'MHz') self.phase = Q(0) self.amplitude = Q(0) self.frequencyText = None self.phaseText = None self.amplitudeText = None self.enabled = False self.name = "" self.squareEnabled = False self.shutter = None self.channel = None
def parseDelta(string, deltapos=0, parseAll=True): string, deltapos = positionawareTrim(string, deltapos) val = valueexpr.parseString(string, parseAll=parseAll) precres = precisionexpr.parseString(string) prec = len(precres[2]) if len(precres) == 3 else 0 decimalpos = len(precres[0]) mydeltapos = max( 2 if precres[0][0] == '-' else 1, min(deltapos - (1 if deltapos > decimalpos else 0), decimalpos + prec)) unit = val[1] if len(val) > 1 else '' retval = Q(val.get('value', float(val[0])), unit) delta = decimalpos - mydeltapos return retval, Q(pow(10, delta), unit), deltapos, decimalpos, prec
def setDefaults(self): self.settings.__dict__.setdefault('waitTime', Q(0.1, 's') ) self.settings.__dict__.setdefault('timeout', Q(0.1, 's') ) self.settings.__dict__.setdefault('C1', 0.97142 ) self.settings.__dict__.setdefault('C2', 2.3268 ) self.settings.__dict__.setdefault('C3', 0.80591 ) self.settings.__dict__.setdefault('P', 0.1 ) self.settings.__dict__.setdefault('I', 0.1 ) self.settings.__dict__.setdefault('D', 0.1 ) self.settings.__dict__.setdefault('ILimHigh', 0 ) self.settings.__dict__.setdefault('ILimLow', -0.5 ) self.settings.__dict__.setdefault('Write', False ) self.settings.__dict__.setdefault('Setpoint', 31.65)
def addVariable(self, m, lineno, sourcename): """ add a variable to the self.variablesdict """ logger = logging.getLogger(__name__) logger.debug("Variable {0} {1} {2}".format(m.groups(), lineno, sourcename)) var = Variable() label, data, var.type, unit, var.encoding, var.comment = [ x if x is None else x.strip() for x in m.groups() ] var.name = label var.origin = sourcename var.enabled = True if var.encoding not in encodings: raise ppexception( "unknown encoding {0} in file '{1}':{2}".format( var.encoding, sourcename, lineno), sourcename, lineno, var.encoding) try: data = str(eval(data, globals(), self.defines)) except Exception: logger.exception( "Evaluation error in file '{0}' on line: '{1}'".format( sourcename, data)) if unit is not None: var.value = Q(float(data), unit) data = self.convertParameter(var.value, var.encoding) else: var.value = Q(float(data)) # var.value.output_prec(0) # without dimension the parameter has to be int. Thus, we do not want decimal places :) data = int(round(float(data))) if label in self.defines: logger.error( "Error in file '%s': attempted to reassign '%s' to '%s' (from prev. value of '%s') in a var statement." % (sourcename, label, data, self.defines[label])) raise ppexception("variable redifinition", sourcename, lineno, label) else: self.defines[ label] = label # add the variable to the dictionary of definitions to prevent identifiers and variables from having the same name # however, we do not want it replaced with a number but keep the name for the last stage of compilation pass var.data = data self.variabledict.update({label: var}) if var.type == "exitcode": self._exitcodes[data & 0x0000ffff] = var
def __init__(self): # Evaluation self.histogramBins = 50 self.integrateHistogram = False self.counterChannel = 0 self.evalList = list() # Timestamps self.enableTimestamps = False self.binwidth = Q(1, 'us') self.roiStart = Q(0, 'us') self.roiWidth = Q(1, 'ms') self.integrateTimestamps = 0 self.timestampsChannel = 0 self.saveRawData = False
def __setstate__(self, d): self.__dict__ = d self.__dict__.setdefault('enableLowPass', False) self.__dict__.setdefault('mode', 0) self.__dict__.setdefault('filter', LockControl.FilterOptions.NoFilter) self.__dict__.setdefault('harmonicOutput', LockControl.HarmonicOutputOptions.Off) self.__dict__.setdefault('resonanceFrequency', Q(12642.817, 'MHz')) self.__dict__.setdefault('harmonicReferenceFrequency', Q(0, 'MHz')) self.__dict__.setdefault('dcThreshold', Q(0, 'V')) self.__dict__.setdefault('enableDCThreshold', False) self.__dict__.setdefault('coreMode', 0) self.__dict__.setdefault('errorsigHarmonic', Q(1)) self.mode &= ~1 # clear the lock enable bit
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 __init__(self, globalDict=dict()): self._globalDict = globalDict self._line = ExpressionValue(name="line", globalDict=globalDict, value=Q(0.0)) self._lineValue = self._line.value self._lineGain = ExpressionValue(name="lineGain", globalDict=globalDict, value=Q(1.0)) self._globalGain = ExpressionValue(name="globalGain", globalDict=globalDict, value=Q(1.0)) self._line.valueChanged.connect(self.onLineExpressionChanged) self._lineGain.valueChanged.connect(self.onLineExpressionChanged) self._globalGain.valueChanged.connect(self.onLineExpressionChanged)
def __init__(self, dataQueue=None, commandPipe=None, loggingQueue=None, sharedMemoryArray=None): Process.__init__(self) OKBase.__init__(self) self.dataQueue = dataQueue self.commandPipe = commandPipe self.running = True self.loggingQueue = loggingQueue self.sharedMemoryArray = sharedMemoryArray # PipeReader stuff self.state = self.analyzingState.normal self.data = Data() self.dedicatedData = self.dedicatedDataClass(time_time()) self.timestampOffset = 0 self._shutter = 0 self._trigger = 0 self._counterMask = 0 self._adcMask = 0 self._integrationTime = Q(100, 'ms') self.logicAnalyzerEnabled = False self.logicAnalyzerStopAtEnd = False self.logicAnalyzerData = LogicAnalyzerData() self.logicAnalyzerBuffer = bytearray() self.logicAnalyzerReadStatus = 0 # self._pulserConfiguration = None
def __init__(self, pulser, config, configName, globalDict, parent=None): self.isSetup = False dacBase.__init__(self, parent) dacForm.__init__(self) self.config = config self.dac = DAC(pulser) self.channelsConfigName = '{0}.dacExpressionChannels'.format( configName) self.autoApplyConfigName = '{0}.autoApply'.format(configName) self.guiStateConfigName = '{0}.guiState'.format(configName) self.dacChannels = self.config.get(self.channelsConfigName) if not self.dacChannels or len( self.dacChannels) != self.dac.numChannels: self.dacChannels = [ DACChannelSetting(globalDict=globalDict) for _ in range(self.dac.numChannels) ] for index, channel in enumerate(self.dacChannels): channel.globalDict = globalDict channel.onChange = partial(self.onChange, index) self.autoApply = self.config.get(self.autoApplyConfigName, True) self.decimation = defaultdict(lambda: StaticDecimation(Q(30, 's'))) self.persistence = DBPersist() self.globalDict = globalDict self.pulser = pulser
def __setstate__(self, state): """this function ensures that the given fields are present in the class object after unpickling. Only new class attributes need to be added here. """ self.__dict__ = state self.__dict__.setdefault('counterMask', 0) self.__dict__.setdefault('adcMask', 0) self.__dict__.setdefault('integrationTime', Q(100, 'ms')) self.__dict__.setdefault('displayUnit', CountrateConversion.DisplayUnit()) self.__dict__.setdefault('unit', 0) self.__dict__.setdefault('pointsToKeep', 400) self.__dict__.setdefault( 'counterDict', dict( zip(list(['Count {0}'.format(i) for i in range(16)]), list(i for i in range(16))))) self.__dict__.setdefault( 'adcDict', dict( zip(list(['ADC {0}'.format(i) for i in range(4)]), list(i for i in range(4))))) self.__dict__.setdefault('plotDisplayData', SequenceDict()) self.__dict__.setdefault('name', "DedicatedCounterSettings")
def __init__(self, pulser, config, configName='DDSUi', globalDict=dict(), parent=None): DDSBase.__init__(self, parent) DDSForm.__init__(self) if pulser.pulserConfiguration(): self.channelInfo = sorted(list( pulser.pulserConfiguration().ddsChannels.values()), key=lambda x: x.channel) else: self.channelInfo = [] self.numChannels = len(self.channelInfo) self.config = config self.channelConfigName = '{0}.ddsChannels'.format(configName) self.autoApplyConfigName = '{0}.autoApply'.format(configName) self.guiStateConfigName = '{0}.guiState'.format(configName) self.ad9912 = Ad9912.Ad9912(pulser) oldDDSChannels = self.config.get(self.channelConfigName, []) self.ddsChannels = [ oldDDSChannels[i] if i < len(oldDDSChannels) else DDSChannelSettings() for i in range(self.numChannels) ] self.autoApply = self.config.get(self.autoApplyConfigName, True) self.decimation = defaultdict(lambda: StaticDecimation(Q(30, 's'))) self.persistence = DBPersist() self.globalDict = globalDict self.pulser = pulser self.persistSpace = 'DDS' for index, channelinfo in enumerate(self.channelInfo): self.ddsChannels[index].channel = channelinfo.channel self.ddsChannels[index].shutter = channelinfo.shutter
def convertMagnitude(self, resistance): if resistance is None: return None lR = log(resistance) m = Q(1 / (self.a + self.b * lR + self.c * lR**3) - 273.15, 'K') m.significantDigits = 7 return m
def addSetting(self): if None not in self.variables: self.beginInsertRows(QtCore.QModelIndex(), len(self.variables), len(self.variables)) self.variables[None] = Q(0) self.endInsertRows() self.edited.emit() return len(self.variables) - 1
def __init__(self): super(PulserHardware, self).__init__() self._shutter = 0 self._trigger = 0 self.xem = None self.Mutex = QtCore.QMutex self._adcCounterMask = 0 self._integrationTime = Q(100, 'ms') self.dataQueue = multiprocessing.Queue() self.clientPipe, self.serverPipe = multiprocessing.Pipe() self.loggingQueue = multiprocessing.Queue() self.sharedMemoryArray = Array(c_longlong, self.sharedMemorySize, lock=True) self.serverProcess = self.serverClass(self.dataQueue, self.serverPipe, self.loggingQueue, self.sharedMemoryArray) self.serverProcess.start() self.queueReader = QueueReader(self, self.dataQueue) self.queueReader.start() self.loggingReader = LoggingReader(self.loggingQueue) self.loggingReader.start() self.ppActive = False self._pulserConfiguration = None
def set_frequency(self, freq, channel, max_age=None): max_age = max_age if max_age is not None else Q(3, 's') self.getWavemeterData(channel, freq) if channel in self.lastResult: result, measure_time = self.lastResult[channel] if time() - measure_time < max_age.m_as('s'): return result return None