def on_login_button_clicked(self): #project_valid, username_valid = self.validate_entries() tmp = "/mnt/BMIT_data/BMIT-USERS-DATA/" if self.project_name != '': project_valid = self.validate_entries() if project_valid: self.login_parameters_dict.update({'bl': self.bl_name}) self.login_parameters_dict.update( {'project': self.project_name}) tmp = os.path.join(tmp, self.project_name) # add fileExistsError exception later in Py3 try: os.makedirs(tmp) #, exist_ok=True) except: pass self.login_parameters_dict.update({'expdir': tmp}) self.accept() #elif not username_valid: # error_message("Username should be alpha-numeric ") elif not project_valid: error_message("The project should be in format: CCTNNNNN, \n" "where CC is cycle number, " "T is one-letter type, " "and NNNNN is project number") elif self.expdir_name != '': if self.validate_dir: self.login_parameters_dict.update({'expdir': self.expdir_name}) self.accept() else: error_message("Cannot write in the selected directory")
def get_outer_motor_grid(self): if self.scan_controls_group.outer_steps > 0: self.number_of_scans = self.scan_controls_group.outer_steps if self.scan_controls_group.outer_loop_endpoint: return linspace( self.scan_controls_group.outer_start, self.scan_controls_group.outer_start + self.scan_controls_group.outer_range, self.scan_controls_group.outer_steps) else: return linspace( self.scan_controls_group.outer_start, self.scan_controls_group.outer_start + self.scan_controls_group.outer_range, self.scan_controls_group.outer_steps, False) elif self.scan_controls_group.outer_steps == 0: self.number_of_scans = 1 if self.scan_controls_group.outer_motor != 'Timer [sec]': return [ self.motors[self.scan_controls_group.outer_motor].position. magnitude ] else: return [0] else: error_message("Outer motor start/steps/range entered incorrectly ") self.abort()
def set_camera_params(self): self.log.info("Setting camera parameters") if self.camera_model_label.text() == 'Dummy camera': return -1 try: if self.camera.state == 'recording': self.camera.stop_recording() self.camera.exposure_time = self.exp_time * q.msec if self.camera_model_label.text() == "PCO Dimax": self.camera.frame_rate = self.fps * q.hertz else: self.camera.sensor_pixelrate = int( self.sensor_pix_rate_entry.currentText()) self.camera.buffered = self.buffered if self.camera.buffered: self.camera.num_buffers = self.buffnum self.set_time_stamp() self.setROI() except: tmp = "Can not set camera parameters" self.log.error(tmp) error_message(tmp) return True else: return False
def fps(self): try: x = float(self.fps_entry.text()) except ValueError: warning_message("{:}".format( "FPS a positive number. Setting FPS based on exp. time")) x = self.relate_fps_to_exptime() if x < 0: error_message("{:}".format("FPS must be positive")) self.all_cam_params_correct = False if self.camera_model_label.text() == 'PCO Dimax': if x < 25: warning_message( "{:}".format("Dimax FPS must be greater than 25")) x = 25 if self.trig_mode == "EXTERNAL" and \ int(x) < int(1000.0 / (self.exp_time + self.dead_time)): warning_message("{:}".format( "Dimax FPS must be greater than frequency of external triggers" )) x = int(1000.0 / self.exp_time) # if self.camera_model_label.text() == 'PCO Edge' and (x > 100): # error_message("{:}".format("PCO Edge max FPS is 100")) # self.all_cam_params_correct = False # if int(x) < int(1000.0 / (self.exp_time + self.dead_time)): #because of round of errors # #warning_message("FPS [Hz] cannot exceed 1/exp.time[s]; setting fps=1/exp.time") # self.relate_fps_to_exptime() elif self.trig_mode == "EXTERNAL": x = self.relate_fps_to_exptime() self.fps_entry.setText("{:.02f}".format(x)) return x
def outer_steps(self): if self.outer_loop_steps_entry.text() == "": return 0 try: return int(self.outer_loop_steps_entry.text()) except ValueError: error_message("Number of steps must be positive integer number") return None
def run(self): # .start() calls this function while self.thread_running: try: self.motor.home().join() self.thread_running = False except TransitionNotAllowed: error_message( "Stage is moving. Wait until motion has stopped.") self.thread_running = False
def set_scan_params(self): self.log.info("Setting scan parameters") '''To be called before Experiment.run to set all parameters required for correct data acquisition''' problem_with_params = False # SET CAMERA PARAMETER if not self.camera_controls_group.ttl_scan.isChecked(): problem_with_params = self.camera_controls_group.set_camera_params( ) # SET ACQUISITION PARAMETERS try: # Times as floating point numbers [msec] to compute the CT stage motion self.concert_scan.acq_setup.dead_time = self.camera_controls_group.dead_time self.concert_scan.acq_setup.exp_time = self.camera_controls_group.exp_time # Inner motor and scan intervals self.concert_scan.acq_setup.motor = self.motors[ self.scan_controls_group.inner_motor] if self.scan_controls_group.inner_motor == 'CT stage [deg]': self.concert_scan.acq_setup.units = q.deg self.concert_scan.acq_setup.cont = self.scan_controls_group.inner_cont self.concert_scan.acq_setup.start = self.scan_controls_group.inner_start self.concert_scan.acq_setup.nsteps = self.scan_controls_group.inner_steps self.concert_scan.acq_setup.range = self.scan_controls_group.inner_range self.concert_scan.acq_setup.endp = self.scan_controls_group.inner_endpoint self.concert_scan.acq_setup.calc_step() self.concert_scan.acq_setup.flats_before = self.scan_controls_group.ffc_before self.concert_scan.acq_setup.flats_after = self.scan_controls_group.ffc_after # SET shutter if self.shutter is None: self.concert_scan.ffc_setup.shutter = DummyShutter() else: self.concert_scan.ffc_setup.shutter = self.shutter except: self.log.error("Scan params defined incorrectly. Aborting") info_message( "Select flat field motor and define parameters correctly") problem_with_params = True # SET FFC parameters if self.scan_controls_group.ffc_before or self.scan_controls_group.ffc_after or \ self.scan_controls_group.ffc_before_outer or self.scan_controls_group.ffc_after_outer: try: self.concert_scan.ffc_setup.flat_motor = self.motors[ self.ffc_controls_group.flat_motor] self.concert_scan.ffc_setup.radio_position = self.ffc_controls_group.radio_position * q.mm self.concert_scan.ffc_setup.flat_position = self.ffc_controls_group.flat_position * q.mm self.concert_scan.acq_setup.num_flats = self.ffc_controls_group.num_flats self.concert_scan.acq_setup.num_darks = self.ffc_controls_group.num_darks except: self.log.error( "Flat-field params defined incorrectly. Aborting") error_message( "Select flat field motor and define parameters correctly") problem_with_params = True if problem_with_params: self.number_of_scans = 0 self.end_of_scan()
def setROI(self): try: self.camera.roi_x0 = self.roi_x0 * q.pixels self.camera.roi_y0 = self.roi_y0 * q.pixels self.camera.roi_width = self.roi_width * q.pixels self.camera.roi_height = self.roi_height * q.pixels except: error_message( "ROI is not correctly defined for the sensor, check multipliers and centering" )
def num_flats(self): try: tmp = int(self.numflats_entry.text()) except ValueError: error_message('Number of flats must be positive integer number') if tmp < 1: info_message('Number of flats must be larger than 0') self.numflats_entry.setText('10') tmp = 10 return tmp
def root_dir(self): try: tmp = self.root_dir_entry.text() except ValueError: error_message("Incorrect path to root directory") if os.access(tmp, os.W_OK): return tmp else: error_message( "Cannot write into root dir. Check filewriter params") return None
def num_darks(self): try: tmp = int(self.numdarks_entry.text()) except ValueError: error_message( 'Number of darks must be non-negative integer number') if tmp < 0: info_message('Number of darks must be 0 or larger') self.numdarks_entry.setText('10') tmp = 10 return tmp
def exp_time(self): try: x = float(self.exposure_entry.text()) except ValueError: error_message("{:}".format( "Exp. time must be a positive number. Setting to default")) x = 13 self.all_cam_params_correct = False if x < 0: error_message( "{:}".format("Exp. time must be positive. Setting to default")) x = 13 self.exposure_entry.setText('13') self.all_cam_params_correct = False if self.camera_model_label.text() == 'PCO Dimax' and (x > 40): error_message("{:}".format("Max exp. time for Dimax is 40 msec")) self.all_cam_params_correct = False x = 39.9999 self.exposure_entry.setText('39.9999') if self.camera_model_label.text() == 'PCO Edge' and (x > 2000): error_message("{:}".format("Max exp. time for Edge is 2 sec")) x = 1999.9 self.exposure_entry.setText('1999.9') self.all_cam_params_correct = False return x
def roi_width(self): try: h = int(self.roi_width_entry.text()) except ValueError: error_message( "ROI height must be positive integer number smaller then {}". format(self.camera.sensor_height.magnitude)) if self.camera_model_label.text() == 'PCO Dimax': h = int(h / 4) * 4 if h > 2000: h = 2000 self.roi_width_entry.setText(str(h)) return h else: return h
def connect_hor_motor_func(self): """Connect to horizontal stage motor.""" try: self.hor_motor = CLSLinear("SMTR1605-2-B10-11:mm", encoded=True) except: error_message("Can not connect to horizontal stage, try again") if self.hor_motor is not None: self.hor_mot_value.setText("Position [mm]") self.connect_hor_mot_button.setEnabled(False) self.move_hor_mot_button.setEnabled(True) self.move_hor_rel_plus.setEnabled(True) self.move_hor_rel_minus.setEnabled(True) self.hor_mot_monitor = EpicsMonitorFloat(self.hor_motor.RBV) self.hor_mot_monitor.i0_state_changed_signal.connect( self.hor_mot_value.setText) self.hor_mot_monitor.i0.run_callback(self.hor_mot_monitor.call_idx)
def connect_shutter_func(self): """Connect the shutter.""" try: self.shutter = CLSShutter("ABRS1605-01:fis") except: error_message( "Could not connect to fast imaging shutter, try again") if self.shutter is not None: self.shutter_status.setText("Connected") self.connect_shutter_button.setEnabled(False) self.open_shutter_button.setEnabled(True) self.close_shutter_button.setEnabled(True) self.shutter_monitor = EpicsMonitorFIS(self.shutter.STATE, self.shutter_status) self.shutter_monitor.i0_state_changed_signal.connect( self.shutter_status.setText) self.shutter_monitor.i0.run_callback(self.shutter_monitor.call_idx)
def roi_x0(self): try: h = int(self.roi_x0_entry.text()) except ValueError: if self.camera_model_label.text() == 'PCO Dimax': error_message( "ROI height must be positive integer number divisible by 4 and smaller then {:}" .format(996)) else: error_message( "ROI height must be positive integer number smaller then {:}" .format(self.camera.sensor_height.magnitude)) if self.camera_model_label.text() == 'PCO Dimax': h = 1000 - self.roi_width / 2 self.roi_x0_entry.setText(str(h)) return h else: return h
def roi_height(self): try: h = int(self.roi_height_entry.text()) except ValueError: error_message( "ROI height must be positive integer number smaller then {}". format(self.camera.sensor_height.magnitude)) if self.camera_model_label.text() == 'PCO Dimax': h = int(h / 4) * 4 if h > 2000: h = 2000 self.roi_height_entry.setText(str(h)) return h if self.camera_model_label.text() == 'PCO Edge': h = int(h / 2) * 2 if h > 2160: h = 2160 self.roi_y0_entry.setText(str(1080 - int(h / 2))) self.roi_height_entry.setText(str(h)) return h
def connect_CT_motor_func(self): """Connect to CT stage. In this case, ABRS is an air-bearing rotation stage.""" try: self.CT_motor = ABRS("ABRS1605-01:deg", encoded=True) except: error_message("Could not connect to CT stage, try again") if self.CT_motor is not None: self.CT_mot_value.setText("Position [deg]") self.connect_CT_mot_button.setEnabled(False) self.move_CT_mot_button.setEnabled(True) self.move_CT_rel_plus.setEnabled(True) self.move_CT_rel_minus.setEnabled(True) self.home_CT_mot_button.setEnabled(True) self.reset_CT_mot_button.setEnabled(True) self.CT_vel_select.setEnabled(True) self.CT_motor.base_vel = 5 * q.deg / q.sec self.CT_mot_monitor = EpicsMonitorFloat(self.CT_motor.RBV) self.CT_mot_monitor.i0_state_changed_signal.connect( self.CT_mot_value.setText) self.CT_mot_monitor.i0.run_callback(self.CT_mot_monitor.call_idx)
def run(self): # .start() calls this function while self.thread_running: final_pos = self.motor.position self.is_moving = True try: if not hasattr(self.motor, 'timer'): if self.rel_position is None: final_pos = self.position * self.motor.UNITS else: final_pos += (self.rel_position * self.direction * self.motor.UNITS) self.motor.position = final_pos else: sleep(self.position) self.is_moving = False self.motion_over_signal.emit(True) self.thread_running = False except TransitionNotAllowed: error_message( "Stage is moving. Wait until motion has stopped.") self.is_moving = False self.thread_running = False
def outer_range(self): try: return float(self.outer_loop_range_entry.text()) except ValueError: error_message("Range must be floating point number") return None
def load_from_yaml(self): fname, _ = QFileDialog.getOpenFileName( self, "Select yaml file with BMITgui params", self.file_writer_group.root_dir, "Python Files (*.yaml)") if fname == '': warning_message('Select the file') return with open(fname) as f: p = yaml.load(f, Loader=yaml.FullLoader) if p['Camera'][ 'Model'] != self.camera_controls_group.camera_model_label.text( ): error_message('Selected params file is for different camera') return try: ####### CAMERA ####### self.camera_controls_group.ttl_scan.setChecked( p['Camera']['External camera']) self.camera_controls_group.exposure_entry.setText( str(p['Camera']['Exposure time'])) self.camera_controls_group.fps_entry.setText( str(p['Camera']['FPS'])) self.camera_controls_group.roi_y0_entry.setText( str(p['Camera']['ROI first column'])) self.camera_controls_group.roi_width_entry.setText( str(p['Camera']['ROI width'])) self.camera_controls_group.roi_x0_entry.setText( str(p['Camera']['ROI first row'])) self.camera_controls_group.roi_height_entry.setText( str(p['Camera']['ROI height'])) tmp = self.camera_controls_group.buffered_entry.findText( str(p['Camera']['Buffered'])) self.camera_controls_group.buffered_entry.setCurrentIndex(tmp) self.camera_controls_group.n_buffers_entry.setText( str(p['Camera']['Number of buffers'])) tmp = self.camera_controls_group.trigger_entry.findText( p['Camera']['Trigger']) self.camera_controls_group.delay_entry.setText( str(p['Camera']['Dead time'])) self.camera_controls_group.trigger_entry.setCurrentIndex(tmp) tmp = self.camera_controls_group.sensor_pix_rate_entry.\ findText(p['Camera']['Sensor clocking']) self.camera_controls_group.sensor_pix_rate_entry.setCurrentIndex( tmp) self.camera_controls_group.time_stamp.setChecked( p['Camera']['Time stamp']) except: warning_message('Cannot enter all camera parameters correctly') try: ####### Scans' settings ####### tmp = self.scan_controls_group.outer_loop_motor.\ findText(p['Outer loop']['Motor']) self.scan_controls_group.outer_loop_motor.setCurrentIndex(tmp) self.scan_controls_group.outer_loop_start_entry.setText( str(p['Outer loop']['Start'])) self.scan_controls_group.outer_loop_steps_entry.setText( str(p['Outer loop']['Steps'])) self.scan_controls_group.outer_loop_range_entry.setText( str(p['Outer loop']['Range'])) self.scan_controls_group.outer_loop_flats_0.setChecked( p['Outer loop']['Flats before']) self.scan_controls_group.outer_loop_flats_1.setChecked( p['Outer loop']['Flats after']) tmp = self.scan_controls_group.inner_loop_motor. \ findText(p['Inner loop']['Motor']) self.scan_controls_group.inner_loop_motor.setCurrentIndex(tmp) self.scan_controls_group.inner_loop_start_entry.setText( str(p['Inner loop']['Start'])) self.scan_controls_group.inner_loop_steps_entry.setText( str(p['Inner loop']['Steps'])) self.scan_controls_group.inner_loop_range_entry.setText( str(p['Inner loop']['Range'])) self.scan_controls_group.inner_loop_flats_0.setChecked( p['Inner loop']['Flats before']) self.scan_controls_group.inner_loop_flats_1.setChecked( p['Inner loop']['Flats after']) self.scan_controls_group.readout_intheend.setChecked( p['Readout in the end']['Readout in the end']) except: warning_message('Cannot enter scan parameters correctly') try: ####### FFC settings ####### tmp = self.ffc_controls_group.motor_options_entry.findText( p['FFC']['Motor']) self.ffc_controls_group.motor_options_entry.setCurrentIndex(tmp) self.ffc_controls_group.radio_position_entry.setText( p['FFC']['Radio position']) self.ffc_controls_group.flat_position_entry.setText( p['FFC']['Flat position']) self.ffc_controls_group.numflats_entry.setText( str(p['FFC']['Num flats'])) self.ffc_controls_group.numdarks_entry.setText( str(p['FFC']['Num darks'])) except: warning_message('Cannot enter flat-field parameters correctly') try: ##### FILE WRITER ######## self.file_writer_group.setChecked(p['Writer']['Enabled']) self.file_writer_group.root_dir_entry.setText( p['Writer']['Data dir']) self.file_writer_group.ctset_fmt_entry.setText( p['Writer']['CT scan name']) self.file_writer_group.dsetname_entry.setText( p['Writer']['Filename']) self.file_writer_group.bigtiff_checkbox.setChecked( p['Writer']['Big tiffs']) self.file_writer_group.separate_scans_checkbox.setChecked( p['Writer']['Separate scans']) except: warning_message('Cannot enter file-writer settings correctly')
def flat_position(self): try: return float(self.flat_position_entry.text()) except ValueError: error_message( 'Out-of-beam sample position is not defined correctly')
def radio_position(self): try: return float(self.radio_position_entry.text()) except ValueError: error_message('In-beam sample position is not defined correctly')
def connect_time_motor_func(self): """Connect to a SimMotor.""" try: self.time_motor = SimMotor(1.0 * q.mm) except: error_message("Can not connect to timer")
def outer_start(self): try: return float(self.outer_loop_start_entry.text()) except ValueError: error_message("Starting point must be floating point number") return None
def live_on_func_stream2disk(self): if self.fname == None: error_message("Select the filename first") return self.lv_stream2disk_on = True self.lv_experiment.run()