class Vitalsign(Analysis):
'''Beeps when atoms are loaded
'''
version = '2017.05.30'
threshold_array = Member()
enable = Bool()
meas_analysis_path = Member()
def __init__(self, experiment, roi_rows=1, roi_columns=1):
super(Vitalsign, self).__init__('Vitalsign', experiment,
'Atom heartbeat')
self.threshold_array = np.zeros(10)
self.properties += ['version', 'threshold_array', 'enable']
self.enable = True
self.meas_analysis_path = 'analysis/ROIThresholds'
self.queueAfterMeasurement = True
#self.measurementDependencies += [self.experiment.thresholdROIAnalysis]
def analyzeMeasurement(self, measurementResults, iterationResults,
experimentResults):
if self.enable:
#threshold_array = np.random.choice([0, 1], size=(10,), p=[1./2, 1./2])
threshold_array = measurementResults[self.meas_analysis_path][()]
threshold_array.astype(int)
if np.sum(threshold_array) > 0:
winsound.Beep(2000, 200)
class Noise_Eaters(Instrument):
version = '2017.07.21'
#host = '10.141.210.242' # ip of raspberry pi
#port = 12345
#arr = [1,5,3,4]
pis = Member()
s = Member()
resultsArray = Member()
def __init__(self, name, experiment, description=''):
super(Noise_Eaters, self).__init__(name, experiment, description)
self.pis = ListProp('pis',
experiment,
'A list of individual Raspberry Pis',
listElementType=Noise_Eater,
listElementName='pi')
self.properties += ['version', 'pis']
def initialize(self):
"""Open the TCP socket"""
if self.enable:
self.isInitialized = True
def start(self):
self.update()
self.isDone = True
def update(self):
"""
Every iteration, send the motors updated positions.
"""
self.resultsArray = numpy.delete(numpy.empty([1, 4]), (0), axis=0)
for i in self.pis:
if self.enable:
#arr = update()
#arr2 = [1,2,3,4]
#IP2 = '10.141.210.242' # ip of raspberry pi
#port2 = 12345
IP, port, settings_array = i.update()
self.s = socket.socket()
settings_array = [d.value for d in settings_array]
#print(settings_array)
data_string = pickle.dumps(settings_array)
self.s.connect((IP, port))
self.s.send(data_string)
self.resultsArray = numpy.append(
self.resultsArray, [pickle.loads(self.s.recv(1024))],
axis=0)
self.s.close()
def writeResults(self, hdf5):
if self.enable:
hdf5['noise_eater'] = self.resultsArray
class Controller(Atom):
model = Member()
view = Member()
def __init__(self, model=None, view=None):
self.model = model
self.view = view
@observe('model.text')
def rewrite(self, change):
self.view.text = self.model.text
class Numpy1DProp(Prop):
array = Member()
dtype = Member()
hdf_dtype = Member()
zero = Member()
def __init__(self,
name,
experiment,
description='',
dtype=float,
hdf_dtype=float,
zero=None):
super(Numpy1DProp, self).__init__(name, experiment, description)
self.dtype = dtype
self.hdf_dtype = hdf_dtype
self.zero = zero
#create zero length array
self.array = numpy.zeros(0, dtype=dtype)
self.properties += ['array']
def __len__(self):
return len(self.array)
def add(self, index):
zero = numpy.zeros(1, dtype=self.dtype)
if self.zero is not None:
zero.fill(self.zero)
self.array = numpy.insert(self.array, index, zero)
def remove(self, index):
self.array = numpy.delete(self.array, index)
def toHDF5(self, hdf, name=None):
try:
hdf.create_dataset(
self.name, data=self.array,
dtype=self.hdf_dtype) #, compression="gzip", chunks=True)
except Exception as e:
logger.exception(
'While trying to create dataset in Numpy1DProp.toHDF5() in ' +
self.name + '.')
raise PauseError
def fromHDF5(self, hdf):
try:
self.array = hdf.value.astype(self.dtype)
except Exception as e:
logger.exception(
' in Numpy1DProp.fromHDF5() in {} for hdf node {}.'.format(
self.name, hdf.name))
raise PauseError
class XYPlotAnalysis(AnalysisWithFigure):
#### needs updating
X = Member()
Y = Member()
def updateFigure(self):
if self.draw_fig:
fig = self.backFigure
fig.clf()
ax = fig.add_subplot(111)
if (self.X is not None) and (self.Y is not None):
ax.plot(self.X, self.Y)
super(XYPlotAnalysis, self).updateFigure()
class RF_generator(Prop):
enable = Member()
GPIBchannel = Member()
frequency = Typed(FloatProp)
power = Typed(FloatProp)
def __init__(self, name, experiment, description=''):
super(RF_generator, self).__init__(name, experiment, description)
self.enable = False
self.GPIBchannel = 0
self.frequency = FloatProp('frequency', self.experiment, '[MHz]', '10')
self.power = FloatProp('power', self.experiment, '[dBm]', '0')
self.properties += ['enable', 'GPIBchannel', 'frequency', 'power']
class BILTcards(Instrument):
version = '2017.07.25'
channels = Member()
port = Int()
socket = Member()
IP = Str()
def __init__(self, name, experiment, description=''):
super(BILTcards, self).__init__(name, experiment, description)
self.channels = ListProp('channels',
experiment,
'A list of voltage channels',
listElementType=BILTcard,
listElementName='channel')
self.properties += ['version', 'IP', 'port', 'channels']
def initialize(self):
"""Open the TCP socket"""
if self.enable:
self.isInitialized = True
def start(self):
self.isDone = True
def update(self):
"""
Every iteration, send the channels updated voltages.
"""
if self.enable:
msg = ''
try:
for i in self.channels:
# get the chassis slot, channel number, and voltage from each channel
msg = i.update()
# send it to the chasis
self.socket = socket.socket()
self.socket.connect((self.IP, self.port))
self.socket.send(msg)
time.sleep(0.2)
self.socket.send('meas:volt ?\n')
print(self.socket.recv(1024))
self.socket.close()
time.sleep(0.2)
except Exception as e:
logger.error(
'Problem setting BILT voltage, closing socket:\n{}\n{}\n'.
format(msg, e))
self.socket.close()
self.isInitialized = False
raise PauseError
class PICam(Instrument):
camera = Member()
analysis = Member()
def __init__(self, name, experiment, description=''):
super(PICam, self).__init__(name, experiment, description)
self.camera = PICamCamera('Camera{}'.format(name), experiment,
'PICam Camera')
self.analysis = PICamViewer('Viewer{}'.format(name), experiment,
'PICam Viewer', self.camera)
self.properties += ['camera', 'analysis']
def evaluate(self):
self.camera.evaluate()
class NIScope(Instrument):
scope = Member()
analysis = Member()
def __init__(self, name, experiment, description=''):
super(NIScope, self).__init__(name, experiment, description)
self.scope = NIScopeInstrument('Scope{}'.format(name), experiment,
'NIScope')
self.analysis = NIScopeViewer('Viewer{}'.format(name), experiment,
'NIScope Viewer', self.scope)
self.properties += ['scope', 'analysis']
def evaluate(self):
self.scope.evaluate()
class NewportStage(Instrument):
version = '2016.12.21'
setposition = Member()
allow_evaluation = Bool(True)
gui = Member()
nport = Member()
comport = Member()
mypos = Float()
def __init__(self, name, experiment, description=''):
super(NewportStage, self).__init__(name, experiment, description)
self.setposition = FloatProp('setposition', experiment, 'Set Position (mm)','0')
self.comport = StrProp('comport',experiment,'COM port','COM6')
self.properties += ['setposition','comport']
def initialize(self):
if self.enable and not self.isInitialized:
self.nport = newportcontroller.Newport(self.comport.value)
self.isInitialized = True
def update(self):
if self.enable:
self.moveStage()
return
def moveStage(self):
if not self.isInitialized:
self.nport = newportcontroller.Newport(self.comport.value)
self.isInitialized = True
self.nport.moveAbs(self.setposition.value*1000)
self.mypos = self.whereAmI()
loopcounter=0
while loopcounter < 100 and abs(self.mypos-self.setposition.value) > .001:
time.sleep(.1)
self.mypos = self.whereAmI()
loopcounter+=1
if loopcounter >= 100:
logger.error("Newport stage position not reached in 10 seconds")
logger.error("Set Position: {} mm, observed position: {} mm".format(self.setposition.value,mypos))
raise PauseError
def whereAmI(self):
return self.nport.whereAmI()/1000
def writeResults(self, hdf5):
if self.enable:
self.mypos = self.whereAmI()
return
class DDSbox(Prop):
enable = Bool()
deviceReference = Str()
DIOport = Int()
serialClockRate = Int()
channels = Typed(ListProp)
DDS = Member()
def __init__(self, name, experiment, description='', DDS=None):
self.DDS = DDS
self.enable = False
self.DIOport = 0
self.serialClockRate = 1000
super(DDSbox, self).__init__(name, experiment, description)
# each box has exactly 4 channels
self.channels = ListProp('channels',
experiment,
listProperty=[
DDSchannel('channel', self.experiment)
for i in range(4)
],
listElementType=DDSchannel,
listElementName='channel')
self.properties += [
'enable', 'deviceReference', 'DIOport', 'serialClockRate',
'channels'
]
@observe('description')
def descriptionChanged(self, change):
self.DDS.updateBoxDescriptionList()
class PiezoController(Prop):
version = '2014.04.06'
enable = Member()
serialNumber = Str()
identificationRead = Str()
serialNumberRead = Str()
channels = Typed(ListProp)
def __init__(self, name, experiment, description=''):
super(PiezoController, self).__init__(name, experiment, description)
self.enable = False
self.serialNumber = ''
self.identificationRead = ''
self.serialNumberRead = ''
self.channels = ListProp('channels',
self.experiment,
listProperty=[
PiezoChannel('channel' + str(i),
self.experiment)
for i in range(9)
],
listElementType=PiezoChannel,
listElementName='channel')
self.properties = [
'version', 'enable', 'serialNumber', 'identificationRead',
'serialNumberRead', 'channels'
]
def test_del_noop():
"""Test the noop handler."""
member = Member()
member.set_delattr_mode(DelAttr.NoOp, None)
class A(Atom):
m = member
assert A.m.delattr_mode[0] == DelAttr.NoOp
a = A()
a.m = 1
del a.m
assert a.m == 1
assert A.m.do_delattr(a) is None
assert a.m == 1
class NumpySequence(Numpy2DProp):
valid = Member() # an array to store the evaluation success of the array
value_str = Member() # an array to store the string that should be displayed for each element of the array ['value']
eval2 = Member()
def __init__(self, experiment, description=''):
super(NumpySequence, self).__init__('sequence', experiment, description,
dtype=[('function', object), ('value', numpy.uint8)],
hdf_dtype=[('function', h5py.special_dtype(vlen=str)), ('value', numpy.uint8)],
zero=('', 5))
self.valid = numpy.zeros(0, dtype=numpy.bool_)
self.value_str = numpy.zeros(0, dtype='S1')
self.eval2 = numpy.vectorize(self.eval1) #, otypes=[numpy.float64, numpy.bool_, numpy.object])
def eval1(self, string):
value, valid = self.experiment.eval_general(string)
if value is None:
return 5, True, ''
elif (value == 0) or (value == 1):
return int(value), valid, str(int(value))
else:
logger.warning('Waveform state must be either None (continue), 0 (off) or 1 (on). Got:\n{} = {}\n'.format(string,value))
return 5, False, ''
def evaluate(self):
"""self.array['value'] is assigned right away, but self.valid and self.value_str are what trigger the gui update
"""
if self.array.size > 0:
self.array['value'], valid, value_str = self.eval2(self.array['function'])
#value_str = self.toStr(self.array['value'])
else:
# We cannot allow calls to a vectorized function with a length zero input,
# so create these zero length arrays manually.
value_str = numpy.zeros((0, 0), dtype='S1')
valid = numpy.zeros((0, 0), dtype=numpy.bool_)
self.set_gui({'value_str': value_str,
'valid': valid})
def copy(self):
new = NumpySequence(self.experiment, self.description)
new.dtype = self.dtype
new.hdf_dtype = self.hdf_dtype
new.zero = self.zero
new.array = self.array.copy()
return new
class NumpyTransitions(Numpy1DProp):
valid = Member() # an array to store the evaluation success of the array
value_str = Member() # an array to store the string that should be displayed for each element of the array ['value']
eval2 = Member()
#toStr = numpy.vectorize(str)
def __init__(self, experiment, description=''):
super(NumpyTransitions, self).__init__('transitions', experiment, description,
dtype=[('description', object), ('function', object), ('value', numpy.float64)],
hdf_dtype=[('description', h5py.special_dtype(vlen=str)), ('function', h5py.special_dtype(vlen=str)), ('value', numpy.float64)],
zero=('new', '0', 0)
)
self.valid = numpy.zeros(0, dtype=numpy.bool_)
self.value_str = numpy.zeros(0, dtype='S1')
self.eval2 = numpy.vectorize(self.eval1) #, otypes=[numpy.float64, numpy.bool_, numpy.object])
def eval1(self, x):
value, valid = self.experiment.eval_float(x)
if value is None:
return 0, False, ''
else:
return value, valid, str(value)
def evaluate(self):
"""self.array['value'] is assigned right away, but self.valid and self.value_str are what trigger the gui update
"""
if len(self.array) > 0:
self.array['value'], valid, value_str = self.eval2(self.array['function'])
#value_str = self.toStr(self.array['value'])
else:
# We cannot allow calls to a vectorized function with a length zero input,
# so create these zero length arrays manually.
value_str = numpy.zeros(0, dtype='S1')
valid = numpy.zeros(0, dtype=numpy.bool_)
self.set_gui({'value_str': value_str,
'valid': valid})
def copy(self):
new = NumpyTransitions(self.experiment,self.description)
new.dtype = self.dtype
new.hdf_dtype = self.hdf_dtype
new.zero = self.zero
new.array = self.array.copy()
return new
class Fit_Sites(Prop):
# must keep track of position changes and send only difference
Fit_site = Int() #site to apply offsets
Fit_Frequency_x = Member() #x frequency for fit
Fit_Frequency_y = Member() #y frequency for fit
def __init__(self, name, experiment, description=''):
super(Fit_Sites, self).__init__(name, experiment, description)
self.Fit_Frequency_x = FloatProp('Fit_Frequency_x', experiment,
'the fit for the x frequency', '0')
self.Fit_Frequency_y = FloatProp('Fit_Frequency_y', experiment,
'the fit for the y frequency', '0')
self.properties += ['Fit_site', 'Fit_Frequency_x', 'Fit_Frequency_y']
def update(self):
# calculate relative move necessary
return self.Fit_site, self.Fit_Frequency_x.value, self.Fit_Frequency_y.value
class UnlockMonitors(Instrument, Analysis):
version = '2016.06.02'
motors = Member()
def __init__(self, name, experiment, description=''):
super(UnlockMonitors, self).__init__(name, experiment, description)
self.motors = ListProp(
'motors',
experiment,
'A list of individual Raspberry Pi unlock monitors',
listElementType=Andor,
listElementName='motor')
self.properties += ['version', 'motors']
def preExperiment(self, hdf5):
"""Open the TCP socket"""
if self.enable:
for i in self.motors:
if i.enable:
try:
i.preExperiment(hdf5)
i.isInitialized = True
except Exception as e:
logger.error(
'Problem initializing Conex: \n{}\n{}\n'.format(
i.IDString.value, e))
i.isInitialized = False
return PauseError
# TODO: add here some sort of communications check to see if it worked
self.isInitialized = True
def postMeasurement(self, callbutt, measurementresults, iterationresults,
hdf5):
return
def postIteration(self, iterationresults, hdf5):
return
def postExperiment(self, hdf5):
if self.enable:
for i in self.motors:
if i.enable:
i.postExperiment()
return
def finalize(self, hdf5):
#if self.enable:
# for i in self.motors:
# i.socket.close()
return
def stop(self):
if self.enable:
for i in self.motors:
if i.enable:
i.stop()
return
def test_del_noop():
"""Test the noop handler.
"""
member = Member()
member.set_delattr_mode(DelAttr.NoOp, None)
class A(Atom):
m = member
assert A.m.delattr_mode[0] == DelAttr.NoOp
a = A()
a.m = 1
del a.m
assert a.m == 1
assert A.m.do_delattr(a) is None
assert a.m == 1
class Picomotors(Instrument):
version = '2014.07.09'
IP = Str()
port = Int()
motors = Member()
socket = Member()
def __init__(self, name, experiment, description=''):
super(Picomotors, self).__init__(name, experiment, description)
self.motors = ListProp('motors',
experiment,
'A list of individual picomotors',
listElementType=Picomotor,
listElementName='motor')
self.properties += ['version', 'IP', 'port', 'motors']
def initialize(self):
"""Open the TCP socket"""
if self.enable:
self.socket = TCP.CsClientSock(self.IP, self.port)
# TODO: add here some sort of communications check to see if it worked
self.isInitialized = True
def update(self):
"""
Every iteration, send the motors updated positions.
"""
if self.enable:
msg = ''
try:
for i in motors:
# get the serial number, motor, and position from each motor
msg = i.update()
# send it to the picomotor server
self.socket.sendmsg(msg)
except Exception as e:
logger.error(
'Problem setting Picomotor position, closing socket:\n{}\n{}\n'
.format(msg, e))
self.socket.close()
self.isInitialized = False
raise PauseError
class InstekPST(Prop):
serial_number = Str()
com_port = Member()
tracking = Member()
isInitialized = Bool(False)
#num_chans = Int(3) #TODO: Implement variable number of channels...
voltage_setpoint_1 = Member()
current_setpoint_1 = Member()
voltage_setpoint_2 = Member()
current_setpoint_2 = Member()
voltage_setpoint_3 = Member()
current_setpoint_3 = Member()
actual_voltage_1 = Str()
actual_current_1 = Str()
actual_voltage_2 = Str()
actual_current_2 = Str()
actual_voltage_3 = Str()
actual_current_3 = Str()
ser = Member()
def __init__(self, name, experiment, description=''):
super(InstekPST, self).__init__(name, experiment, description)
self.com_port = StrProp('com_port', experiment, 'Communications port of PST','0')
self.tracking = IntProp('tracking', experiment, 'Tracking Mode (0 Independent; 1 Parallel; 2 Series)','0')
#self.num_chans = IntProp('num_chans', experiment, 'Number of channels','0')
self.voltage_setpoint_1 = FloatProp('voltage_setpoint_1', experiment, 'Voltage Setpoint for Channel 1','0')
self.current_setpoint_1 = FloatProp('current_setpoint_1', experiment, 'Current Setpoint for Channel 1','0')
self.voltage_setpoint_2 = FloatProp('voltage_setpoint_2', experiment, 'Voltage Setpoint for Channel 2','0')
self.current_setpoint_2 = FloatProp('current_setpoint_2', experiment, 'Current Setpoint for Channel 2','0')
self.voltage_setpoint_3 = FloatProp('voltage_setpoint_3', experiment, 'Voltage Setpoint for Channel 3','0')
self.current_setpoint_3 = FloatProp('current_setpoint_3', experiment, 'Current Setpoint for Channel 3','0')
self.properties += ['com_port', 'serial_number', 'tracking',
'voltage_setpoint_1', 'current_setpoint_1', 'voltage_setpoint_2', 'current_setpoint_2',
'voltage_setpoint_3', 'current_setpoint_3', 'actual_voltage_1', 'actual_current_1',
'actual_voltage_2', 'actual_current_2', 'actual_voltage_3', 'actual_current_3',
]
def initialize(self):
self.ser = serial.Serial()
self.ser.port = self.com_port.value
self.ser.baudrate = 9600
self.ser.timeout = 1
try:
self.ser.open()
self.isInitialized = True
except serial.SerialException, e:
logger.error("Instek PST initialize: Could not open serial port %s: %s\n" % (self.ser.portstr, e))
self.isInitialized = False
raise PauseError
def resolve_member_types(
member: Member,
resolve: bool = True) -> Optional[TupleType[type, ...]]:
"""Determine the validation types specified on a member.
Parameters
----------
member: Member
The member to retrieve the type from
resolve: bool
Whether to resolve "Forward" members.
Returns
-------
types: Optional[Tuple[Model|Member|type, ..]]
The member types. If types is `None` then the member does not do any
type validation.
Raises
------
UnresolveableError
If `resolve=False` and the member has a nested forwarded member this
will raise an UnresolvableError with the unresolved member.
"""
# TODO: This should really use the validate mode...
if hasattr(member, "resolve"):
if not resolve:
raise UnresolvableError(member) # Do not resolve now
types = member.resolve() # type: ignore
elif isinstance(member, Coerced):
types = member.validate_mode[-1][0]
else:
types = member.validate_mode[-1]
if types is None:
return None
if isinstance(types, tuple):
# Dict may have an member in the types list, so walk the types
# and resolve all of those.
resolved: ListType[type] = []
for t in types:
if isinstance(t, Member):
r = resolve_member_types(t, resolve)
if r is None:
# TODO: Think about whether this is correct to bail out here
return None
resolved.extend(r)
else:
resolved.append(t)
return tuple(resolved)
if isinstance(types, Member):
# Follow the chain. For example if the member is defined
# as `List(Tuple(float)))` lookup the types of the nested Tuple().
return resolve_member_types(types, resolve)
if isinstance(types, str):
return None # Custom validation method
return (types, )
class InstekPSTs(Instrument):
version = '2015.07.09'
motors = Member()
def __init__(self, name, experiment, description=''):
super(InstekPSTs, self).__init__(name, experiment, description)
self.motors = ListProp('motors', experiment, 'A list of individual PST power supplies', listElementType=InstekPST,
listElementName='PST')
self.properties += ['version', 'motors']
def preExperiment(self, hdf5):
"""Open the TCP socket"""
if self.enable:
for i in self.motors:
#initialize serial connection to each power supply
i.initialize()
#check connection by requesting serial number
i.get_serial_number()
self.isInitialized = True
def preIteration(self, iterationresults, hdf5):
"""
Every iteration, send the motors updated positions.
"""
if self.enable:
msg = ''
try:
for i in self.motors:
i.update()
if i.test_output() == False:
i.enable_output()
if (i.get_tracking() != i.tracking.value):
i.set_tracking()
except Exception as e:
logger.error('Problem updating current/voltage for Instek PST:\n{}\n{}\n'.format(msg, e))
self.isInitialized = False
raise PauseError
def postMeasurement(self, measurementresults, iterationresults, hdf5):
return
def postIteration(self, iterationresults, hdf5):
if self.enable:
for i in self.motors:
i.measure_all_channels()
return
def postExperiment(self, hdf5):
return
def finalize(self,hdf5):
return
class Model(Atom):
text = Member()
def __init__(self):
self.text = 'hi'
threading.Thread(target=self.go).start()
def go(self):
for i in xrange(10):
self.text = str(i)
time.sleep(1)
class Aerotech(Prop):
'''Xi = Member()
Xend = Member()
Xvmx = Member()
Xamx = Member()
Zi = Member()
Zend = Member()
Zvmx = Member()
Zamx = Member()
XretTrig = Member()'''
globals = Member()
allow_evaluation = Bool(True)
gui = Member()
myController = Member()
def __init__(self, name, experiment, description=''):
super(Aerotech, self).__init__(name, experiment, description)
'''self.Xi = FloatProp('Xi', experiment, 'Initial X position (mm)','0')
self.Xend = FloatProp('Xend', experiment, 'Final X position (mm)','0')
self.Xvmx = FloatProp('Xvmx', experiment, 'Max X velocity (mm/s)','0')
self.Xamx = FloatProp('Xend', experiment, 'Max X acceleration (mm/s^2)','0')
self.Zi = FloatProp('Zi', experiment, 'Initial Z position (mm)','0')
self.Zend = FloatProp('Zend', experiment, 'Final Z position (mm)','0')
self.Zvmx = FloatProp('Zvmx', experiment, 'Max Z velocity (mm/s)','0')
self.Zamx = FloatProp('Zend', experiment, 'Max Z acceleration (mm/s^2)','0')
self.XretTrig = IntProp('XretTrig', experiment, 'X Trig Return?','0')'''
self.globals = ListProp('globals',
experiment,
listElementType=FloatProp,
listElementName='global')
self.properties += ['globals']
def update(self):
for i, k in enumerate(self.globals):
self.myController.Commands.Register.WriteDoubleGlobal(i, k.value)
#integer globals go here if needed
self.myController.Parameters.System.User.UserInteger0.Value = 1
def waitForGlobals(self):
self.myController.Parameters.System.User.UserInteger0.Value = -1
class Noise_Eater(Prop):
# must keep track of position changes and send only difference
target_setting1 = Member() #set from 0 to 100
target_setting2 = Member() #set from 0 to 100
target_setting3 = Member() #set from 0 to 100
target_setting4 = Member() #set from 0 to 100
IP = Str()
port = Int()
setting_array = List()
def __init__(self, name, experiment, description=''):
super(Noise_Eater, self).__init__(name, experiment, description)
self.target_setting1 = FloatProp('target_setting1', experiment,
'the target power 1 percentage',
'100')
self.target_setting2 = FloatProp('target_setting2', experiment,
'the target power 2 percentage',
'100')
self.target_setting3 = FloatProp('target_setting3', experiment,
'the target power 3 percentage',
'100')
self.target_setting4 = FloatProp('target_setting4', experiment,
'the target power 4 percentage',
'100')
self.properties += [
'target_setting1', 'target_setting2', 'target_setting3',
'target_setting4', 'IP', 'port'
]
self.setting_array = [
self.target_setting1, self.target_setting2, self.target_setting3,
self.target_setting4
]
def update(self):
# calculate relative move necessary
return self.IP, self.port, self.setting_array
class Noise_Eater(Prop):
# must keep track of position changes and send only difference
target_setting = Member() #set from 0 to 100
ip = Str()
ID = Int()
def __init__(self, name, experiment, description=''):
super(Noise_Eater, self).__init__(name, experiment, description)
self.target_setting = FloatProp('target_setting1', experiment,
'the target Voltage', '1')
self.properties += ['target_setting', 'ip', 'ID']
def update(self):
# calculate relative move necessary
data = {'setpointv': self.target_setting.value}
return self.ip, data, self.ID
class ROIAnalysis(AnalysisWithFigure):
"""Parent class for analyses that depend on the number of ROIs"""
camera = Member()
def set_rois(self):
"""This function is called following the normal fromHDF5 call and
should be used to re-initialize anything that depends on the number
of ROIs.
The function should reference self.experiment.ROI_XXXXX to get the
updated number of ROIs.
"""
raise NotImplementedError
def fromHDF5(self, hdf):
"""Overrides fromHDF5 to call set_rois following the read"""
super(ROIAnalysis, self).fromHDF5(hdf)
self.set_rois()
def find_camera(self):
"""Find camera instrument object in experiment properties tree."""
# get the property tree path to the camera object from the config file
prop_tree = self.experiment.Config.config.get('CAMERA',
'CameraObj').split(',')
camera = self.experiment
for lvl in prop_tree:
camera = getattr(camera, lvl)
# if camera is stored in a ListProp list then use the index function
# to retreive it
camera_idx = self.experiment.Config.config.getint(
'CAMERA', 'CameraIdx')
if camera_idx >= 0:
try:
camera = camera[camera_idx]
except ValueError:
logger.warning(
'No camera found at index `%d` in camera list: `%s`. Disabling analysis',
camera_idx, '.'.join(prop_tree))
self.enable = False
self.camera = camera
def preExperiment(self, experimentResults):
self.set_rois()
super(ROIAnalysis, self).preExperiment(experimentResults)
class BILTcard(Prop):
# must keep track of voltage changes
chassis_card_number = Str()
channel_number = Str()
desired_voltage = Member()
def __init__(self, name, experiment, description=''):
super(BILTcard, self).__init__(name, experiment, description)
self.desired_voltage = FloatProp('desired_voltage', experiment,
'the desired voltage', '0')
self.properties += [
'chassis_card_number', 'channel_number', 'desired_voltage'
]
def update(self):
# return the new voltage value
return 'i{}; c{}; volt {}\n'.format(self.chassis_card_number,
self.channel_number,
self.desired_voltage.value)
class Noise_Eaters(Instrument):
version = '2017.07.21'
NEchannels = Member()
def __init__(self, name, experiment, description=''):
super(Noise_Eaters, self).__init__(name, experiment, description)
self.NEchannels = ListProp('NEchannels',
experiment,
'A list of Noise Eater channels',
listElementType=Noise_Eater,
listElementName='NEchannel')
self.properties += ['version', 'NEchannels']
def initialize(self):
"""Open the TCP socket"""
if self.enable:
self.isInitialized = True
def start(self):
self.isDone = True
def configChangeRequest(self, ip, data, ID):
url = "http://" + ip + ":5000/update/" + ID + "/config"
payload = ''
for key in data.keys():
payload += key + '=' + str(data[key]) + '&'
headers = {
'content-type': "application/x-www-form-urlencoded",
'cache-control': "no-cache",
'postman-token': "09ba4097-3e23-694d-3d87-1b8d5bc3aaaa"
}
response = requests.request("POST", url, data=payload, headers=headers)
def update(self):
"""
Every iteration, send the motors updated positions.
"""
for i in self.NEchannels:
if self.enable:
ip, data, ID = i.update()
self.configChangeRequest(ip, data, str(ID))
class PiezoChannel(Prop):
version = '2014.04.06'
setServo = Typed(BoolProp)
setPosition = Typed(FloatProp)
readAxis = Str()
readServo = Member()
readPosition = Float()
def __init__(self, name, experiment, description=''):
super(PiezoChannel, self).__init__(name, experiment, description)
self.readServo = False
self.setServo = BoolProp('setServo', self.experiment, '', 'False')
self.setPosition = FloatProp('setPosition', self.experiment, '', '0')
self.readAxis = ''
self.readServo = False
self.readPosition = float('nan')
self.properties += [
'version', 'setServo', 'setPosition', 'readAxis', 'readServo',
'readPosition'
]
class Piezo(Instrument):
version = '2014.04.06'
channels = Typed(ListProp)
controllers = Member()
def __init__(self, experiment):
super(Piezo, self).__init__('piezo', experiment)
self.controllers = ListProp('controllers',
self.experiment,
listProperty=[
PiezoController(
'controller' + str(i),
self.experiment) for i in range(2)
],
listElementType=PiezoController,
listElementName='controller')
self.properties += ['version', 'controllers']
def evaluate(self):
if self.experiment.allow_evaluation:
logger.debug('piezo.evaluate()')
return super(Piezo, self).evaluate()