def trigger_average_count_times(self, count=None, autoscale_after_first_sweep=False):
        '''
        Calls single() average_count (or count, if specified) times.

        Input:
            None

        Output:
            None
        '''

        t0 = time.time()
        t1 = t0
        for i in range(self.get_average_count() if count==None else count):
          # measure the time it took to complete the loop
          t0 = t1
          t1 = time.time()
          
          self.single(block_until_done = False)

          if i>0:
            # sleep until the sweep is almost done
            sleeping = np.max(( 0., (t1 - t0) - 10. ))
            logging.debug('Sleeping %.2e seconds before asking for OPC.' % sleeping)
            qt.msleep(sleeping)

          self.block_until_operation_complete()

          if i==0 and autoscale_after_first_sweep:
            for j in range(4): self.autoscale(1+j)

    def power_and_mw_ok(self):
        ret = True
        max_E_power = self.ins_E_aom.get_cal_a()
        max_A_power = self.ins_A_aom.get_cal_a()
        if (
            (max_E_power < self.par["Ex_CR_amplitude"])
            or (max_E_power < self.par["Ex_SP_amplitude"])
            or (max_E_power < self.par["Ex_RO_amplitude"])
        ):
            print "Trying to set too large value for E laser, quiting!"
            ret = False
        if (
            (max_A_power < self.par["A_CR_amplitude"])
            or (max_A_power < self.par["A_SP_amplitude"])
            or (max_A_power < self.par["A_RO_amplitude"])
        ):
            print "Trying to set too large value for A laser, quiting"
            ret = False
        if self.mwpower > 0:
            print "MW power > 0 dBm, are you sure you want to continue? Press q to quit, c to continue."
            idx = 0
            max_idx = 5
            kb_hit = None
            while (idx < max_idx) and kb_hit == None:
                kb_hit = msvcrt.getch()
                if kb_hit == "q":
                    ret = False
                if kb_hit == "c":
                    ret = True
                qt.msleep(1)
                idx += 1

        return ret

def sideband(center_freq,sideband_freq,marker_value,markernum,sideband='up'):
    center_freq = center_freq*1E9
    sideband_freq = sideband_freq*1E9
    up_side = center_freq + sideband_freq
    down_side = center_freq - sideband_freq
    test = False    
    
    while (test == False):
        marker_center = np.abs(marker_value - center_freq)

        if (sideband == 'up'):
            marker_sideband = np.abs(marker_value - up_side)
            if (marker_center > marker_sideband):
                test = True
            else:     
                MXA.next_peak_right()
                qt.msleep(0.1)
                marker_value = MXA.marker_X_value()
        
        if (sideband == 'down'):
            marker_sideband = np.abs(marker_value - down_side)
            if (marker_center > marker_sideband):
                test = True
            else:             
                MXA.next_peak_left()
                qt.msleep(0.1)
                marker_value = MXA.marker_X_value()

    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 calibrate_MBI_fidelity_RO_pulses(name):
    m = pulsar_msmt.ElectronRabi('MBI_fidelity_RO_pulses_'+name)
    
    m.params.from_dict(qt.cfgman['protocols']['AdwinSSRO'])
    m.params.from_dict(qt.cfgman['protocols']['AdwinSSRO+espin'])
    funcs.prepare(m)

    m.params['pts'] = 21
    pts = m.params['pts']
    m.params['repetitions'] = 5000

    m.params['MBI_calibration_RO_pulse_duration'] = 8.3e-6
    m.params['MBI_calibration_RO_pulse_amplitude_sweep_vals'] = np.linspace(0.002,0.007,pts)
    m.params['MBI_calibration_RO_pulse_mod_frqs'] = \
        m.params['ms-1_cntr_frq'] - m.params['mw_frq'] + \
        np.array([-1,0,+1]) * m.params['N_HF_frq']

    m.params['MW_pulse_durations'] =  np.ones(pts) * m.params['MBI_calibration_RO_pulse_duration']  
    m.params['MW_pulse_amplitudes'] = m.params['MBI_calibration_RO_pulse_amplitude_sweep_vals']

    m.params['sweep_name'] = 'Pulse amplitudes (V)'
    m.params['sweep_pts'] = m.params['MW_pulse_amplitudes']
    m.params['sequence_wait_time'] = \
            int(np.ceil(np.max(m.params['MW_pulse_durations'])*1e6)+10)

    for i,f in enumerate(m.params['MBI_calibration_RO_pulse_mod_frqs']):
        m.params['MW_pulse_frequency'] = f
        m.autoconfig()
        m.generate_sequence(upload=True)
        m.run()
        m.save('line-{}'.format(i))
        m.stop_sequence()
        qt.msleep(1)

    m.finish()

def print_save_cr_check_info(cr_stats,rep_nr):
 
    qt.msleep(1)

    lt1_cnts_below = adwin_lt1.remote_tpqi_control_get_cr_below_threshold_events()
    lt1_cr_checks = adwin_lt1.remote_tpqi_control_get_noof_cr_checks()
    lt2_cnts_below = adwin_lt2.remote_tpqi_control_get_cr_below_threshold_events()
    lt2_cr_checks = adwin_lt2.remote_tpqi_control_get_noof_cr_checks()
    TPQI_starts = adwin_lt2.remote_tpqi_control_get_noof_tpqi_starts()
    
    
    lt1_repump_cts= adwin_lt1.remote_tpqi_control_get_repump_counts()
    lt2_repump_cts= adwin_lt2.remote_tpqi_control_get_repump_counts()
    lt1_triggers_received= adwin_lt1.remote_tpqi_control_get_noof_trigger()
    lt2_triggers_sent= adwin_lt2.remote_tpqi_control_get_noof_triggers_sent()
    lt1_oks_sent = adwin_lt1.remote_tpqi_control_get_noof_oks_sent()
    lt2_oks_received = adwin_lt2.remote_tpqi_control_get_noof_lt1_oks()

    
    lt1_succes =100.*( 1.-(float(lt1_cnts_below)/lt1_cr_checks))
    lt2_succes = 100.*(1.-(float(lt2_cnts_below)/lt2_cr_checks))

    print 'lt1 : CR succes_percentage: ', lt1_succes
    print 'lt1 : CR checks: ', lt1_cr_checks
    print 'lt2 : CR succes_percentage: ', lt2_succes
    print 'lt2 : CR checks: ', lt2_cr_checks
    print 'tpqi starts: ', TPQI_starts
    print ' adwin check-trigger difference:', lt2_triggers_sent - lt1_triggers_received
    print ' adwin ok-trigger difference: ', lt1_oks_sent - lt2_oks_received
    print ''
    cr_stats.add_data_point(rep_nr,lt1_succes,lt1_cr_checks,
                            lt2_succes,lt2_cr_checks,TPQI_starts,lt1_repump_cts,
                            lt2_repump_cts,lt1_triggers_received,lt2_triggers_sent,
                            lt1_oks_sent,lt2_oks_received)

def power_and_mw_ok():
    ret = True
    max_E_power = ins_E_aom.get_cal_a()
    max_A_power = ins_A_aom.get_cal_a()
    if (max_E_power < par['Ex_CR_amplitude']) or \
            (max_E_power < par['Ex_SP_amplitude']) or \
            (max_E_power < par['Ex_RO_amplitude']):
        print 'Trying to set too large value for E laser, quiting!'
        ret = False    
    if (max_A_power < par['A_CR_amplitude']) or \
            (max_A_power < par['A_SP_amplitude']) or \
            (max_A_power < par['A_RO_amplitude']):
        print 'Trying to set too large value for A laser, quiting'
        ret = False
    if mwpower > 0:
        print 'MW power > 0 dBm, are you sure you want to continue? Press q to quit, c to continue.'
        idx = 0
        max_idx = 5
        kb_hit = None
        while (idx<max_idx) and kb_hit == None:
            kb_hit = msvcrt.getch()
            if kb_hit == 'q':
                ret = False
            if kb_hit == 'c':
                ret = True
            qt.msleep(1)
            idx += 1
       
    return ret

    def measure(self, measurement_time, noof_reps = 1E6, RAW = False):
        
        today = time.strftime('%Y%m%d')
        curr_time = time.strftime('%H%M%S')
        self.save_folder = os.path.join(r'D:\measuring\data', 
                today, curr_time+'_HydraHarp_Live')
                
        if not(os.path.exists(os.path.split(self.save_folder)[0])):
            os.mkdir(os.path.split(self.save_folder)[0])
        if not(os.path.exists(self.save_folder)):
            os.mkdir(self.save_folder)
        
        self.noof_reps = noof_reps
        sync_separation = self.sync_rep_rate             
        self.generate_sequence()

        hharp.start_T3_mode()
        hharp.calibrate()
        hharp.set_Binning(8)
        hharp.StartMeas(int(measurement_time*1e3))
        qt.msleep(0.5)
        awg.start()
        accumulated_data = self.get_T3_pulsed_events(
                sync_separation, start_ch0 = 0, start_ch1 = 0,
                max_pulses = 2, save_raw = RAW, 
                raw_max_len = 1E6, sleep_time = 1000E-3)
        awg.stop()

        dts = self.process_accumulated_data(accumulated_data, rawfile = RAW)

        return accumulated_data, dts

    def start_measurement(self,generate_sequence,pulse_dict,lt1=False,ssro_dict={},):
        # Prepare MW source and counters
        print 'Setting MW freq to '
        print (self.f_drive*1e-9)

        self.microwaves.set_iq('on')
        self.microwaves.set_frequency(self.f_drive)
        self.microwaves.set_pulm('on')
        self.microwaves.set_power(self.mwpower)
        self.counters.set_is_running(False)
        
        #Generate sequence and send to AWG
        sequence = generate_sequence(sweep_param,pulse_dict,lt1)

        self.par['RO_repetitions'] =               int(len(self.sweep_param)*self.par['reps_per_datapoint'])
        self.par['sweep_length'] =                 int(len(self.sweep_param))
        self.par['sequence_wait_time'] =           int(np.ceil(sequence["max_seq_time"]/1e3)+2)
        
        self.par['min_sweep_par'] =                sweep_param.min()
        self.par['max_sweep_par'] =                sweep_param.max()
        
        awg.set_runmode('SEQ')
        awg.start()  
        while awg.get_state() != 'Waiting for trigger':
            qt.msleep(1)

        self.microwaves.set_status('on')
        qt.msleep(1)

        self.spin_control(lt1,ssro_dict=ssro_dict)
        self.end_measurement()

 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 get2trace(self,trace1,trace2):
        '''
        reades 2 traces from znb

        Input:

            trace (string)

        Output:

            None
        '''
        logging.info(__name__ + ' : start to measure and wait till it is finished')


        while self._visainstrument.query('*ESR?') != '1':
            qt.msleep(0.1)
        else:
            self._visainstrument.write('calc:parameter:sel  "%s"' %(trace1))
            dstring=self._visainstrument.query('calculate:Data? Sdata')
            dstringclean=dstring.split(';')[0]
            real1,im1= np.reshape(np.array(dstringclean.split(','),dtype=float),(-1,2)).T

            self._visainstrument.write('calc:parameter:sel  "%s"' %(trace2))
            dstring=self._visainstrument.query('calculate:Data? Sdata')
            dstringclean=dstring.split(';')[0]
            real2,im2= np.reshape(np.array(dstringclean.split(','),dtype=float),(-1,2)).T

            return real1+im1*1j,real2+im2*1j

    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 scan_to_voltage(self, voltage, pts=101, dwell_time=0.03):
     print 'scan red laser to start voltage ...',
     #print 'current voltage: ' + str(self.get_laser_voltage())
     for v in np.linspace(self.get_laser_voltage(), voltage, pts):
         self.set_laser_voltage(v)
         qt.msleep(dwell_time)
     print 'done.'

    def iv(self, channel, start=0, stop=3, step=0.2, delay=0.2):
        '''
        Take an IV on channel chan:
        - start / stop in V
        - steps
        '''

        biaspar = 'bias%d' % channel
        vmeaspar = 'vmeas%d' % channel

        r = self.get_resistance() / 1000.0 # Not sure why this is dividing. Bug?
        n = (int(abs(stop - start) / step)) + 1
        data = qt.Data(name='iv')
        data.add_coordinate('Vbias', units='V')
        data.add_value('Vmeas', units='V')
        data.create_file()
        for i in range(n):
            v_out = start + i * step
            current = v_out/r
            self.set(biaspar, v_out, check=False)
            qt.msleep(delay)
            v_meas = self.get(vmeaspar)
            print 'v_out, current_out, v_meas: %f, %f, %f' %(v_out, current, v_meas)
            data.add_data_point(v_out, v_meas)

        self.set(biaspar, 0)
        qt.plot(data, name='iv', clear=True)
        return data

	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 print_save_cr_check_info(cr_stats,rep_nr):
 
    qt.msleep(1)

    adpars_lt1 = adwin_lt1.get_remote_tpqi_control_var('par')
    adpars_lt2 = adwin_lt2.get_remote_tpqi_control_var('par')

    lt1_cnts_below = adpars_lt1[1][1]
    lt1_cr_checks = adpars_lt1[0][1]
    lt2_cnts_below = adpars_lt2[3][1]
    lt2_cr_checks = adpars_lt2[2][1]
    TPQI_starts = adpars_lt2[15][1]
       
    lt1_repump_cts = adpars_lt1[8][1]
    lt1_triggers_received= adpars_lt1[11][1]
    lt1_oks_sent = adpars_lt1[7][1]
    lt2_repump_cts= adpars_lt2[0][1]
    lt2_triggers_sent= adpars_lt2[10][1]
    lt2_oks_received = adpars_lt2[17][1]
    
    #print 'lt1 : CR below threshold: ', lt1_cnts_below
    #print 'lt1 : CR checks: ', lt1_cr_checks
    #print 'lt2 : CR below threshold: ', lt2_cnts_below
    #print 'lt2 : CR checks: ', lt2_cr_checks
    print rep_nr, ': TPQI starts during the cycle = ', TPQI_starts
    #print ' adwin check-trigger difference:', lt2_triggers_sent - lt1_triggers_received
    #print ' adwin ok-trigger difference: ', lt1_oks_sent - lt2_oks_received
    #print ''
    
    cr_stats.add_data_point(rep_nr,lt1_cnts_below,lt1_cr_checks,
                            lt2_cnts_below,lt2_cr_checks,TPQI_starts,lt1_repump_cts,
                            lt2_repump_cts,lt1_triggers_received,lt2_triggers_sent,
                            lt1_oks_sent,lt2_oks_received)

	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 setup(self, wait_for_awg=True, mw=True):
        ssro.IntegratedSSRO.setup(self)
        
        if mw:
            self.mwsrc.set_iq('on')
            self.mwsrc.set_pulm('on')
            self.mwsrc.set_frequency(self.params['mw_frq'])
            self.mwsrc.set_power(self.params['mw_power'])
            self.mwsrc.set_status('on')
        
        self.awg.set_runmode('SEQ')
        self.awg.start()
        
        if wait_for_awg:
            i=0
            awg_ready = False
            while not awg_ready and i<40:
                if (msvcrt.kbhit() and (msvcrt.getch() == 'x')):
                    raise Exception('User abort while waiting for AWG')

                try:
                    if self.awg.get_state() == 'Waiting for trigger':
                        awg_ready = True
                except:
                    print 'waiting for awg: usually means awg is still busy and doesnt respond'
                    print 'waiting', i, '/ 40'
                    i=i+1
                
                qt.msleep(0.5)
            
            if not awg_ready: 
                raise Exception('AWG not ready')

    def start_measurement(self,generate_sequence,pulse_dict,lt1=False,ssro_dict={},send_sequence_AWG=True):
        # Prepare MW source and counters
        print 'Setting MW freq to '
        print (self.f_drive*1e-9)

        self.microwaves.set_iq('on')
        self.microwaves.set_frequency(self.f_drive)
        self.microwaves.set_pulm('on')
        self.microwaves.set_power(self.mwpower)
        self.counters.set_is_running(False)
        
        #Generate sequence and send to AWG
        if send_sequence_AWG:
            sequence = generate_sequence(self.par['sweep_par'],pulse_dict,lt1)
        else:
            sequence=self.sequence
        #sequence["max_seq_time"]=100000
        self.par['RO_repetitions'] =               int(len(self.par['sweep_par'])*self.par['reps_per_datapoint'])
        self.par['sweep_length'] =                 int(len(self.par['sweep_par']))
        print 'seq max time in start meas'
        print int(np.ceil(sequence["max_seq_time"])+10)
        self.par['sequence_wait_time'] =           int(np.ceil(sequence["max_seq_time"])+10)
        
        
        self.awg.set_runmode('SEQ')
        self.awg.start()  
        while self.awg.get_state() != 'Waiting for trigger':
            qt.msleep(1)

        self.microwaves.set_status('on')
        qt.msleep(1)

        self.spin_control(lt1,ssro_dict=ssro_dict)
        self.end_measurement()

def optimize():
    awg.set_ch4_marker1_low(0)
    adwin_lt1.set_simple_counting()
    adwin_lt2.set_simple_counting()
    ins_green_aom_lt1.set_power(par_opt_lt1_green_power)
    ins_green_aom_lt2.set_power(par_opt_lt2_green_power)
    
    print 'Simple counting'
    qt.msleep(5)

    if  (adwin_lt1.get_countrates()[1] < par_opt_min_cnts_lt1):
        print 'optimizing lt1: countrate', adwin_lt1.get_countrates()[1]
        ins_optimiz0r_lt1.optimize(cnt=2)
    if  (adwin_lt2.get_countrates()[0] < par_opt_min_cnts_lt2):
        print 'optimizing lt2: countrate', adwin_lt2.get_countrates()[0]
        ins_optimiz0r_lt2.optimize(cnt=1)  
    
    #check for bad suppression
    awg.set_ch4_marker1_low(0.3)
    if adwin_lt1.get_countrates()[0] > par_zpl_cts_break \ 
        or adwin_lt2.get_countrates()[1] > par_zpl_cts_break:
            awg.set_ch4_marker1_low(0)
            return False
    
    awg.set_ch4_marker1_low(0)
    ins_green_aom_lt1.set_power(0)
    ins_green_aom_lt2.set_power(0)
    
    print 'Optimisation step completed'
    return True