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()