Python qt.mstart函数代码示例

def test_hh():
    
    qt.mstart()
    initialize_hh()
    hharp.StartMeas(int(1e3 * 60 * 2))
    [histogram,hist_ch0,hist_ch1,hist_ch1_long] = hharp.get_T3_pulsed_g2_2DHistogram_v2(
                binsize_T3 = par_binsize_T3,
                binsize_sync=par_binsize_sync,
                range_sync=par_range_sync,
                binsize_g2=par_binsize_g2,
                range_g2=par_range_g2,
                sync_period = par_sync_period,
                )
    data = qt.Data(name='interference test_hh')
    data.add_coordinate('dt')
    data.add_coordinate('sync')
    data.add_value('counts')
    
    cr_stats = qt.Data(name = 'Statistics_cr_checks') 
    cr_stats.add_coordinate('repetition nr')
    cr_stats.add_value('lt1_cr_succes_percentage')
    cr_stats.add_value('lt1_cr_checks')
    cr_stats.add_value('lt2_cr_succes_percentage')
    cr_stats.add_value('lt2_cr_checks')
    cr_stats.add_value('tpqi_starts')
   
    save_and_plot_data(data,histogram,histogram,hist_ch0,hist_ch1,hist_ch1_long)
    qt.mend()
    optimize()

    def get_trace(self, mode='lin'):
        '''
        Send trigger to device, wait for aquiring the data,
        and read back the data from the device.
        '''
        qt.mstart()

        startfreq = self.get_start_freq(query=False)
        stopfreq = self.get_stop_freq(query=False)
        numpoints = self.get_numpoints(query=False)

        if mode=='lin':
            freqs = numpy.linspace(startfreq,stopfreq,numpoints)
        elif mode=='log':
            freqs = numpy.logspace(numpy.log10(startfreq),numpy.log10(stopfreq),numpoints)
        else:
            print 'mode needs to be either "lin" or "log"!'
            return False

        sweep_time = self.get_sweep_time(query=False)
        
        print 'sending trigger to network analyzer, and wait to finish'
        print 'estimated waiting time: %.2f s' % sweep_time
        self.send_trigger()
        qt.msleep(sweep_time)
    
        print 'readout network analyzer'
        reply = self.read()
        reply = numpy.array(reply)
    
        qt.mend()

        return (freqs, reply)

    def get_data(self, n=1, enable_continuous=False):
        """
        Reads out the nth trace

        Input:
            None

        Output:
            2D ndarray
        """
        logging.debug(__name__ + " : Get the data ")
        qt.mstart()
        sweep_time = float(self._visainstrument.query(":SENSe:SWEep:TIME?"))
        # print sweep_time
        self._visainstrument.write(":INIT:CONT OFF")
        self._visainstrument.write(":INIT:IMMediate")
        wait_time = 1.05 * sweep_time * self.get_averages(query=False)
        ##        print time.ctime()
        #        print 'waiting %f seconds'%wait_time
        qt.msleep(wait_time + 0.5)
        #        print time.ctime()
        #        print 'reading'
        try:
            datastr = self._visainstrument.query(":FETCh:SANalyzer" + str(n) + "?")
        except Exception as error:
            pass
        finally:
            datastr = self._visainstrument.query(":FETCh:SANalyzer" + str(n) + "?")

        if enable_continuous:
            self._visainstrument.write(":INIT:CONT ON")
        qt.mend()
        return np.reshape(np.array(datastr.split(","), dtype=float), (-1, 2))

	def measure_2D_AWG(self):
		'''
		x_vec is sequence in AWG
		'''
		
		if self.y_set_obj == None:
			print 'axes parameters not properly set...aborting'
			return
	
		qt.mstart()
		qt.msleep()   #if stop button was pressed by now, abort without creating data files
		
		self._prepare_measurement_dat_file(mode='2dAWG')
		self._create_dat_plots(mode='2dAWG')

		p = Progress_Bar(len(self.y_vec),name=self.dirname)
		try:
			# measurement loop
			for it in range(len(self.y_vec)):
				qt.msleep() # better done during measurement (waiting for trigger)
				self.y_set_obj(self.y_vec[it])
				self._append_data([self.y_vec[it]],trace=True,it=it)
				self._update_plots()
				p.iterate()
		#except Exception as e:
		#	print e
		
		finally:
			self._safe_plots()
			self._generate_avg_data(final=True)
			self._close_files()
		
			qt.mend()

    def measure_1d_lowpass(
        self, x_vec, coordname, set_param_func, iterations=1, comment=None, dirname=None, plotLive=True
    ):
        """
            acquire _averages traces per value in x_vec and store the time-averaged result

            x_vec - vector of values to pass to set_param_func at the start of each iteration
            coordname - friendly name of the parameter contained in x_vec
            set_param_func - parameter values are passed to this function at the start of each iteration
            comment - comment line in the data file
            dirname - data is saved in directories named <time>_spec_<dirname>
            plotLive - plot data during measurement
        """
        qt.mstart()

        if dirname == None:
            dirname = coordname
        data = qt.Data(name="spec_lp_%s" % dirname)
        if comment:
            data.add_comment(comment)
        data.add_coordinate(coordname)
        data.add_value("ch0")
        if self._numchannels == 2:
            data.add_value("ch1")
        if iterations > 1:
            data.add_coordinate("iteration")
        data.create_file()

        plot_ch0 = qt.Plot2D(data, name="waveform_ch0", coorddim=0, valdim=1, maxtraces=2)
        if self._numchannels == 2:
            plot_ch1 = qt.Plot2D(data, name="waveform_ch1", coorddim=0, valdim=2, maxtraces=2)

        set_param_func(x_vec[0])

        # measurement loop
        for i in range(iterations):
            data.new_block()
            for x in x_vec:
                set_param_func(x)
                # sleep(td)
                qt.msleep()  # better done during measurement (waiting for trigger)

                dat_x = [x]
                dat_mean = numpy.mean(self.acquire(), axis=0)
                dat = numpy.append(dat_x, dat_mean, axis=0)
                if iterations > 1:
                    dat = numpy.append(dat, [i], axis=0)
                data.add_data_point(*dat)

                plot_ch0.update()
                if self._numchannels == 2:
                    plot_ch1.update()

            plot_ch0.update()
            plot_ch0.save_png()
            plot_ch0.save_gp()
            if self._numchannels == 2:
                plot_ch1.update()
                plot_ch1.save_png()
                plot_ch1.save_gp()

	def measure_2D(self):

		if self.x_set_obj == None or self.y_set_obj == None:
			print 'axes parameters not properly set...aborting'
			return
		
		qt.mstart()
		self._prepare_measurement_dat_file(mode='2d')
		self._create_dat_plots(mode='2d')

		p = Progress_Bar(len(self.x_vec)*len(self.y_vec),name=self.dirname)
		try:
			# measurement loop
			for x in self.x_vec:
				self.x_set_obj(x)
				if self.save_dat: self.data_raw.new_block()
				for y in self.y_vec:
					qt.msleep() # better done during measurement (waiting for trigge
					self.y_set_obj(y)
					#sleep(self.tdy)
					qt.msleep() # better done during measurement (waiting for trigger)
					self._append_data([x,y],trace=False)
					self._update_plots()
					p.iterate()
		finally:
			self._safe_plots()
			self._close_files()
			qt.mend()

    def measure_2D(self):

        if self.x_set_obj == None or self.y_set_obj == None:
            print 'axes parameters not properly set...aborting'
            return
        if self.ReadoutTrace:
            raise ValueError('ReadoutTrace is currently not supported for 2D measurements')
        
        qt.mstart()
        self.mode = 2 #1: 1D, 2: 2D, 3:1D_AWG/2D_AWG
        self._prepare_measurement_file()
        #self._create_dat_plots(mode='2d')

        if self.show_progress_bar: p = Progress_Bar(len(self.x_vec)*len(self.y_vec),name=self.dirname)
        try:
            # measurement loop
            for x in self.x_vec:
                self.x_set_obj(x)
                for y in self.y_vec:
                    qt.msleep() 
                    self.y_set_obj(y)
                    qt.msleep() 
                    self._append_data()
                    if self.show_progress_bar: p.iterate()
                self._hdf_amp.next_matrix()
                self._hdf_pha.next_matrix()
        finally:
            self._end_measurement()
            qt.mend()

 def measure_2D_AWG(self):
     '''
     x_vec is sequence in AWG
     '''
     
     if self.y_set_obj == None:
         print 'axes parameters not properly set...aborting'
         return
 
     qt.mstart()
     qt.msleep()   #if stop button was pressed by now, abort without creating data files
     
     self.mode = 3 #1: 1D, 2: 2D, 3:1D_AWG/2D_AWG
     self._prepare_measurement_file()
     
     if self.show_progress_bar: 
         p = Progress_Bar(len(self.y_vec),name=self.dirname)
     try:
         # measurement loop
         for it in range(len(self.y_vec)):
             qt.msleep() # better done during measurement (waiting for trigger)
             self.y_set_obj(self.y_vec[it])
             self._append_data(iteration=it)
             if self.show_progress_bar: p.iterate()
     finally:
         self._end_measurement()
     
         qt.mend()

def main():

    initialize_hh()
    generate_sequence()

    # configure measurement
    repetitions = 3*6 
    hh_measurement_time = int(1e3 * 60 * 20 )

    qt.mstart()
    histogram=zeros((200,2000))
    for idx in arange(repetitions):
        if msvcrt.kbhit() and msvcrt.getch() == "q" : break
        print 'Starting measurement cycle', idx
        histogram += measurement_cycle(hh_measurement_time)
        print 'Finished measurement cycle', idx, 'start saving'
        data = qt.Data(name='interference'+str(idx))
        data.add_coordinate('dt')
        data.add_coordinate('sync')
        data.add_value('counts')
        save_and_plot_data(data,histogram)
        print 'Data saving cycle', idx, 'completed'
        qt.msleep(1)

        if not optimize(): break
        print 'Optimisation step', idx, ' completed'
    
    qt.mend()
    optimize()

def ht_calibrate(f_vec, p_vec):
    '''
    this example is based on 'measure_module.py'
    you will need to set up a vector of frequencies and then call the
    measurment script.

    To run the function type in the terminal:

    fv = numpy.arange(1e9,2e9,50e6)
    esr_meas.simple(fv,power,TC)
    '''


    n63 = qt.instruments['NIDAQ6363']
    pxi = qt.instruments['pxi']

    qt.mstart()

    data = qt.Data(name='herotek_calibration')
    data.add_coordinate('Frequency, NI_RFSG [GHz]')
    data.add_coordinate('Power, NI_RFSG [dBm]')
    data.add_value('Analog Input (V)')
    data.create_file()

    p2d = qt.Plot2D(data, 'bO',
    name = 'Herotek',
    clear = True,
    coorddim = 1,
    valdim = 2,
    maxtraces = 1)

    p3d = qt.Plot3D(data, name='measure3D', coorddims=(0,1), valdim=2, style='image')

    pxi.set_power(-50)
    pxi.set_frequency(1e9)
    pxi.set_status('on')
    for f in f_vec:
        pxi.set_frequency(f)
        logging.debug('frequency set: %s GHz' % (f*1e-9))
        if (msvcrt.kbhit() and (msvcrt.getch() == 'q')): break
        for p in p_vec:
            pxi.set_power(p)
            qt.msleep(0.1)
            logging.debug(__name__ + 'power set to: %s dBm' % (p))
            tot = 0
            Navg = 128
            for i in numpy.arange(0,Navg):
                tot = tot + n63.get_ai0()
            meas_v = tot/Navg
            data.add_data_point(f*1e-9,p,meas_v)
        data.new_block()
        p3d.update()



    pxi.set_status('off')
    data.close_file()
    qt.mend()

def main():

    counters_lt1.set_is_running(0)
    counters.set_is_running(0)
  
    if not debug_mode:initialize_hh()

    generate_sequence()

    # configure measurement
    repetitions = par_reps

    hh_measurement_time = int(1e3 * 60 *  par_meas_time) #ms

    qt.mstart()
    
    cr_stats = qt.Data(name = 'Statistics_cr_checks') 
    cr_stats.add_coordinate('repetition nr')
    cr_stats.add_value('lt1_cr_below threshold')
    cr_stats.add_value('lt1_cr_checks')
    cr_stats.add_value('lt2_cr_below_threshold')
    cr_stats.add_value('lt2_cr_checks')
    cr_stats.add_value('tpqi_starts')
    cr_stats.add_value('lt1_repump_cts')
    cr_stats.add_value('lt2_repump_cts')
    cr_stats.add_value('lt1_triggers_received')
    cr_stats.add_value('lt2_triggers_sent')
    cr_stats.add_value('lt1_oks_sent')
    cr_stats.add_value('lt2_oks_received')
    cr_stats.create_file()

    gated_ch0_summed=zeros(par_range_g2)
    gated_ch1_summed=zeros(par_range_g2)
    
    for idx in arange(repetitions):
        if msvcrt.kbhit():
            kb_char=msvcrt.getch()
            if kb_char == "q" : break
        
        print 'Starting measurement cycle', idx, 'current time:', time.strftime('%H:%M',time.localtime())
        [hist_ch0, hist_ch1, gated_ch0, gated_ch1] = measurement_cycle(hh_measurement_time)

#        gated_ch0_summed += gated_ch0
#        gated_ch1_summed += gated_ch1
        print 'Finished measurement cycle', idx, 'start saving'
        
        print_save_cr_check_info(cr_stats,idx)

        data = qt.Data(name='PLU_calibration'+"_"+str(idx))
        data.add_coordinate('dt')
        data.add_value('counts')
        save_and_plot_data(data,hist_ch0, hist_ch1, gated_ch0, gated_ch1,gated_ch0_summed,gated_ch1_summed)
        print 'Data saving cycle', idx, 'completed'
        qt.msleep(1)

    cr_stats.close_file()    
    qt.mend()
    end_measuring()

def main():

    generate_sequence()
    awg.set_runmode("SEQ")
    awg.start()
    while awg.get_state() != "Waiting for trigger":
        qt.msleep(1)

    repetitions = par_reps
    hh_measurement_time = int(1e3 * 60 * par_meas_time)  # ms

    qt.mstart()

    cr_stats = qt.Data(name="Statistics_cr_checks")
    cr_stats.add_coordinate("repetition nr")
    cr_stats.add_value("lt1_cr_below threshold")
    cr_stats.add_value("lt1_cr_checks")
    cr_stats.add_value("lt2_cr_below_threshold")
    cr_stats.add_value("lt2_cr_checks")
    cr_stats.add_value("tpqi_starts")
    cr_stats.add_value("lt1_repump_cts")
    cr_stats.add_value("lt2_repump_cts")
    cr_stats.add_value("lt1_triggers_received")
    cr_stats.add_value("lt2_triggers_sent")
    cr_stats.add_value("lt1_oks_sent")
    cr_stats.add_value("lt2_oks_received")
    cr_stats.create_file()

    for idx in arange(repetitions):

        if msvcrt.kbhit():
            kb_char = msvcrt.getch()
            if kb_char == "q":
                break

        print "Starting measurement cycle", idx, "current time:", time.strftime("%H:%M", time.localtime())
        measurement_cycle(hh_measurement_time)

        print_save_cr_check_info(cr_stats, idx)

        if not debug_mode:
            histogram_summed += histogram
            hist_roi_summed += hist_roi
        print "Finished measurement cycle", idx, "start saving"

        data = qt.Data(name="interference" + "_" + str(idx))
        data.add_coordinate("dt")
        data.add_coordinate("sync")
        data.add_value("counts")
        save_and_plot_data(
            data, histogram, histogram_summed, hist_ch0, hist_ch1, hist_ch1_long, hist_roi, hist_roi_summed
        )
        print "Data saving cycle", idx, "completed"
        qt.msleep(1)

    cr_stats.close_file()
    qt.mend()
    end_measuring()

def example3(x_vec=numpy.linspace(0,10,10), y_vec=numpy.linspace(0,10,50)):
    '''
    To run the function type in the terminal:
   
    measure_module.example3()
    '''

    qt.mstart()

    data = qt.Data(name='testmeasurement')
    data.add_coordinate('x')
    data.add_coordinate('y')
    data.add_value('z1')
    data.add_value('z2')
    data.add_value('z3')
    data.create_file()

    plot2d_1 = qt.Plot2D(data, name='2D_1', coorddim=1, valdim=2)

    plot2d_2 = qt.Plot2D(data, name='2D_2', coorddim=1, valdim=2, maxtraces=1)

    plot2d_3 = qt.Plot2D(data, name='2D_3', coorddim=1, valdim=2, maxtraces=1)
    plot2d_3.add_data(data, coorddim=1, valdim=3, maxtraces=1)
    plot2d_3.add_data(data, coorddim=1, valdim=4, maxtraces=1)

    plot2d_4 = qt.Plot2D(data, name='2D_4', coorddim=1, valdim=2, mintime=0.3)

    plot2d_5 = qt.Plot2D(data, name='2D_5', coorddim=1, valdim=2, autoupdate=False)

    plot3d_1 = qt.Plot3D(data, name='3D_1', style='image')

    plot3d_2 = qt.Plot3D(data, name='3D_2', style='image', coorddims=(1,0), valdim=4)

    for x in x_vec:
        for y in y_vec:

            z1 = numpy.sin(x+y)
            z2 = numpy.cos(x+y)
            z3 = numpy.sin(x+2*y)

            data.add_data_point(x, y, z1, z2, z3)

            if z1>0:
                plot2d_5.update()

            qt.msleep(0.1)
        data.new_block()

    plot2d_1.save_png()
    plot2d_1.save_gp()

    plot3d_2.save_png()
    plot3d_2.save_gp()

    data.close_file()
    qt.mend()

 def run(self):
     qt.mstart()
     self.Fire()
     qt.msleep(0.1)
     while not self.buttons[8]:
         print "=============================="
         self.Fire()
         qt.msleep(0.1)
     qt.mend()
     print "So long, and thanks for all the fish!"

    def measure_1D(self):
        '''
        measure method to record a single (averaged) VNA trace, S11 or S21 according to the setting on the VNA
        '''
        self._scan_1D = True
        self._scan_2D = False
        self._scan_3D = False

        if not self.dirname:
            self.dirname = 'VNA_tracedata'
        self._file_name = self.dirname.replace(' ', '').replace(',','_')
        if self.exp_name:
            self._file_name += '_' + self.exp_name
        self._prepare_measurement_vna()
        self._prepare_measurement_file()

        """opens qviewkit to plot measurement, amp and pha are opened by default"""
        if self.open_qviewkit:
            qviewkit.plot(self._data_file.get_filepath(), datasets=['amplitude', 'phase'])
        if self._fit_resonator:
            self._resonator = resonator(self._data_file.get_filepath())

        print 'recording trace...'
        sys.stdout.flush()

        qt.mstart()
        self.vna.avg_clear()
        if self.vna.get_averages() == 1 or self.vna.get_Average() == False:   #no averaging
            self._p = Progress_Bar(1,self.dirname,self.vna.get_sweeptime())
            qt.msleep(self.vna.get_sweeptime())      #wait single sweep
            self._p.iterate()
        else:   #with averaging
            self._p = Progress_Bar(self.vna.get_averages(),self.dirname,self.vna.get_sweeptime())
            if "avg_status" in self.vna.get_function_names():
                for a in range(self.vna.get_averages()):
                    while self.vna.avg_status() <= a:
                        qt.msleep(.2) #maybe one would like to adjust this at a later point
                    self._p.iterate()
            else: #old style
                for a in range(self.vna.get_averages()):
                    qt.msleep(self.vna.get_sweeptime())      #wait single sweep time
                    self._p.iterate()

        data_amp, data_pha = self.vna.get_tracedata()
        data_real, data_imag = self.vna.get_tracedata('RealImag')

        self._data_amp.append(data_amp)
        self._data_pha.append(data_pha)
        self._data_real.append(data_real)
        self._data_imag.append(data_imag)
        if self._fit_resonator:
            self._do_fit_resonator()

        qt.mend()
        self._end_measurement()