def calibrate_theta_pulse(name, multiplicity=1, debug=False, mw2=False, **kw): m = pulsar_msmt.GeneralPiCalibrationSingleElement(name) espin_funcs.prepare(m) pulse_shape = m.params['pulse_shape'] pts = 25 m.params['pts'] = pts if pulse_shape == 'Square': raise KeyError('This hasnt been written for square pulses yet!') ps.X_pulse( m) #### update the pulse params depending on the chosen pulse shape. m.params['repetitions'] = 2500 m.params['MW_pulse_amplitudes'] = np.linspace(0.3, m.params['Hermite_pi_amp'], pts) m.params['multiplicity'] = np.ones(pts) * multiplicity m.params['delay_reps'] = 0 # for the autoanalysis m.params['sweep_name'] = 'MW amplitude (V)' m.params['sweep_pts'] = m.params['MW_pulse_amplitudes'] m.params['wait_for_AWG_done'] = 1 m.MW_pi = pulse.cp(ps.X_pulse(m), phase=0) espin_funcs.finish(m, debug=debug, pulse_pi=m.MW_pi)
def sweep_number_pi_pulses(name, debug=False, pts=30): m = pulsar_msmt.GeneralPiCalibration(name) espin_funcs.prepare(m) ps.X_pulse( m) #### update the pulse params depending on the chosen pulse shape. m.params['multiplicity'] = np.arange(1, 1 + 2 * pts, 2) m.params['pulse_type'] = 'Hermite quantum memory' # pts = 10 m.params['pts'] = pts # m.params['repetitions'] = 3000 if multiplicity == 1 else 5000 m.params['repetitions'] = 1000 #if multiplicity == 1 else 5000 # Pulse settings m.params['MW_duration'] = m.params['fast_pi_duration'] m.params['MW_pulse_amplitudes'] = np.ones(pts) * m.params[ 'fast_pi_amp'] #XXXXX -0.05, 0.05 m.params['delay_reps'] = 20 # for the autoanalysis m.params['sweep_name'] = 'Number of pulses' m.params['sweep_pts'] = m.params['multiplicity'] m.params['wait_for_AWG_done'] = 1 # Add Hermite X pulse m.MW_pi = ps.X_pulse(m) espin_funcs.finish(m, debug=debug, pulse_pi=m.MW_pi)
def _create_mw_pulses(msmt,Gate): Gate.mw_X = ps.X_pulse(msmt) Gate.mw_pi2 = ps.Xpi2_pulse(msmt) Gate.mw_mpi2 = ps.mXpi2_pulse(msmt) Gate.mw_first_pulse = pulse.cp(ps.Xpi2_pulse(msmt),amplitude = msmt.params['mw_first_pulse_amp'],length = msmt.params['mw_first_pulse_length'],phase = msmt.params['mw_first_pulse_phase']) Gate.mw_second_pulse = pulse.cp(ps.X_pulse(msmt),amplitude = msmt.params['mw_second_pulse_amp'],length = msmt.params['mw_second_pulse_length']) if hasattr(Gate,'first_pulse_is_pi2') and hasattr(Gate,'first_mw_pulse_phase'): if Gate.first_pulse_is_pi2: Gate.mw_first_pulse = pulse.cp(Gate.mw_pi2, phase = Gate.first_mw_pulse_phase) elif hasattr(Gate,'first_pulse_is_pi2'): if Gate.first_pulse_is_pi2: Gate.mw_first_pulse = pulse.cp(Gate.mw_pi2, phase = msmt.params['mw_first_pulse_phase']) if hasattr(Gate,'no_first_pulse'): if Gate.no_first_pulse: Gate.mw_first_pulse = pulse.cp(Gate.mw_X,amplitude = 0) if hasattr(Gate,'no_mw_pulse'): if Gate.no_mw_pulse: Gate.mw_first_pulse = pulse.cp(Gate.mw_X,amplitude = 0) Gate.mw_pi2 = pulse.cp(Gate.mw_X,amplitude = 0) Gate.mw_mpi2 = pulse.cp(Gate.mw_X,amplitude = 0) Gate.mw_X = pulse.cp(Gate.mw_X,amplitude = 0)
def _create_mw_pulses(msmt,Gate): Gate.mw_X = ps.X_pulse(msmt) Gate.mw_pi2 = ps.Xpi2_pulse(msmt) Gate.mw_mpi2 = ps.mXpi2_pulse(msmt) if msmt.params['do_calc_theta'] > 0 or msmt.params['general_sweep_name'] == 'sin2_theta': fit_a = msmt.params['sin2_theta_fit_a'] fit_x0 = msmt.params['sin2_theta_fit_x0'] fit_of = msmt.params['sin2_theta_fit_of'] p0 = msmt.params['sin2_theta'] msmt.params['mw_first_pulse_amp'] = fit_x0 - np.sqrt((p0-1+fit_of)/fit_a) ### calc right pulse amp from theta calibration Gate.mw_first_pulse = pulse.cp(ps.X_pulse(msmt),amplitude = msmt.params['mw_first_pulse_amp'],length = msmt.params['mw_first_pulse_length'],phase = msmt.params['mw_first_pulse_phase']) if msmt.params['first_mw_pulse_is_pi2'] > 0 and hasattr(Gate,'first_mw_pulse_phase'): Gate.mw_first_pulse = pulse.cp(Gate.mw_pi2, phase = Gate.first_mw_pulse_phase) elif msmt.params['first_mw_pulse_is_pi2']: Gate.mw_first_pulse = pulse.cp(Gate.mw_pi2, phase = msmt.params['mw_first_pulse_phase']) if hasattr(Gate,'no_first_pulse'): if Gate.no_first_pulse: Gate.mw_first_pulse = pulse.cp(Gate.mw_X,amplitude = 0) if hasattr(Gate,'no_mw_pulse') or msmt.params['do_only_opt_pi'] >0: if Gate.no_mw_pulse: Gate.mw_first_pulse = pulse.cp(Gate.mw_X,amplitude = 0) Gate.mw_pi2 = pulse.cp(Gate.mw_X,amplitude = 0) Gate.mw_mpi2 = pulse.cp(Gate.mw_X,amplitude = 0) Gate.mw_X = pulse.cp(Gate.mw_X,amplitude = 0) if msmt.params['do_only_opt_pi'] >0: Gate.mw_first_pulse = pulse.cp(Gate.mw_X,amplitude = 0) Gate.mw_pi2 = pulse.cp(Gate.mw_X,amplitude = 0) Gate.mw_mpi2 = pulse.cp(Gate.mw_X,amplitude = 0) Gate.mw_X = pulse.cp(Gate.mw_X,amplitude = 0)
def calibrate_pi_pulse(name, multiplicity=1, debug=False): m = pulsar_msmt.GeneralPiCalibrationSingleElement(name) m.params.from_dict(qt.exp_params['samples'][SAMPLE]) m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO-integrated']) m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO+espin']) m.params.from_dict(qt.exp_params['protocols']['cr_mod']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['pulses']) m.params['pulse_type'] = 'Hermite quantum memory' # m.params['pulse_type'] = 'Square quantum memory' pts = 16 m.params['pts'] = pts # m.params['repetitions'] = 3000 if multiplicity == 1 else 5000 m.params['repetitions'] = 600 if multiplicity == 1 else 1000 rng = 0.2 if multiplicity == 1 else 0.03 ### Pulse settings m.params['multiplicity'] = np.ones(pts)*multiplicity # For square pulses m.params['MW_duration'] = m.params['Hermite_pi_length'] m.params['MW_pulse_amplitudes'] = m.params['Hermite_pi_amp'] + np.linspace(-rng, rng, pts) #XXXXX -0.05, 0.05 # For hermite pulses # m.params['MW_duration'] = m.params['Hermite_fast_pi_duration'] # m.params['MW_pulse_amplitudes'] = m.params['Hermite_fast_pi_amp'] + np.linspace(-0.04, 0.02, pts) #XXXXX -0.05, 0.05 m.params['delay_reps'] = 195 ## Currently not used # m.params['mw_power'] = 20 ###put in msmt_params. # for the autoanalysis m.params['sweep_name'] = 'MW amplitude (V)' m.params['sweep_pts'] = m.params['MW_pulse_amplitudes'] m.params['wait_for_AWG_done'] = 1 # Add Hermite X pulse ps.X_pulse(m) m.MW_pi = pulse.cp(ps.X_pulse(m),phase = 0) print 'duration ', m.params['MW_duration'] print 'amp ', m.params['MW_pulse_amplitudes'][0] espin_funcs.finish(m, debug=debug, pulse_pi=m.MW_pi)
def calibrate_pi_pulse(name, multiplicity=1,RO_basis = 'Z', debug=False, mw2=False, wait_time_pulses=15000e-9, **kw): m = GeneralPiCalibrationSingleElement(name+str(multiplicity)) m.params.from_dict(qt.exp_params['samples'][SAMPLE]) m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO-integrated']) m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO+espin']) m.params.from_dict(qt.exp_params['protocols']['cr_mod']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['pulses']) pulse_shape = m.params['pulse_shape'] pts = 20 m.params['pts'] = pts ps.X_pulse(m) #### update the pulse params depending on the chosen pulse shape. m.params['repetitions'] = 1600 if multiplicity == 1 else 2000 rng = 0.15 if multiplicity == 1 else 0.04 ### comment NK: the previous parameters for MW_duration etc. were not used anywhere in the underlying measurement class. ### therefore, I removed them if mw2: m.params['MW_pulse_amplitudes'] = m.params['mw2_fast_pi_amp'] + np.linspace(-rng, rng, pts) else: m.params['MW_pulse_amplitudes'] = m.params['fast_pi_amp'] + np.linspace(-rng, rng, pts) print m.params['MW_pulse_amplitudes'] m.params['multiplicity'] = np.ones(pts)*multiplicity m.params['wait_time_pulses']=wait_time_pulses m.params['RO_basis'] = RO_basis m.params['delay_reps'] = 0 # for the autoanalysis m.params['sweep_name'] = 'MW amplitude (V)' m.params['sweep_pts'] = m.params['MW_pulse_amplitudes'] m.params['wait_for_AWG_done'] = 1 m.MW_pi=ps.X_pulse(m) m.MW_pi2=ps.Xpi2_pulse(m) # m.MW_pi = pulse.cp(ps.mw2_X_pulse(m), phase = 0) if mw2 else pulse.cp(ps.X_pulse(m), phase = 0) # m.MW_pi = pulse.cp(ps.mw2_X_pulse(m), phase = 0) if mw2 else pulse.cp(ps.X_pulse(m), phase = 0) espin_funcs.finish(m, debug=debug, pulse_pi=m.MW_pi,pulse_pi2=m.MW_pi2)
def fidelity_SSRO_0_p1(name): m = pulsar_msmt.SSRO_calibration_msp1(name) m.params.from_dict(qt.exp_params['samples'][SAMPLE]) m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO']) m.params.from_dict(qt.exp_params['protocols']['cr_mod']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO']) m.params.from_dict( qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO-integrated']) m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO+espin']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['pulses']) #m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['Magnetometry']) m.params['pts'] = 1 pts = m.params['pts'] m.params['repetitions'] = 750 m.params['Ex_SP_amplitude'] = 0 sweep_param = 'length' print m.params['pts'] X = ps.X_pulse(m) # m.autoconfig() #Redundant because executed in m.run()? Tim #m.generate_sequence() m.generate_sequence(upload=True, Pi_pulse=X) m.run() qt.msleep(2) m.save() qt.msleep(2) m.finish()
def pi_pulse_sweepdelay(name, multiplicity=1, debug=False): m = pulsar_msmt.PiCalibration_SweepDelay(name) espin_funcs.prepare(m) m.params['pulse_type'] = 'Hermite quantum memory' # m.params['pulse_type'] = 'Square quantum memory' pts = 11 m.params['pts'] = pts # m.params['repetitions'] = 3000 if multiplicity == 1 else 5000 m.params['repetitions'] = 1000 if multiplicity == 1 else 5000 # Pulse settings m.params['multiplicity'] = np.ones(pts) * multiplicity m.params['MW_duration'] = m.params['Hermite_fast_pi_duration'] m.params[ 'MW_pulse_amplitudes'] = m.params['Hermite_fast_pi_amp'] * np.ones(pts) m.params['delay_reps'] = np.linspace(1, 100, pts) m.params['mw_power'] = 20 # for the autoanalysis m.params['sweep_name'] = 'Interpulse delay (us)' m.params['sweep_pts'] = m.params['interpulse_delay'] * 1e6 m.params['wait_for_AWG_done'] = 1 # Add Hermite X pulse m.MW_pi = ps.X_pulse(m) espin_funcs.finish(m, debug=debug, pulse_pi=m.MW_pi)
def ssro_MWInit(name, multiplicity=[0], debug=False, mw2=[False], el_states=['ms0'], **kw): m = pulsar_msmt.SSRO_MWInit(name) # Import all msmst params m.params.from_dict(qt.exp_params['samples'][SAMPLE]) m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO']) m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO+espin']) m.params.from_dict(qt.exp_params['protocols']['cr_mod']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['pulses']) # MW settings pulse_shape = kw.get('pulse_shape', None) if pulse_shape == None: pulse_shape == m.params['pulse_shape'] else: m.params['pulse_shape'] = pulse_shape m.params['wait_for_AWG_done'] = 1 # m.params['sequence_wait_time'] = 20 m.params['send_AWG_start'] = 1 m.params['pts'] = 1 m.params['repetitions'] = 5000 m.params['Ex_SP_amplitude'] = 0 for mult, mw2, s in zip(multiplicity, mw2, el_states): #selecting correct parameters if s == 'msm1' and qt.current_setup == 'lt3': m.params['Hermite_pi_length'] = 144e-9 m.params['Hermite_pi_amp'] = 0.939 m.params['electron_transition'] = '_m1' m.params['mw_frq'] = 1.719319e9 - 100e3 if s == 'msm1' and qt.current_setup == 'lt4': m.params['Hermite_pi_length'] = 126e-9 m.params['Hermite_pi_amp'] = 0.844 m.params['electron_transition'] = '_m1' m.params['mw_frq'] = 1.718064e9 m.params['multiplicity'] = mult ### need to select the correct frequency m.MW_pi = pulse.cp(ps.pi_pulse_MW2(m), phase=0) if mw2 else pulse.cp( ps.X_pulse(m), phase=0) m.autoconfig() m.generate_sequence(upload=True, pulse_pi=m.MW_pi) m.setup() if not debug: print 'electron state: ' + str(s) m.run(setup=False, autoconfig=False) m.save(s) m.finish()
def electronT2_NoTriggers(name, debug=False, range_start=0e-6, range_end=1000e-6): m = pulsar_delay.ElectronT2NoTriggers(name) m.params.from_dict(qt.exp_params['samples'][SAMPLE]) m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO']) m.params.from_dict( qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO-integrated']) m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO+espin']) m.params.from_dict(qt.exp_params['protocols']['cr_mod']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['pulses']) m.params['pulse_type'] = 'Hermite' m.params['Ex_SP_amplitude'] = 0 m.params[ 'AWG_to_adwin_ttl_trigger_duration'] = 2e-6 # commenting this out gives an erro m.params['wait_for_AWG_done'] = 1 m.params['sequence_wait_time'] = 1 pts = 51 m.params['pts'] = pts m.params['repetitions'] = 500 #m.params['wait_for_AWG_done']=1 #m.params['evolution_times'] = np.linspace(0,0.25*(pts-1)*1/m.params['N_HF_frq'],pts) # range from 0 to 1000 us m.params['evolution_times'] = np.linspace(range_start, range_end, pts) # MW pulses m.params['detuning'] = 0 #-1e6 #0.5e6 X_pi2 = ps.Xpi2_pulse(m) X_pi = ps.X_pulse(m) m.params['pulse_sweep_pi2_phases1'] = np.ones(pts) * m.params[ 'X_phase'] # First pi/2 = +X # m.params['pulse_sweep_pi2_phases2'] = np.ones(pts) * (m.params['X_phase']+180 ) # Second pi/2 = mX m.params['pulse_sweep_pi2_phases2'] = np.ones(pts) * m.params['X_phase'] m.params['pulse_sweep_pi_phases'] = np.ones(pts) * m.params['X_phase'] # for the autoanalysis m.params['sweep_name'] = 'evolution time (ns)' m.params['sweep_pts'] = (m.params['evolution_times'] + 2 * m.params['Hermite_pi2_length'] + m.params['Hermite_pi_length']) * 1e9 # for the self-triggering through the delay line # m.params['self_trigger_delay'] = 500e-9 # 0.5 us # m.params['self_trigger_duration'] = 100e-9 # Start measurement m.autoconfig() m.generate_sequence(upload=True, pulse_pi2=X_pi2, pulse_pi=X_pi) if not debug: m.run(autoconfig=False) m.save() m.finish()
def calibrate_pi_pulse(name, multiplicity=1, debug=False, mw2=False, **kw): m = pulsar_msmt.GeneralPiCalibrationSingleElement(name) espin_funcs.prepare(m) pulse_shape = m.params['pulse_shape'] pts = 15 m.params['pts'] = pts ps.X_pulse( m) #### update the pulse params depending on the chosen pulse shape. m.params['repetitions'] = 1000 if multiplicity == 1 else 1000 rng = 0.1 if multiplicity == 1 else 0.06 ### comment NK: the previous parameters for MW_duration etc. were not used anywhere in the underlying measurement class. ### therefore, I removed them if mw2: m.params[ 'MW_pulse_amplitudes'] = m.params['mw2_fast_pi_amp'] + np.linspace( -rng, rng, pts) else: m.params[ 'MW_pulse_amplitudes'] = m.params['fast_pi_amp'] + np.linspace( -rng, rng, pts) # m.params['MW_pulse_amplitudes'] = np.linspace(0,0.9,pts) m.params['interpulse_delay'] = [7.5e-6] * pts m.params['AWG_controlled_readout'] = 0 m.params['multiplicity'] = np.ones(pts) * multiplicity m.params['delay_reps'] = 0 # for the autoanalysis m.params['sweep_name'] = 'MW amplitude (V)' m.params['sweep_pts'] = m.params['MW_pulse_amplitudes'] m.params['wait_for_AWG_done'] = 1 m.MW_pi = pulse.cp(ps.mw2_X_pulse(m), phase=0) if mw2 else pulse.cp( ps.X_pulse(m), phase=0) espin_funcs.finish(m, debug=debug, pulse_pi=m.MW_pi)
def _LDE_rephasing_elt(msmt,Gate,forced_wait_duration = 0,addressed_carbon=None): """waits the right amount of time after and LDE element for the electron to rephase. NOTE: after developing the purification code for several one realizes that we should distinguish between LDE 1 and LDE 2. The two elements are very different from each other. """ _create_wait_times(Gate) _create_syncs_and_triggers(msmt,Gate) e = element.Element(Gate.name, pulsar = qt.pulsar) if forced_wait_duration == 0: ### we need to add some time for the following carbon gate to this rephasing element ### this time is tau_cut and is calculated below. # TODO: generalize this to multiple carbons c = str(addressed_carbon) e_trans = msmt.params['electron_transition'] #### for concatenating LDE with a longer entangling sequence, see also purify_slave, function carbon_swap_gate: if 'ElectronDD_tau' in msmt.params.to_dict().keys(): tau = msmt.params['ElectronDD_tau'] else: tau = msmt.params['C'+c+'_Ren_tau'+e_trans][0] ps.X_pulse(msmt) # update pi pulse parameters fast_pi_duration = msmt.params['fast_pi_duration'] pulse_tau = tau - fast_pi_duration/2.0 n_wait_reps, tau_remaind = divmod(round(2*pulse_tau*1e9),1e3) if n_wait_reps %2 == 0: tau_cut = 1e-6 else: tau_cut = 1.5e-6 # LDE 2 does not need tau_cut because we do dynamic phase correction with a fixed tau_cut. if 'LDE_rephasing_2' in Gate.name: tau_cut =1e-6 #0e-6 # print e.samples() ### avg. repump time + tau_cut gives the right amount of time. wait_duration = msmt.params['average_repump_time'] + tau_cut test = pulse.cp(Gate.T, length=wait_duration,name='rephasing') test.name = 'rephase' e.add(test) else: e = element.Element(Gate.name, pulsar = qt.pulsar) test = pulse.cp(Gate.T,length=forced_wait_duration,name = 'rephase_with_known_wait') e.add(test) return e
def _create_mw_pulses(msmt,Gate): Gate.mw_X = ps.X_pulse(msmt) Gate.mw_pi2 = ps.Xpi2_pulse(msmt) Gate.mw_mpi2 = ps.mXpi2_pulse(msmt) Gate.mw_first_pulse = pulse.cp(ps.Xpi2_pulse(msmt),amplitude = msmt.params['mw_first_pulse_amp'],length = msmt.params['mw_first_pulse_length'],phase = msmt.params['mw_first_pulse_phase']) if 'first_mw_pulse_type' in msmt.params: if msmt.params['first_mw_pulse_type'] == 'pi': Gate.mw_first_pulse = pulse.cp(Gate.mw_X, phase = msmt.params['mw_first_pulse_phase']) elif msmt.params['first_mw_pulse_type'] == 'pi2': Gate.mw_first_pulse = pulse.cp(Gate.mw_pi2, phase = msmt.params['mw_first_pulse_phase']) elif msmt.params['first_mw_pulse_type'] == 'none': Gate.mw_first_pulse = pulse.cp(Gate.mw_X,amplitude = 0) elif msmt.params['first_mw_pulse_type'] == 'square': msmt.params['pulse_shape'] = 'Square' Gate.mw_first_pulse = ps.X_pulse(msmt) msmt.params['pulse_shape'] = 'Hermite' else: raise ValueError("What are you doing first_mw_pulse_type does not make sense.") else: if hasattr(Gate,'first_pulse_is_pi2') and hasattr(Gate,'first_mw_pulse_phase'): if Gate.first_pulse_is_pi2: Gate.mw_first_pulse = pulse.cp(Gate.mw_pi2, phase = Gate.first_mw_pulse_phase) elif hasattr(Gate,'first_pulse_is_pi2'): if Gate.first_pulse_is_pi2: Gate.mw_first_pulse = pulse.cp(Gate.mw_pi2, phase = msmt.params['mw_first_pulse_phase']) if hasattr(Gate,'no_first_pulse'): if Gate.no_first_pulse: Gate.mw_first_pulse = pulse.cp(Gate.mw_X,amplitude = 0) if hasattr(Gate,'no_mw_pulse'): if Gate.no_mw_pulse: Gate.mw_first_pulse = pulse.cp(Gate.mw_X,amplitude = 0, length = 0) Gate.mw_pi2 = pulse.cp(Gate.mw_X,amplitude = 0, length = 0) Gate.mw_mpi2 = pulse.cp(Gate.mw_X,amplitude = 0, length = 0) Gate.mw_X = pulse.cp(Gate.mw_X,amplitude = 0, length = 0)
def calibrate_pi2_pulse(name, debug=False): m = pulsar_msmt.GeneralPi2Calibration(name) m.params.from_dict(qt.exp_params['samples'][SAMPLE]) m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO']) m.params.from_dict( qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO-integrated']) m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO+espin']) m.params.from_dict(qt.exp_params['protocols']['cr_mod']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['pulses']) print 'pulse_shape =', m.params['pulse_shape'] pts = 11 m.params['pulse_type'] = 'Square QuMem' m.params['pts_awg'] = pts m.params['repetitions'] = 1500 # Append pi & pi/2 pulses to instance m.MW_pi = ps.X_pulse(m) m.MW_pi2 = ps.Xpi2_pulse(m) # we do actually two msmts for every sweep point, that's why the awg gets only half of the # pts; m.params['pts'] = 2 * pts m.params['Ex_SP_amplitude'] = 0 # m.params['SP_duration'] = 50 m.params['wait_for_AWG_done'] = 1 # Square pulses sweep_axis = m.params['fast_pi2_amp'] + np.linspace(-0.1, 0.1, pts) m.params['pulse_pi2_sweep_amps'] = sweep_axis # Hermite pulses sweep_axis = m.params['Hermite_fast_pi2_amp'] + np.linspace( -0.08, 0.08, pts) m.params['pulse_pi2_sweep_amps'] = sweep_axis # for the autoanalysis m.params['sweep_name'] = 'MW pi/2 amp (V)' m.params['sweep_pts'] = np.sort(np.append(sweep_axis, sweep_axis)) espin_funcs.finish(m, debug=debug, pulse_pi=m.MW_pi, pulse_pi2=m.MW_pi2)
def calibrate_pi2_pulse(name, debug=False, mw2=False): m = pulsar_msmt.GeneralPi2Calibration(name) espin_funcs.prepare(m) pts = 11 m.params['pulse_type'] = 'Hermite' m.params['pts_awg'] = pts m.params['repetitions'] = 2000 if mw2: print m.params['mw2_pulse_shape'] m.MW_pi = ps.mw2_X_pulse(m) m.MW_pi2 = ps.mw2_Xpi2_pulse(m) sweep_axis = m.params['mw2_Hermite_pi2_amp'] + np.linspace( -0.12, 0.12, pts) m.params['pulse_pi2_sweep_amps'] = sweep_axis else: print m.params['pulse_shape'] m.MW_pi = ps.X_pulse(m) m.MW_pi2 = ps.Xpi2_pulse(m) sweep_axis = m.params['Hermite_pi2_amp'] + np.linspace( -0.12, 0.12, pts) m.params['pulse_pi2_sweep_amps'] = sweep_axis # print 'this is the length',m.MW_pi2.length # we do actually two msmts for every sweep point, that's why the awg gets only half of the # pts; m.params['pts'] = 2 * pts m.params['Ex_SP_amplitude'] = 0 # m.params['SP_duration'] = 50 m.params['wait_for_AWG_done'] = 1 # Square pulses # sweep_axis = m.params['fast_pi2_amp'] + np.linspace(-0.02, 0.02, pts) # m.params['pulse_pi2_sweep_amps'] = sweep_axis # for the autoanalysis m.params['sweep_name'] = 'MW pi/2 amp (V)' m.params['sweep_pts'] = np.sort(np.append(sweep_axis, sweep_axis)) espin_funcs.finish(m, debug=debug, pulse_pi=m.MW_pi, pulse_pi2=m.MW_pi2)
def pi_pulse_sweepdelay(name, multiplicity=1, debug=False): m = pulsar_msmt.PiCalibration_SweepDelay(name) m.params.from_dict(qt.exp_params['samples'][SAMPLE]) m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO']) m.params.from_dict( qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO-integrated']) m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO+espin']) m.params.from_dict(qt.exp_params['protocols']['cr_mod']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['pulses']) m.params['pulse_type'] = 'Hermite quantum memory' # m.params['pulse_type'] = 'Square quantum memory' pts = 21 m.params['pts'] = pts # m.params['repetitions'] = 3000 if multiplicity == 1 else 5000 m.params['repetitions'] = 1000 if multiplicity == 1 else 5000 # Pulse settings m.params['multiplicity'] = np.ones(pts) * multiplicity m.params['MW_duration'] = m.params['Hermite_fast_pi_duration'] m.params[ 'MW_pulse_amplitudes'] = m.params['Hermite_fast_pi_amp'] * np.ones(pts) m.params['delay_reps'] = np.linspace(1, 100, pts) # for the autoanalysis m.params['sweep_name'] = 'Interpulse delay (us)' m.params['sweep_pts'] = m.params['interpulse_delay'] * 1e6 m.params['wait_for_AWG_done'] = 1 # Add Hermite X pulse # m.MW_pi = hermite_Xpi(m) m.MW_pi = ps.X_pulse(m) espin_funcs.finish(m, debug=debug, pulse_pi=m.MW_pi)
def sweep_number_pi_pulses(name, debug=False, pts = 30): m = pulsar_msmt.GeneralPiCalibration(name) m.params.from_dict(qt.exp_params['samples'][SAMPLE]) m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO-integrated']) m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO+espin']) m.params.from_dict(qt.exp_params['protocols']['cr_mod']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['pulses']) m.params['multiplicity'] = np.arange(1, 1 + 2 * pts, 2) m.params['pulse_type'] = 'Hermite quantum memory' # pts = 10 m.params['pts'] = pts # m.params['repetitions'] = 3000 if multiplicity == 1 else 5000 m.params['repetitions'] = 1000 #if multiplicity == 1 else 5000 # Pulse settings m.params['MW_duration'] = m.params['Hermite_fast_pi_duration'] m.params['MW_pulse_amplitudes'] = np.ones(pts) * m.params['Hermite_fast_pi_amp'] #XXXXX -0.05, 0.05 m.params['delay_reps'] = 1000 m.params['mw_power'] = 20 # for the autoanalysis m.params['sweep_name'] = 'Number of pulses' m.params['sweep_pts'] = m.params['multiplicity'] m.params['wait_for_AWG_done'] = 1 # Add Hermite X pulse m.MW_pi = ps.X_pulse(m) espin_funcs.finish(m, debug=debug, pulse_pi=m.MW_pi)
def calibrate_BB1_pi_pulse(name, multiplicity=1, debug=False): m = pulsar_msmt.ScrofulousPiCalibrationSingleElement(name) m.params.from_dict(qt.exp_params['samples'][SAMPLE]) m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO']) m.params.from_dict( qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO-integrated']) m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO+espin']) m.params.from_dict(qt.exp_params['protocols']['cr_mod']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['pulses']) pts = 16 m.params['pulse_type'] = 'Hermite' m.params['pts'] = pts # m.params['repetitions'] = 3000 if multiplicity == 1 else 5000 m.params['repetitions'] = 600 if multiplicity == 1 else 600 rng = 0.2 if multiplicity == 1 else 0.08 ### Pulse settings m.params['multiplicity'] = np.ones(pts) * multiplicity # For square pulses m.params[ 'MW_pulse_amplitudes'] = m.params['BB1_fast_pi_amp'] + np.linspace( -rng, rng, pts) ### which pulse amplitudes are swept? Is a string containing integers. e.g. '123' sweeps all amplitudes m.params['swept_pulses'] = '12345' m.params['delay_reps'] = 1 #195 ## Currently not used # for the autoanalysis m.params['sweep_name'] = 'MW amplitude (V)' m.params['sweep_pts'] = m.params['MW_pulse_amplitudes'] m.params['wait_for_AWG_done'] = 1 # Add Hermite X pulse # m.MW_pi = hermite_Xpi(m) m.MW_pi = ps.X_pulse(m) m.MW_pi = pulse.cp(m.MW_pi, length=m.params['BB1_fast_pi_duration'], amplitude=m.params['BB1_fast_pi_amp']) m.MW_pi2 = ps.Xpi2_pulse(m) # m.Phi60 = pulse.cp(m.MW_pi, phase = m.params['X_phase']+60) ### scrofolous pulse: https://arxiv.org/pdf/quant-ph/0208092.pdf m.Phi1 = pulse.cp(m.MW_pi, phase=60) m.Phi2 = pulse.cp(m.MW_pi, phase=300) m.params['composite_pulse_keys'] = ['1', '2', '1'] m.pulse_dict = { '1': m.Phi1, '2': m.Phi2 } ### keys refer to composite_pulse_keys #### BB1 pulse is below # m.Phi1 = pulse.cp(m.MW_pi, phase = m.params['X_phase']+104.5) # m.Phi2 = pulse.cp(m.MW_pi, phase = m.params['X_phase']+313.4) # m.Phi3 = pulse.cp(m.MW_pi, phase = m.params['X_phase']) # m.params['composite_pulse_keys'] = ['1','2','2','1','3'] ### determines what pulse you want to do in which oder # m.pulse_dict = {'1': m.Phi1,'2' : m.Phi2,'3' : m.Phi3} ### keys refer to composite_pulse_keys print 'amp ', m.params['MW_pulse_amplitudes'][0] espin_funcs.finish(m, debug=debug, pulse_dict=m.pulse_dict)
def hahn_echo_variable_delayline(name, debug=False, vary_refocussing_time=True, range_start=-2e-6, range_end=2e6, evolution_1_self_trigger=False, evolution_2_self_trigger=False, refocussing_time=1e-6): m = pulsar_delay.ElectronRefocussingTriggered(name) m.params.from_dict(qt.exp_params['samples'][SAMPLE]) m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO']) m.params.from_dict( qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO-integrated']) m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO+espin']) m.params.from_dict(qt.exp_params['protocols']['cr_mod']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['pulses']) m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO+delay']) m.params['delay_to_voltage_fitparams'] = np.loadtxt( '../lt4_V_c_from_dl_fit_20170323_1914.txt') m.params['delay_to_voltage_fitfunc'] = V_c_from_dl_fit m.params['pulse_type'] = 'Hermite' m.params['Ex_SP_amplitude'] = 0 m.params['AWG_to_adwin_ttl_trigger_duration'] = 2e-6 m.params['wait_for_AWG_done'] = 1 m.params['sequence_wait_time'] = 1 m.params['self_trigger_duration'] = 100e-9 # m.params['delay_voltage_DAC_channel'] = 16 # should be moved to msmt_params? m.params['do_delay_voltage_control'] = 1 pts = 11 m.params['pts'] = pts m.params['repetitions'] = 1000 if vary_refocussing_time: m.params['refocussing_time'] = np.linspace(range_start, range_end, pts) m.params['defocussing_offset'] = 0.0 * np.ones(pts) m.params['self_trigger_delay'] = m.params['refocussing_time'] m.params['sweep_name'] = 'single-sided free evolution time (us)' m.params['sweep_pts'] = (m.params['refocussing_time']) * 1e6 else: m.params['refocussing_time'] = np.ones(pts) * refocussing_time m.params['defocussing_offset'] = np.linspace(range_start, range_end, pts) m.params['self_trigger_delay'] = m.params['refocussing_time'] m.params['sweep_name'] = 'defocussing offset (us)' m.params['sweep_pts'] = (m.params['defocussing_offset']) * 1e6 # MW pulses X_pi2 = ps.Xpi2_pulse(m) X_pi = ps.X_pulse(m) # Start measurement m.autoconfig() print(m.params['delay_voltages']) m.generate_sequence(upload=True, pulse_pi2=X_pi2, pulse_pi=X_pi, evolution_1_self_trigger=evolution_1_self_trigger, evolution_2_self_trigger=evolution_2_self_trigger) if not debug: m.run(autoconfig=False) m.save() m.finish()
def electronRefocussingTriggered(name, debug=False, range_start=-2e-6, range_end=2e-6, evolution_1_self_trigger=True, evolution_2_self_trigger=False, vary_refocussing_time=False, refocussing_time=200e-6): m = pulsar_delay.ElectronRefocussingTriggered(name) m.params.from_dict(qt.exp_params['samples'][SAMPLE]) m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO']) m.params.from_dict( qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO-integrated']) m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO+espin']) m.params.from_dict(qt.exp_params['protocols']['cr_mod']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['pulses']) m.params['pulse_type'] = 'Hermite' m.params['Ex_SP_amplitude'] = 0 m.params[ 'AWG_to_adwin_ttl_trigger_duration'] = 2e-6 # commenting this out gives an erro m.params['wait_for_AWG_done'] = 1 m.params['sequence_wait_time'] = 1 m.params['do_delay_voltage_control'] = 0 m.params['delay_voltage_DAC_channel'] = 14 pts = 51 m.params['pts'] = pts m.params['repetitions'] = 1000 #m.params['wait_for_AWG_done']=1 #m.params['evolution_times'] = np.linspace(0,0.25*(pts-1)*1/m.params['N_HF_frq'],pts) # range from 0 to 1000 us # calibrated using Hahn echo m.params['self_trigger_delay'] = 2.950e-6 * np.ones(pts) m.params['self_trigger_duration'] = 100e-9 if vary_refocussing_time: m.params['refocussing_time'] = np.linspace(range_start, range_end, pts) m.params['defocussing_offset'] = 0.0 * np.ones(pts) m.params['sweep_name'] = 'single-sided free evolution time (us)' m.params['sweep_pts'] = (m.params['refocussing_time']) * 1e6 else: m.params['refocussing_time'] = np.ones(pts) * refocussing_time m.params['defocussing_offset'] = np.linspace(range_start, range_end, pts) m.params['sweep_name'] = 'defocussing offset (us)' m.params['sweep_pts'] = (m.params['defocussing_offset']) * 1e6 # MW pulses X_pi2 = ps.Xpi2_pulse(m) X_pi = ps.X_pulse(m) # for the self-triggering through the delay line # m.params['self_trigger_delay'] = 500e-9 # 0.5 us # m.params['self_trigger_duration'] = 100e-9 # Start measurement m.autoconfig() m.generate_sequence(upload=True, pulse_pi2=X_pi2, pulse_pi=X_pi, evolution_1_self_trigger=evolution_1_self_trigger, evolution_2_self_trigger=evolution_2_self_trigger) if not debug: m.run(autoconfig=False) m.save() m.finish()
def ssro_MWInit(name, multiplicity=1, debug=False, mw2=False, **kw): m = pulsar_msmt.SSRO_MWInit(name) # Import all msmst params m.params.from_dict(qt.exp_params['samples'][SAMPLE]) m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO-integrated']) m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO+espin']) m.params.from_dict(qt.exp_params['protocols']['cr_mod']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['pulses']) stools.turn_off_all_lasers() # MW settings pulse_shape = kw.get('pulse_shape', None) if pulse_shape == None: pulse_shape == m.params['pulse_shape'] else: m.params['pulse_shape'] = pulse_shape m.params['multiplicity'] = np.ones(pts)*multiplicity ### need to selectr the correct frequency if mw2: if m.params['pulse_shape'] == 'Hermite': print 'Using Hermite pulses' m.params['mw2_duration'] = m.params['mw2_Hermite_pi_length'] m.params['mw2_pulse_amplitudes'] = m.params['mw2_Hermite_pi_amp'] m.params['MW_pulse_amplitudes'] = m.params['mw2_Hermite_pi_amp'] else: print 'Using square pulses' m.params['mw2_duration'] = m.params['mw2_Square_pi_length'] m.params['mw2_pulse_amplitudes'] = m.params['mw2_Square_pi_amp'] m.params['MW_pulse_amplitudes'] = m.params['mw2_Square_pi_amp'] else: if m.params['pulse_shape'] == 'Hermite': print 'Using Hermite pulses' m.params['MW_duration'] = m.params['Hermite_pi_length'] m.params['MW_pulse_amplitudes'] = m.params['Hermite_pi_amp'] else: print 'Using square pulses' m.params['MW_duration'] = m.params['Square_pi_length'] m.params['MW_pulse_amplitudes'] = m.params['Square_pi_amp'] ### SSRO RO duration sweep params #### Maybe not hardcode RO time m.params['SSRO_duration_list'] = np.arange(0,500,10) m.params['pts'] = len(m.params['SSRO_duration_list']) m.params['Ex_SP_amplitude'] = 0. m.params['sweep_name'] = 'SSRO_MWInit duration' m.params['sweep_pts'] = m.params['SP_duration_list'] m.params['wait_for_AWG_done'] = 1 m.MW_pi = pulse.cp(ps.pi_pulse_MW2(m), phase = 0) if mw2 else pulse.cp(ps.X_pulse(m), phase = 0) espin_funcs.finish(m, debug=debug, pulse_pi=m.MW_pi)
def gateset(m, debug=False, decoupling=True, multiple=False, pi=True, single_decoupling=False, last_seq=False, fid_1=['e'], fid_2=['e'], sequence_type='all', germ=['e'], germ_position=[1, 3], N_decoupling=[4], run_numbers=[1, 2, 3]): """ Function used to run GST on the individual experiment level. """ if sequence_type == 'specific_germ_position': m = pulsar_delay.GateSetWithDecoupling(name) mbi_funcs.prepare(m) # load msmt params #from mbi_funcs.py m.params['E_RO_durations'] = [m.params['SSRO_duration']] m.params['E_RO_amplitudes'] = [m.params['Ex_RO_amplitude']] m.params['send_AWG_start'] = [1] m.params['sequence_wait_time'] = [0] #Specific to make it work on LT2 m.params['initial_msmt_delay'] = 5000.0e-9 #The total number of sequence repetitions m.params['reps_per_ROsequence'] = 5000 m.params['fid_1'] = fid_1 m.params['fid_2'] = fid_2 m.params['sequence_type'] = sequence_type m.params['germ'] = germ m.params['germ_position'] = germ_position m.params['N_decoupling'] = N_decoupling m.params['run_numbers'] = run_numbers #Muss auch nicht imer definiert werden #Calculae the larmor frequency, since we want to sit on larmor revival points for this experiment tau_larmor = np.round(1 / m.params['C1_freq_0'], 9) m.params['tau_larmor'] = tau_larmor if decoupling: #The spacing in between germ pulses t_bw_germs = 50e-9 m.params['wait_time'] = t_bw_germs #We need to check that our germ / fiducial pulses fit between two larmor times, and otherwise make it an #integer multiple of the initial value. Strictly the fiducial does not go in here. In the end this is probably not necessary since #our sequences are very short. sequence_length = max(len(max(fid_1, key=len)), len(max( fid_2, key=len)), len(max(germ, key=len))) * ( m.params['Hermite_pi2_length'] + t_bw_germs) + t_bw_germs if 2 * tau_larmor <= sequence_length: tau_larmor *= np.ceil(sequence_length / (2 * tau_larmor)) print "Adjusted larmor frequency to multiple", tau_larmor # tau_larmor *= 4 # print tau_larmor m.params['tau_larmor'] = tau_larmor m.params['sweep_name'] = 'Total evolution time [ms]' m.params['sweep_pts'] = run_numbers * np.ones( len(run_numbers)) * tau_larmor * 1.e3 else: m.params['sweep_name'] = 'Germ repetitions' m.params['sweep_pts'] = run_numbers #Set up the pulses we want to use in the experiment. First all the pi2 pulses. X_pi2 = ps.Xpi2_pulse(m) Y_pi2 = ps.Ypi2_pulse(m) mX_pi2 = ps.mXpi2_pulse(m) mY_pi2 = ps.mYpi2_pulse(m) #Set up all the pi pulses. X_pi = ps.X_pulse(m) Y_pi = ps.Y_pulse(m) mX_pi = ps.mX_pulse(m) mY_pi = ps.mY_pulse(m) # for the autoanalysis # m.params['sweep_name'] = 'Run number' # m.params['sweep_pts'] = 1 # Now calculate how many sweeps we want to do. For now we want to put a germ pulse at different subsequent # locations. Later, we want to make this random if sequence_type == "all": if len(fid_1) == len(fid_2) == len(germ) == len(N_decoupling) == len( run_numbers): m.params['pts'] = len(fid_1) else: sys.exit( "A mistake happened. Check your fiducials and germ lists have the same length." ) else: m.params['pts'] = len(germ_position) # Start measurement m.autoconfig() m.generate_sequence(pi=pi, decoupling=decoupling, upload=True, single_decoupling=single_decoupling, x_pulse_pi2=X_pi2, y_pulse_pi2=Y_pi2, x_pulse_mpi2=mX_pi2, y_pulse_mpi2=mY_pi2, x_pulse_pi=X_pi, y_pulse_pi=Y_pi, x_pulse_mpi=mX_pi, y_pulse_mpi=mY_pi) if not debug: m.run(autoconfig=False) if multiple: print run_numbers[0] m.save(name='Start_run%d' % run_numbers[0]) else: m.save() if not multiple: m.finish() else: if last_seq == True: m.finish()
def QMem(name, carbon_list=[5], carbon_init_list=[5], carbon_init_states=['up'], carbon_init_methods=['MBI'], carbon_init_thresholds=[1], number_of_MBE_steps=0, mbe_bases=['Y', 'Y'], MBE_threshold=1, logic_state='X', el_RO='positive', debug=True, tomo_list=['X'], Repetitions=300, carbon_swap_list=[], e_swap_state=['X'], swap_type=None, RO_after_swap=True, **kw): m = QM.QMemory_repumping(name) funcs.prepare(m) pts = kw.get('pts', 20) m.params['do_optical_pi'] = kw.get('do_optical_pi', False) m.params['initial_MW_pulse'] = kw.get('initial_MW_pulse', 'pi2') m.params['reps_per_ROsequence'] = Repetitions m.params['carbon_list'] = carbon_list ### Carbons to be used ####################################### ### Carbon Initialization settings #### ####################################### m.params['carbon_init_list'] = carbon_init_list m.params['init_method_list'] = carbon_init_methods * len(carbon_init_list) m.params['init_state_list'] = carbon_init_states * len(carbon_init_list) m.params['Nr_C13_init'] = len(carbon_init_thresholds) m.params['el_after_init'] = '0' ################################ ### elec to carbon swap settings #### ################################ if swap_type == None: m.params['C13_MBI_threshold_list'] = carbon_init_thresholds * len( carbon_init_list) else: m.params['C13_MBI_threshold_list'] = carbon_init_thresholds print 'c_init_th' + str(m.params['C13_MBI_threshold_list']) m.params['carbon_swap_list'] = carbon_swap_list m.params['elec_init_state'] = e_swap_state m.params[ 'SWAP_type'] = swap_type #used in carbon_swap_gate to determine swap w carbon init or w/o carbon init m.params['Nr_C13_SWAP'] = len(carbon_swap_list) m.params['RO_after_swap'] = RO_after_swap #################### ### MBE settings ### #################### m.params['Nr_MBE'] = number_of_MBE_steps m.params['MBE_bases'] = mbe_bases m.params['MBE_threshold'] = MBE_threshold m.params['2qb_logical_state'] = logic_state m.params['2C_RO_trigger_duration'] = 150e-6 ################################### ### Parity measurement settings ### ################################### m.params['Nr_parity_msmts'] = 0 m.params['Parity_threshold'] = 1 ########################################## ##### Detuning for sweep of LDE phase #### ########################################## m.params['Carbon_LDE_init_phase_correction_list'] = np.array([0.0] + [0.0] * 10) m.params['fast_repump_repetitions'] = np.array([1] * pts) ############################# ##### Sweep Params ########## ############################# print 'min Reps: ', minReps, ' Max reps: ', maxReps print 'carbons ', carbon_list, ' couplings: ', abs( abs(coupling_difference) - m.params['C1_freq_0']) f_larmor = m.params['C1_freq_0'] tau_larmor = round(1 / f_larmor, 9) # tau_larmor = 2.1e-6 print 'Calculated tau_larmor', tau_larmor m.params['repump_wait'] = pts * [ tau_larmor ] #tau_larmor] #pts*[2e-6] # time between pi pulse and beginning of the repumper m.params['fast_repump_power'] = kw.get('repump_power', 20e-9) m.params['fast_repump_duration'] = pts * [ kw.get('fast_repump_duration', 1.5e-6) ] #how long the beam is irradiated m.params['average_repump_time'] = pts * [ kw.get('average_repump_time', 110e-9) ] #this parameter has to be estimated from calibration curves, goes into phase calculation m.params['do_pi'] = True ### does a regular pi pulse m.params[ 'do_BB1'] = False # ### does a BB1 pi pulse NOTE: both bools should not be true at the same time. ps.X_pulse(m) #this updates fast_pi_amp m.params['pi_amps'] = pts * [m.params['fast_pi_amp']] ### RO params m.params['electron_readout_orientation'] = el_RO m.params['Tomo_bases'] = np.linspace(-60., 400., pts) ### For the Autoanalysis m.params['pts'] = pts m.params['sweep_name'] = 'Carbon RO phase' m.params['sweep_pts'] = m.params['Tomo_bases'] funcs.finish(m, upload=True, debug=debug)
def calibrate_pi_RO_N(name, multiplicity, debug=False, **kw): m = PiCalibrationWithDESRreadout(name) if qt.current_setup == 'lt3': ### formatting is pulse amp, pulse duration, frequency shift N_peak_dict = { '0': [0.000, 7e-6, 0], '1': [0.0017, 7e-6, +876e3 / 2. + 0.002194e9], '2': [0.0017, 7e-6, -876e3 / 2. + 0.002194e9], '3': [0.0017, 7e-6, +876e3 / 2.], '4': [0.0017, 7e-6, -876e3 / 2.], '5': [0.0017, 7e-6, +876e3 / 2. - 0.002194e9], '6': [0.0017, 7e-6, -876e3 / 2. - 0.002194e9], } espin_funcs.prepare(m) m.params['wait_for_AWG_done'] = 1 m.params['AWG_controlled_readout'] = 0 m.params['delay_reps'] = 0 ### kws calibrate_N_RO = kw.pop('calibrate_N_RO', False) #### some pulse changes such that we don't interfere with msmt.params. f_msp1_cntr = m.params['ms+1_cntr_frq'] mw_mod_frequency = 43e6 m.params['mw_mod_freq'] = mw_mod_frequency m.params['mw_frq'] = f_msp1_cntr - mw_mod_frequency ### initialize a bunch of useful values [ m.params['N_RO_pulse_amp'], m.params['N_RO_pulse_duration'], m.params['N_RO_frequency_shift'] ] = N_peak_dict[str(1)] m.MW_pi = pulse.cp(ps.X_pulse(m), phase=0) ### first calibrate all average state populations this is used for ROC purposes first = True if calibrate_N_RO: m.params['repetitions'] = 12000 m.params['add_RO_pulse'] = True pts = 6 m.params['pts'] = pts m.params['general_sweep_pts'] = [] m.params['general_sweep_name'] = 'N_RO_frequency_shift' m.params['multiplicity'] = np.ones(pts) * 0 for i in range(1, pts + 1, 1): m.params['general_sweep_pts'].append(N_peak_dict[str(i)][2]) m.params['sweep_name'] = 'N/13C dip' m.params['sweep_pts'] = np.array(range(1, pts + 1, 1)) m.autoconfig() m.generate_sequence(upload=True, pulse_pi=m.MW_pi) if not debug: m.run(autoconfig=False) m.save(name='n_ro_calibration', first=first) first = False m.params['add_RO_pulse'] = kw.pop('add_RO_pulse', False) ###### here is the actual sweep! m.params['Hermite_pi_length'] = m.params['Hermite_pi_length'] + 10e-9 pts = 15 m.params['pts'] = pts m.params['repetitions'] = 5000 if multiplicity == 1 else 1000 rng = 0.15 if multiplicity == 1 else 0.06 # ps.X_pulse(m) ### update pulse params m.params['general_sweep_name'] = 'fast_pi_amp' m.params['general_sweep_pts'] = np.linspace( 0.0, 0.95, pts) #m.params['fast_pi_amp'] + np.linspace(-rng, rng, pts) m.params['multiplicity'] = np.ones(pts) * multiplicity # for the autoanalysis m.params['sweep_name'] = 'MW amplitude (V)' m.params['sweep_pts'] = m.params['general_sweep_pts'] #### get thte correct N_RO_params breakst = False m.autoconfig() for i in range(0, 6 + 1, 1): breakst = show_stopper() if breakst: break [ m.params['N_RO_pulse_amp'], m.params['N_RO_pulse_duration'], m.params['N_RO_frequency_shift'] ] = N_peak_dict[str(i)] m.generate_sequence(upload=True, pulse_pi=m.MW_pi) if not debug: m.run(autoconfig=False) m.save(name='ro_n_dip_' + str(i), first=first) first = False m.finish()
def run(name, **kw): m = pulsar_mbi_espin.ElectronRamsey_Dephasing(name) funcs.prepare(m) max_duration = kw.get('max_duration', 3e-6) pts = 50 # even number m.params['pts'] = pts m.params['reps_per_ROsequence'] = 200 m.params['detuning'] = 0e6 #artificial detuning # MW pulses ## First pulse # m.params['MW_pulse_durations'] = np.ones(pts) * m.params['fast_pi_duration'] # m.params['MW_pulse_amps'] = np.ones(pts) * m.params['fast_pi_amp'] # m.params['MW_pulse_mod_frqs'] = np.ones(pts) * m.params['AWG_MBI_MW_pulse_mod_frq'] # m.params['MW_pulse_1_phases'] = np.ones(pts) * 0 m.params['init_with_second_source'] = init_with_second_source m.params['readout_with_second_source'] = readout_with_second_source m.params['init_in_zero'] = init_in_zero ## this needs to be cleaner MW1_pi = ps.X_pulse(m) m.params['fast_pi_amp'] = MW1_pi.amplitude ## initialization microwave pulse if init_with_second_source: m.params['MW_pulse_durations'] = np.ones( pts) * m.params['mw2_fast_pi_duration'] m.params['MW_pulse_amps'] = np.ones(pts) * m.params['mw2_fast_pi_amp'] else: m.params['MW_pulse_durations'] = np.ones( pts) * m.params['fast_pi_duration'] m.params['MW_pulse_amps'] = np.ones(pts) * m.params['fast_pi_amp'] m.params['MW_pulse_mod_frqs'] = np.ones( pts) * m.params['AWG_MBI_MW_pulse_mod_frq'] m.params['MW_pulse_1_phases'] = np.ones(pts) * 0 ## Readout microwave pulse if do_pm1_readout: if readout_with_second_source: m.params['MW_pulse_2_durations'] = np.ones( pts) * m.params['mw2_fast_pi_duration'] m.params['MW_pulse_2_amps'] = np.ones( pts) * m.params['mw2_fast_pi_amp'] else: m.params['MW_pulse_2_durations'] = np.ones( pts) * m.params['fast_pi_duration'] m.params['MW_pulse_2_amps'] = np.ones( pts) * m.params['fast_pi_amp'] m.params['MW_pulse_mod_frqs'] = np.ones( pts) * m.params['AWG_MBI_MW_pulse_mod_frq'] m.params['MW_pulse_2_phases'] = np.ones(pts) * 0 else: m.params['MW_pulse_2_durations'] = np.ones(pts) * 0 m.params['MW_pulse_2_amps'] = np.ones(pts) * 0 m.params['MW_pulse_2_phases'] = np.ones(pts) * 0 m.params['pump_using_repumper'] = pump_using_repumper m.params['pump_using_newfocus'] = pump_using_newfocus m.params['pump_using_MW2'] = pump_using_MW2 if pump_using_MW2: m.params['pump_MW2_durations'] = np.linspace(0.0e-6, max_duration, pts) m.params['pump_MW2_delay'] = np.ones(pts) * pump_MW2_delay m.params['pump_MW2_falltime'] = np.ones(pts) * pump_MW2_falltime # laser beam; called dephasing, but does repump m.params['dephasing_AOM'] = 'NewfocusAOM' #m.params['dephasing_AOM'] = 'RepumperAOM' m.params['laser_dephasing_amplitude'] = kw.get('newfocus_power', 20e-9) m.params['repumper_amplitude'] = kw.get('repumper_power', 20e-9) m.params['repumping_time'] = np.linspace( 0.0e-6, max_duration, pts ) # np.r_[np.linspace(0.0e-6,0.2e-6,pts/2), np.linspace(1.2e-6,5e-6,pts/2)] #m.params['repumping_time'] = np.r_[np.linspace(0.03e-6,0.5e-6,pts/4.), np.linspace(0.2e-6,5e-6,3.*pts/4.)] m.params['MW_repump_delay1'] = np.ones(pts) * 500e-9 m.params['MW_repump_delay2'] = np.ones(pts) * 2500e-9 m.params['Repump_multiplicity'] = np.ones(pts) * 1 # for the autoanalysis m.params['sweep_name'] = 'Repump duration (us)' m.params['sweep_pts'] = m.params['repumping_time'] / (1e-6) funcs.finish(m, debug=kw.get('debug', False))
def QMem(name, carbon_list=[5], carbon_init_list=[5], carbon_init_states=['up'], carbon_init_methods=['MBI'], carbon_init_thresholds=[1], number_of_MBE_steps=0, mbe_bases=['Y', 'Y'], MBE_threshold=1, logic_state='X', el_RO='positive', debug=True, tomo_list=['X'], Repetitions=300, carbon_swap_list=[], e_swap_state=['X'], swap_type=None, RO_after_swap=True, **kw): m = QM.QMemory_repumping(name) funcs.prepare(m) m.params['do_optical_pi'] = kw.get('do_optical_pi', False) m.params['initial_MW_pulse'] = kw.get('initial_MW_pulse', 'pi2') m.params['reps_per_ROsequence'] = Repetitions m.params['carbon_list'] = carbon_list ### Carbons to be used ####################################### ### Carbon Initialization settings #### ####################################### m.params['carbon_init_list'] = carbon_init_list m.params['init_method_list'] = carbon_init_methods * len(carbon_init_list) m.params['init_state_list'] = carbon_init_states * len(carbon_init_list) m.params['Nr_C13_init'] = len(carbon_init_thresholds) m.params['el_after_init'] = '0' ################################ ### elec to carbon swap settings #### ################################ if swap_type == None: m.params['C13_MBI_threshold_list'] = carbon_init_thresholds * len( carbon_init_list) else: m.params['C13_MBI_threshold_list'] = carbon_init_thresholds print 'c_init_th' + str(m.params['C13_MBI_threshold_list']) m.params['carbon_swap_list'] = carbon_swap_list m.params['elec_init_state'] = e_swap_state m.params[ 'SWAP_type'] = swap_type #used in carbon_swap_gate to determine swap w carbon init or w/o carbon init m.params['Nr_C13_SWAP'] = len(carbon_swap_list) m.params['RO_after_swap'] = RO_after_swap #################### ### MBE settings ### #################### m.params['Nr_MBE'] = number_of_MBE_steps m.params['MBE_bases'] = mbe_bases m.params['MBE_threshold'] = MBE_threshold m.params['2qb_logical_state'] = logic_state m.params['2C_RO_trigger_duration'] = 150e-6 ################################### ### Parity measurement settings ### ################################### m.params['Nr_parity_msmts'] = 0 m.params['Parity_threshold'] = 1 ################################### ### LDE element settings ### ################################### coupling_difference = 0 ## sum up coupling differences in order to get an estimate for maxRepetitions. for ii, c in enumerate(carbon_list): if ii == 0: coupling_difference = m.params['C' + str(c) + '_freq_1_m1'] else: if logic_state == 'X': # print 'carbon freqs',m.params['C'+str(c)+'_freq_1_m1'],m.params['C'+str(c)+'_freq_0'] coupling_difference += (m.params['C' + str(c) + '_freq_1_m1'] - m.params['C' + str(c) + '_freq_0']) else: # print 'carbon freqs',m.params['C'+str(c)+'_freq_1_m1'],m.params['C'+str(c)+'_freq_0'] coupling_difference += -m.params['C' + str( c) + '_freq_1_m1'] - m.params['C' + str(c) + '_freq_0'] # print c # print coupling_difference pts = kw.get('pts', None) if pts == None: if len(carbon_list) != 2: if 6 in carbon_list and not 5 in carbon_list: pts = 10 elif 6 in carbon_list and 5 in carbon_list: pts = 6 else: pts = 11 else: pts = 11 minReps = kw.get('minReps', 0) # minimum number of LDE reps maxReps = kw.get( 'maxReps', 1e3 / abs(abs(coupling_difference) - m.params['C1_freq_0'])) step = int((maxReps - minReps) / pts) m.params['fast_repump_repetitions'] = np.arange(minReps, minReps + pts * step, step) ############################# ##### Sweep Params ########## ############################# print 'min Reps: ', minReps, ' Max reps: ', maxReps print 'carbons ', carbon_list, ' couplings: ', abs( abs(coupling_difference) - m.params['C1_freq_0']) f_larmor = m.params['C1_freq_0'] tau_larmor = round(1 / f_larmor, 9) # tau_larmor = 2.1e-6 print 'Calculated tau_larmor', tau_larmor # tau_larmor = 2.298e-6 m.params['repump_wait'] = pts * [ tau_larmor ] #tau_larmor] #pts*[2e-6] # time between pi pulse and beginning of the repumper m.params['fast_repump_power'] = kw.get('repump_power', 20e-9) m.params['fast_repump_duration'] = pts * [ kw.get('fast_repump_duration', 1.5e-6) ] #how long the beam is irradiated m.params['average_repump_time'] = pts * [ kw.get('average_repump_time', 110e-9) ] #this parameter has to be estimated from calibration curves, goes into phase calculation m.params['do_pi'] = True ### does a regular pi pulse m.params[ 'do_BB1'] = False # ### does a BB1 pi pulse NOTE: both bools should not be true at the same time. ps.X_pulse(m) #this updated fast_pi_amp m.params['pi_amps'] = pts * [m.params['fast_pi_amp']] ### For the Autoanalysis m.params['pts'] = pts m.params['sweep_name'] = 'repump repetitions' m.params['sweep_pts'] = m.params['fast_repump_repetitions'] ### RO params m.params['electron_readout_orientation'] = el_RO m.params['Tomo_bases'] = tomo_list funcs.finish(m, upload=True, debug=debug)
def QMem(name, carbon_list=[5], carbon_init_list=[5], carbon_init_states=['up'], carbon_init_methods=['MBI'], carbon_init_thresholds=[1], number_of_MBE_steps=0, mbe_bases=['Y', 'Y'], MBE_threshold=1, logic_state='X', el_RO='positive', debug=True, tomo_list=['X'], Repetitions=5000, **kw): m = QM.QMemory_repumping(name) funcs.prepare(m) ############ m.params['C13_MBI_threshold_list'] = carbon_init_thresholds * len( carbon_init_list) ''' set experimental parameters ''' m.params['reps_per_ROsequence'] = Repetitions ### Carbons to be used m.params['carbon_list'] = carbon_list ### Carbon Initialization settings m.params['carbon_init_list'] = carbon_init_list m.params['init_method_list'] = carbon_init_methods * len(carbon_init_list) m.params['init_state_list'] = carbon_init_states * len(carbon_init_list) m.params['Nr_C13_init'] = len(carbon_init_list) m.params['el_after_init'] = '0' ################################## ### RO bases ### ################################## ## not necessary #################### ### MBE settings ### #################### """these parameters will be used later on""" m.params['Nr_MBE'] = number_of_MBE_steps m.params['MBE_bases'] = mbe_bases m.params['MBE_threshold'] = MBE_threshold m.params['2qb_logical_state'] = logic_state m.params['2C_RO_trigger_duration'] = 150e-6 ################################### ### Parity measurement settings ### ################################### m.params['Nr_parity_msmts'] = 0 m.params['Parity_threshold'] = 1 ################################### ### LDE element settings ### ################################### ### determine sweep parameters pts = 21 tau_larmor = kw.get('tau_larmor', round(1. / m.params['C4_freq_0'], 9)) print 'Tau larmor is ', tau_larmor m.params['repump_wait'] = pts * [ tau_larmor ] # time between pi pulse and beginning of the repumper m.params['average_repump_time'] = np.linspace( -0.5e-6, 1.5e-6, pts ) #np.linspace(-0.2e-6,1.5e-6,pts) #this parameter has to be estimated from calibration curves, goes into phase calculation m.params['fast_repump_repetitions'] = pts * [kw.get('seq_reps', 250.)] m.params['do_pi'] = True ### does a regular pi pulse m.params[ 'do_BB1'] = False ### does a BB1 pi pulse NOTE: both bools should not be true at the same time. m.params['do_optical_pi'] = kw.get('do_optical_pi', False) ps.X_pulse(m) print 'pi pulse amps', m.params['fast_pi_amp'], m.params['Hermite_pi_amp'] m.params['pi_amps'] = pts * [m.params['fast_pi_amp']] # print 'this is the pi pulse amplitude',ps.X_pulse(m).env_amplitude,ps.X_pulse(m).Sw_risetime m.params['fast_repump_duration'] = pts * [ 2.5e-6 ] #how long the repump beam is applied. m.params['fast_repump_power'] = kw.get('repump_power', 50e-9) ### For the Autoanalysis m.params['pts'] = pts m.params['sweep_name'] = 'average repump time (us)' m.params['sweep_pts'] = m.params['average_repump_time'] * 1e6 ### RO params m.params['electron_readout_orientation'] = el_RO m.params['Tomo_bases'] = tomo_list funcs.finish(m, upload=True, debug=debug)