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
