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

def meas_BW(min_pos, max_pos, steps, name = 'beamwaist'):


#generate list of steps
    x_list = numpy.linspace(min_pos, max_pos, steps)

    ins_xps = qt.instruments['xps']
    ins_fm = qt.instruments['fm']


    # create data object
    qt.mstart()

    qt.msleep(0.2)


    d = qt.Data(name='BeamWaist')
    d.add_coordinate('displacement (mm)')
    d.add_value('power')
    d.create_file()
    filename=d.get_filepath()[:-4]

    plot2d = qt.Plot2D(d, name=name)
    stop_scan = False
    result = numpy.zeros(steps)
    for i,cur_x in enumerate(x_list):

        if (msvcrt.kbhit() and (msvcrt.getch() == 'q')): stop_scan=True
        ins_xps.set_abs_positionZ(float(-1*cur_x))

        qt.msleep(0.05)
        result[i] = ins_fm.get_power()
        d.add_data_point(cur_x, result[i])

        if stop_scan: break


    ins_xps.set_abs_positionZ(-1*min_pos)
    i_max = result.tolist().index(max(result))
    i_min = result.tolist().index(min(result))

    print 'result imax is: %s' % result[i_max]
    knife_fit = fit.fit1d(x_list, result,fit_knife_simple, result[i_max],
                    0, 2, result[i_min], do_print=False,ret=True)
    if type(knife_fit) != dict:
                print 'fit failed!'
    else:
        print 'best fit params are: A: %.03f x0: %.03f w: %.03f b: %.03f' % (
        knife_fit['params'][0], knife_fit['params'][1], knife_fit['params'][2],
        knife_fit['params'][3])
    plot2d.set_plottitle('Beam Waist: %.03f +- %.03f' % (knife_fit['params'][2], knife_fit['error'][2]))
    d.close_file()
    plot2d.save_png(filename+'.png')

    qt.mend()

def main():

    initialize_hh()
    generate_sequence()

    # configure measurement
    repetitions = 100 
    hh_measurement_time = int(1e3 * 60 * 15) #ms

    qt.mstart()

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


    #histogram=zeros((par_range_sync,par_range_g2))
    histogram_summed=zeros((par_range_sync,par_range_g2))
    for idx in arange(repetitions):
        if msvcrt.kbhit() and msvcrt.getch() == "q" : break

        print 'Starting measurement cycle', idx
        [histogram,hist_ch0,hist_ch1,hist_ch1_long] = measurement_cycle(hh_measurement_time)
        print_save_cr_check_info(cr_stats,idx)    

        
        print shape(histogram)
        histogram_summed += histogram
        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)
        print 'Data saving cycle', idx, 'completed'
        qt.msleep(1)

        #if not optimize(): break
        print 'Optimisation step', idx, ' completed'

    cr_stats.close_file()
    qt.mend()

def main():

    initialize_hh()
    generate_sequence()

    # configure measurement
    repetitions = 100
    hh_measurement_time = int(1e3 * 60 * 15)  # ms

    qt.mstart()

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

    histogram_summed = zeros((par_range_sync, par_range_g2))
    for idx in arange(repetitions):
        if msvcrt.kbhit() and msvcrt.getch() == "q":
            break

        print "Starting measurement cycle", idx, "current time:", time.strftime("%H:%M", time.localtime())
        [histogram, hist_ch0, hist_ch1, hist_ch1_long] = measurement_cycle(hh_measurement_time)
        print_save_cr_check_info(cr_stats, idx)

        print shape(histogram)
        histogram_summed += histogram
        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)
        print "Data saving cycle", idx, "completed"
        qt.msleep(1)

        if not optimize():
            break
        print "Optimisation step", idx, " completed"

    cr_stats.close_file()
    qt.mend()

def simple(s_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:

    sv = numpy.arange(0,300000,1000)
    esr_meas.simple(sv)
    '''


    st0 = qt.instruments['Standa0']





    qt.mstart()

    data = qt.Data(name='hwp_sweep')
    data.add_coordinate('Step Position')
    data.add_value('Counts')
    data.create_file()
    filename=data.get_filepath()[:-4]

    plot2d_1 = qt.Plot2D(data, name='measure2D', valdim=1)


    for s in s_vec:
        if (msvcrt.kbhit() and (msvcrt.getch() == 'q')): break
        st0.move(s)
        logging.debug('step set: %s' % (s))
        n = 0
        qt.msleep(0.2)
        while n < 50:
            cur_pos = st0.get_position()
            if cur_pos == s:
                break
            else:
                n = n + 1
                qt.msleep(0.5)

        qt.msleep(0.5)
        ni63.get('ctr0')
        data.add_data_point(s,counts)



    plot2d_1.save_png(filename+'.png')
    data.close_file()
    qt.mend()

def simple(t_maximum, meas_period):

    # This example will monitor the SNSPD cooldown for a period of up to
    # t_maximum, which is measured in HOURS.



    ls211 = qt.instruments['ls211']
    snspd = qt.instruments['snspd']

    # meas_period is the measurement period denoted in seconds.





    qt.mstart()

    data = qt.Data(name='snspd_cooldown_monitor')
    data.add_coordinate('Measurement Index')
    data.add_value('Temperature')
    data.add_value('Channel 0 Voltage')
    data.add_value('Channel 1 Voltage')
    data.create_file()
    filename=data.get_filepath()[:-4]


    plot2d_1 = qt.Plot2D(data, name='measureSNSPDT', valdim=1)
    plot2d_2 = qt.Plot2D(data, name='measureSNSPDVs', valdim=2)
    plot2d_2.add_data(data, valdim=3)
    meas_idx = 0

    # Set bias on detectors
    snspd.set_bias0(0.2)
    snspd.set_bias1(0.2)
    while True:
        if (meas_idx > t_maximum*3600/15): break
        if (msvcrt.kbhit() and (msvcrt.getch() == 'q')): break
        currentT = ls211.get_temperature()
        currentV0 = snspd.get_vmeas0()
        currentV1 = snspd.get_vmeas1()

        qt.msleep(meas_period)
        data.add_data_point(meas_idx,currentT,currentV0,currentV1)
        meas_idx = meas_idx + 1



    plot2d_1.set_plottitle('SNSPD cooldown, measurement period %s seconds, measured for %s seconds total' % (meas_period, meas_period*meas_idx))

    plot2d_1.save_png(filename+'.png')
    data.close_file()
    qt.mend()

def main():

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


    histogram_summed=zeros(65536)
    histogram=zeros(65536)
    for idx in arange(repetitions):
        if msvcrt.kbhit() and msvcrt.getch() == "q" : break
        
        print 'Starting measurement cycle', idx, 'current time:', time.strftime('%H:%M',time.localtime())
        histogram = measurement_cycle(hh_measurement_time)
        print_save_cr_check_info(cr_stats,idx)    

        print shape(histogram)
        histogram_summed += histogram
        print 'Finished measurement cycle', idx, 'start saving'
        
        data = qt.Data(name='antibunching'+str(idx))
        data.add_coordinate('dt')
        data.add_value('counts')
        
        save_and_plot_data(data,histogram,histogram_summed)
        print 'Data saving cycle', idx, 'completed'
        qt.msleep(1)

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

    cr_stats.close_file()
    qt.mend()