def rf_sweep( BW, Power, Freq, Logname): print "rf_sweep" m = uut(ipaddr='10.8.9.195', opmode='master') s = uut(ipaddr='10.8.9.196', opmode='slave') m.telnet() s.telnet() m.web() s.web() print "pre control" ctrl = control( m, s, 25) # <-- 25 second wait time print "post control" csv = LogFile( 'logs',Logname, '.csv') #, ['11','22','33','44','55','66'] ) tdata = testdata( 0,0,0) csv.write(tdata.header) bw = sweep( BW[0], BW[1], BW[2], ctrl.setbw, file='bw') pwr = sweep( Power[0], Power[1], Power[2], ctrl.setpower, file='pwr') frq = sweep( Freq[0], Freq[1], Freq[2], ctrl.setfrequency, file='frq') bw.regen() ChBW = bw.next() while ChBW : print "ChBW: ",ChBW frq.regen() delay = 25 freq = frq.next() while freq: print "Freq: ",freq delay = 25 pwr.regen() power = pwr.next() while power: print "Power: ",power ctrl.wait(delay) delay = 3 tdata = testdata( freq, power, ChBW, temp) tdata.wdata( m ) tdata.wdata( s ) csv.write(tdata.getcsv()) # print tdata.header print tdata.getcsv() power = pwr.next() # reset power ctrl.setpower(pwr.start) freq = frq.next() ChBW = bw.next() print "Complete csv.close()" csv.close() bw.clean() pwr.clean() frq.clean()
def main(): conn = connect(sys.argv[1]) n = int(sys.argv[2]) cur = conn.cursor() cur.execute( '''CREATE TABLE IF NOT EXISTS sir_runs ( id SERIAL PRIMARY KEY, gamma REAL, beta REAL )''') cur.execute( '''CREATE TABLE IF NOT EXISTS sir_results ( id INTEGER REFERENCES sir_runs, s INTEGER, i INTEGER, r INTEGER, t SMALLINT );''') conn.commit() sr = sweep_range(0.99, 0.01, n) for g, b, sw in sweep(1000, 5, 0, sr, sr): print g, b, len(sw) cur.execute( '''INSERT INTO sir_runs (gamma, beta) VALUES (%s, %s) RETURNING id;''', (g, b)) id, = cur.fetchone() for t in xrange(len(sw)): s, i, r = sw[t] cur.execute( 'INSERT INTO sir_results VALUES (%s, %s, %s, %s, %s);', (id, s, i, r, t)) conn.commit()
def xrf_sweep(): print "rf_sweep" m = uut(ipaddr='10.8.8.100', opmode='master') s = uut(ipaddr='10.8.8.108', opmode='slave') m.telnet() s.telnet() m.web() s.web() print "pre control" ctrl = control( m, s, 25) # <-- 25 second wait time print "post control" csv = LogFile( 'logs','SWEEP', '.csv') #, ['11','22','33','44','55','66'] ) tdata = testdata( 0,0,0) csv.write(tdata.header) bw = sweep( 50, 51, 1, ctrl.setbw) # <-- Channel Bandwidth 50,51,1 ChBW = bw.next() while ChBW : print ChBW pwr = sweep( 10, 13, 1, ctrl.setpower) # <-- TX POWER 10,27,1 power = pwr.next() while power: frq = sweep( 5150, 5151, 1, ctrl.setfrequency) # <-- Frequency 5150,5876,1 freq = frq.next() while freq: print freq ctrl.wait() tdata = testdata( freq, power, ChBW) tdata.wdata( m ) tdata.wdata( s ) csv.write(tdata.getcsv()) # print tdata.header print tdata.getcsv() freq = frq.next() power = pwr.next() ChBW = bw.next() csv.close()
#!/usr/bin/env python3 # # Simple spectrum analyzer to measure the transmitted spectrum # to check that the transmitter meets frequency licensing requirements. # import sweep import h5py import numpy as n import matplotlib.pyplot as plt acquire_new_spec = False if acquire_new_spec: import analyze_spectrum as aspec s = sweep.sweep(freqs=sweep.freqs30, freq_dur=2.0) n_f = len(s.freqs) if acquire_new_spec: print( "Measuring receiver noise floor. Make sure the transmitter is powered off" ) aspec.acquire_spectrum(ofname="meas/spec_off.h5", N_windows=1000) try: input( "Measuring the transmitted spectrum. Make sure that the transmitter is on.\n" "Press any key to continue.") except Exception as e: pass
absM = [] #Empty list to store absolute value of magnetisation (normalised) avgabsM = [] #Empty list to store average absolute value of magnetisation iterations = 1000 #No. of sweeps we want to conduct #To start after a few sweeps are done so that we are close to the equilibrium state #(and to avoid the effect of the initial state) eqstate = int(iterations/3) #Set up empty lists for storing data after our chosen "equilibrium state" eqsweep = [] #sweep no. after "equilibrium" eqM = [] #absolute magnetisation value after "equilibrium" #Do multiple sweeps and store the information related to magnetisation in a list for i in range(iterations): S = sweep(S, JkT, BkT) # #For visualising lattice # if i%100 == 0: # plt.clf() # plt.title("i = " + str(i)) # plt.imshow(S) # plt.pause(0.000001) M.append(np.sum(S)/maxM) #Store value of M after i sweeps absM.append(abs(np.sum(S)/maxM)) #Store value of |M| after i sweeps #For points after our chosen "equilibrium state" if i >= eqstate: eqsweep.append(i)
def generate_table_all_16(algorithm): # If the algorithm is not supported we do not create anything if algorithm not in supported_algorithms: print("We cannot generate the table!") else: # Creating the document doc = Document('latex_tables/generated_table_all_16_' + algorithm) section = Section(algorithm_name_dict[algorithm] + " Table") # Creation of the Table table = Tabular('ccc') table.add_row((MultiColumn(3, align='c', data=algorithm_name_dict[algorithm]), )) table.add_hline() table.add_hline() table.add_row(("ID", "Soluzione", "Tempo")) table.add_hline() # Iterating for each map with respect to the wind map_index = 1 for current_map in maps: for current_wind in winds: tot_cost = 0 tot_time = 0 # We catch the correct algorithm to use if algorithm == 'sweep': tot_cost, tot_time, path = sweep(current_map, generate_costs( current_map, current_wind), plot=False) if algorithm == 'knn': tot_cost, tot_time, path = kNN( generate_costs(current_map, current_wind), 0) if algorithm == 'knn-opt': tot_cost, tot_time, path = opt_kNN( generate_costs(current_map, current_wind)) if algorithm == 'nearest_insertion': tot_cost, tot_time, path = nearest_insertion( generate_costs(current_map, current_wind)) if algorithm == 'farthest_insertion': tot_cost, tot_time, path = farthest_insertion( generate_costs(current_map, current_wind)) # The row with the data is written onto a new row and the index is incremented table.add_row((map_index, "{:.2f}".format(tot_cost), "{:.2e}".format(tot_time))) map_index += 1 # We close the table table.add_hline() # And finally we compose and generate the new document with the embedded table section.append(table) doc.append(section) doc.generate_tex()
def measure(self): #if self.interleaving_sequences: il_seqs = self.interleaving_sequences #else: # il_seqs = [self.generate_random_interleaver_sequence(self.sequence_length) for i in range(self.random_sequence_num)] interleaved = [ self.interleave(i['Gate names'], self.target_gate, self.target_gate_unitary, self.target_gate_name) for i in il_seqs ] def set_interleaved_sequence(seq_id): self.tomo.set_prepare_seq(interleaved[seq_id]['Pulse sequence']) results = sweep.sweep( self.tomo, (np.arange(len(interleaved)), set_interleaved_sequence, 'Interleaving sequence id'), output=False, plot=False, header='Interleaved benchmarking sequence sweep') #calculating euclidean distance metric axes = [a for a in self.tomo.reconstruction_basis.keys()] expected_projections = {a:[np.trace(np.dot(self.tomo.reconstruction_basis[a]['operator'], seq['Final state matrix'])) \ for seq in interleaved] for a in axes} #print (expected_projections, results) #print (results[axes[0]]) #print (results[axes[0]][0]) #print (results[axes[0]][1]) #print (np.real(np.sqrt(np.sum([(expected_projections[a] - results[a][2])**2 for a in axes], axis=0)))) #print (results[axes[0]][3]) results['Euclidean distance'] = ( results[axes[0]][0], results[axes[0]][1], np.real( np.sqrt( np.sum([(expected_projections[a] - results[a][2])**2 for a in axes], axis=0))), results[axes[0]][3]) results['Mean Euclidean distance'] = ( [], [], np.mean( np.real( np.sqrt( np.sum([(expected_projections[a] - results[a][2])**2 for a in axes], axis=0)))), []) results['Pulse sequences'] = ((results[axes[0]][0], 'Gate names'), (results[axes[0]][1], np.arange( len(interleaved[0]['Gate names']))), np.asarray([ i['Gate names'] for i in interleaved ]), results[axes[0]][3]) results.update({ '{0} fit'.format(i): (results[i][0], results[i][1], np.real(expected_projections[i]), results[i][3]) for i in axes }) # calculating fidelities of measured projections #psi = seq['Final state vector'] #results['Fidelity'] = np.sqrt(np.sum([np.einsum('i,ij,jk,kl,j->', np.conj(psi), np.conj(Ut['unitary']), rho, Ut['unitary'], psi) \ # for rho, Ut in zip(, self.tomo.proj_seq)])) #for a in axes: # plt.close(a) #for p in self.tomo.proj_seq.keys(): # plt.close(a) return {k: v[2] for k, v in results.items()}
output_file = file(output_filename,'w') output_file.write("#PWIDTH\tPWIDTH Error\tPIN\tPIN Error\tWIDTH\tWIDTH Error\tRISE\tRISE Error\tFALL\tFALL Error\tAREA\tAREA Error\tMinimum\tMinimum Error\n") #Start scanning! tmpResults = None t_start = time.time() for width in widths: min_volt = None loopStart = time.time() if tmpResults!=None: #set a best guess for the trigger and the scale #using the last sweeps value min_volt = float(tmpResults["peak"]) if min_volt == 0: # If bad data set, make none min_volt = 50e-3 # Used to be None - Changed for speed-up! tmpResults = sweep.sweep(saveDir,box,channel,width,delay,scope,min_volt) output_file.write("%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n"%(width, 0, tmpResults["pin"], tmpResults["pin error"], tmpResults["width"], tmpResults["width error"], tmpResults["rise"], tmpResults["rise error"], tmpResults["fall"], tmpResults["fall error"], tmpResults["area"], tmpResults["area error"], tmpResults["peak"], tmpResults["peak error"] )) print "WIDTH %d took : %1.1f s" % (width, time.time()-loopStart) output_file.close() print "Total script time : %1.1f mins"%( (time.time() - total_time) / 60)
output_file = file(output_filename,'w') output_file.write("#PWIDTH\tPIN\tWIDTH\tRISE\tFALL\tWIDTH\tAREA\n") #Start scanning! widths = range(cutoff-1500,cutoff+501,10) results = None sweep.set_port(options.port) sweep.set_scope("LeCroy") sweep.start() for width in widths: min_volt = None print time.time() if results!=None: #set a best guess for the trigger and the scale #using the last sweeps value min_volt = float(results["minimum"]) results = sweep.sweep("low_intensity",output_filename,box,channel,width,delay,scope,min_volt,min_trigger) output_file.write("%s\t%s\t%s\t%s\t%s\t%s\t%s\n"%(width, results["pin"], results["width"], results["rise"], results["fall"], results["width"], results["area"])) output_file.close()
nearest_neighbour_opt_curr_cost = 0 nearest_neighbour_opt_curr_time = 0 nearest_insertion_curr_cost = 0 nearest_insertion_curr_time = 0 farthest_insertion_curr_cost = 0 farthest_insertion_curr_time = 0 for i in range(n_means): print(" = Generating maps for " + str(dim) + " nodes =") current_map = generate_map(dim) # Uptating Sweep print("Generating sweep...") c, t, _ = sweep(current_map, generate_costs(current_map, 0), plot=False) sweep_curr_cost += c sweep_curr_time += t print("Sweep time: " + "{:.2f}".format(t)) # Uptating Nearest Neighbour print("Generating nearest neighbour...") c, t, _ = kNN(generate_costs(current_map, 0), 0) nearest_neighbour_curr_cost += c nearest_neighbour_curr_time += t print("Nearest neighbour time: " + "{:.2f}".format(t)) # Uptating Optimized Nearest Neighbour print("Generating optimized nearest neighbour...") c, t, _ = opt_kNN(generate_costs(current_map, 0))
def rf_sweep_temp( BW, Power, Freq, Temp, Logname): print "rf_sweep_temp" m = uut(ipaddr='10.8.8.100', opmode='master') #195 s = uut(ipaddr='10.8.8.108', opmode='slave') #196 m.telnet() s.telnet() m.web() s.web() t = None # is the thermotron required? if Temp[0] != Temp[1]: t = thermotron("10.8.9.20") print "thermotron" ctrl = control( m, s, t, 25) # <-- 25 second wait time csv = LogFile( 'logs',Logname, '.csv') #, ['11','22','33','44','55','66'] ) tdata = testdata( 0,0,0,'--') csv.write(tdata.header) thm = sweep( Temp[0], Temp[1], Temp[2], ctrl.settemp, file='thm') bw = sweep( BW[0], BW[1], BW[2], ctrl.setbw, file='bw') pwr = sweep( Power[0], Power[1], Power[2], ctrl.setpower, file='pwr') frq = sweep( Freq[0], Freq[1], Freq[2], ctrl.setfrequency, file='frq') thm.regen() temp = thm.next() print while temp: print "Temp" bw.regen() ChBW = bw.next() while ChBW : print "ChBW: ",ChBW frq.regen() delay = 25 freq = frq.next() while freq: print "Freq: ",freq delay = 25 pwr.regen() power = pwr.next() while power: if freq < 5750 and power >= 23: pwr.curval = None pwr.regen() break; print "Power: ",power ctrl.wait(delay) delay = 3 tdata = testdata( freq, power, ChBW, temp) tdata.wdata( m ) tdata.wdata( s ) csv.write(tdata.getcsv() ) # print tdata.header print tdata.getcsv() power = pwr.next() # reset power ctrl.setpower(pwr.start) freq = frq.next() ChBW = bw.next() temp = thm.next() print "Complete csv.close()" csv.close() bw.clean() pwr.clean() frq.clean() thm.clean()
import channels import numpy import sweep import channel_panel_gui import sweep_gui sw1 = sweep.sweep("D244_2Dsweep", [VG1, VG2], [I1], loops="2", updatepointbypoint=True) sw1.set_loops([0.1, 0.3, 0.05], 0) sw1.set_channel_factors([1, 1], 0) # sw1.add_final_coord([[0.2,0.4]],0) # sw1.add_final_coord([[0.4,0.2],[0.2,0.4]],1) sw1.set_loops([0, 0.2, 0.05], 1) sw1.set_channel_factors([0, 1], 1) # sw1.set_loops([0,0.2,0.05],2) # sw1.set_channel_factors([0,1,0],2) # sw1.set_loops([0,0.2,0.05],3) # sw1.set_channel_factors([0,1,0],3) sw1.set_channel_constants([0, 0]) channel_panel_gui.channel_panel([VSD, VG1, VG2, VG3]) sweep_gui.sweep_gui(sw1)
usb_conn = scope_connections.VisaUSB() scope = scopes.Tektronix3000(usb_conn) scope.set_cursor("x", 1, cursor_low) scope.set_cursor("x", 2, cursor_high) #Create a new, timestamped, summary file timestamp = time.strftime("%y%m%d_%H.%M.%S", time.gmtime()) output_filename = "broad/Box%02d_Channel%d_%s.dat" % (box, channel, timestamp) output_file = file(output_filename, 'w') output_file.write("#PWIDTH\tPIN\tWIDTH\tRISE\tFALL\tWIDTH\tAREA\n") #Start scanning! widths = range(0, cutoff + 501, 50) results = None for width in widths: min_volt = None if results != None: #set a best guess for the trigger and the scale #using the last sweeps value min_volt = float(results["minimum"]) results = sweep.sweep("broad", output_filename, box, channel, width, delay, scope, min_volt, min_trigger) output_file.write( "%s\t%s\t%s\t%s\t%s\t%s\t%s\n" % (width, results["pin"], results["width"], results["rise"], results["fall"], results["width"], results["area"])) output_file.close()
def __init__(self, fname=None, write_waveforms=True, quiet=True): c = configparser.ConfigParser() self.quiet = quiet if fname is not None: if os.path.exists(fname): if not quiet: print("reading %s" % (fname)) c.read(fname) else: print("configuration file %s doesn't exist." % (fname)) exit(0) self.fname = fname self.instrument_name = json.loads(c["config"]["instrument_name"]) self.n_range_gates = int(json.loads(c["config"]["n_range_gates"])) self.station_id = json.loads(c["config"]["station_id"]) self.lat = int(json.loads(c["config"]["lat"])) self.lon = int(json.loads(c["config"]["lon"])) self.require_gps = bool(json.loads(c["config"]["require_gps"])) self.save_raw_voltage = bool( json.loads(c["config"]["save_raw_voltage"])) self.min_gps_lock_time = json.loads(c["config"]["min_gps_lock_time"]) self.rx_channel = json.loads(c["config"]["rx_channel"]) self.sample_rate = int(json.loads(c["config"]["sample_rate"])) self.dec = int(json.loads(c["config"]["dec"])) self.data_dir = json.loads(c["config"]["data_dir"]) self.range_shift = int(json.loads(c["config"]["range_shift"])) # self.codes=json.loads(c["config"]["codes"]) self.short_name = json.loads(c["config"]["short_name"]) self.code_len = json.loads(c["config"]["code_len"]) self.code_types = json.loads(c["config"]["code_type"]) self.pulse_lengths = json.loads(c["config"]["pulse_length"]) self.ipps = json.loads(c["config"]["ipp"]) self.bws = json.loads(c["config"]["bw"]) if not quiet: print("Creating waveforms") self.n_codes = len(self.code_types) self.codes = [] self.orig_codes = [] for i in range(self.n_codes): if self.pulse_lengths[i] > 0: if n.mod(int(self.code_len), int(self.ipps[i])) != 0: print("Code length %d must be a multiple of IPP %d." " This is not the case. Exiting." % (self.code_len, self.ipps[i])) exit(0) # todo. we should avoid dumping the waveforms to files # for all but debugging purposes. the waveforms # created here (ocode) should be directly fed into sweep. cfname, ocode = create_waveform.waveform_to_file( station=self.station_id, clen=self.code_len, oversample=self.dec, filter_output=True, sr=self.sample_rate, bandwidth=self.bws[i], power_outside_band=0.01, pulse_length=self.pulse_lengths[i], ipp=self.ipps[i], code_type=self.code_types[i], write_file=write_waveforms) self.codes.append(cfname) self.orig_codes.append(ocode) self.freqs = json.loads(c["config"]["freqs"]) self.n_freqs = len(self.freqs) for fi in range(len(self.freqs)): # center frequency self.freqs[fi][0] = float(self.freqs[fi][0]) # code index self.freqs[fi][1] = int(self.freqs[fi][1]) self.transmit_amplitude = float( json.loads(c["config"]["transmit_amplitude"])) self.frequency_duration = float( json.loads(c["config"]["frequency_duration"])) if n.mod(int(self.frequency_duration * self.sample_rate), int(self.code_len * self.dec)) != 0: print( "frequency_duration (%1.2f s) needs to be a multiple of code_length (%1.2f s)" % (self.frequency_duration, self.code_len * self.dec / self.sample_rate)) exit(0) self.antenna_select_freq = float( json.loads(c["config"]["antenna_select_freq"])) self.max_plot_range = float(json.loads(c["config"]["max_plot_range"])) self.gps_holdover_time = float( json.loads(c["config"]["gps_holdover_time"])) self.max_plot_dB = float(json.loads(c["config"]["max_plot_dB"])) self.tx_addr = json.loads(c["config"]["tx_addr"]) self.rx_addr = json.loads(c["config"]["rx_addr"]) self.tx_subdev = json.loads(c["config"]["tx_subdev"]) self.rx_subdev = json.loads(c["config"]["rx_subdev"]) self.ionogram_path = json.loads(c["config"]["ionogram_path"]) self.ionogram_dirname = json.loads(c["config"]["ionogram_dirname"]) self.reflected_power_cal_dB = json.loads( c["config"]["reflected_power_cal_dB"]) try: os.mkdir(self.ionogram_path) except Exception as e: pass if not os.path.exists(self.ionogram_path): print("Output directory %s doesn't exists and cannot be created" % (self.ionogram_path)) exit(0) try: os.mkdir(self.ionogram_path) except Exception as e: pass if not os.path.exists(self.data_dir): print("Output directory %s doesn't exists and cannot be created" % (self.data_dir)) exit(0) self.s = sweep.sweep( freqs=self.freqs, codes=self.codes, sample_rate=self.sample_rate, code_amp=self. transmit_amplitude, # safe setting for waveform amplitude freq_dur=self.frequency_duration)
saveDir = sweep.check_dir("data/scope_data_%1.2fV/" % float(options.voltage)) sweep.check_dir("%sraw_data/" % saveDir) output_filename = "%s/Chan%02d_%1.2fV.dat" % (saveDir,channel,float(options.voltage)) output_file = file(output_filename,'w') output_file.write("#PWIDTH\tPWIDTH Error\tPIN\tPIN Error\tWIDTH\tWIDTH Error\tRISE\tRISE Error\tFALL\t\ FALL Error\tAREA\tAREA Error\tMinimum\tMinimum Error\n") flag, tmpResults, min_volt = 0, None, None run_start = time.time() for width in widths: loop_start = time.time() if tmpResults!=None: #set a best guess for the trigger and the scale #using the last sweeps value min_volt = float(tmpResults["peak"]) tmpResults = sweep.sweep(saveDir,1,channel,width,pulse_delay_ms,scope,min_volt) output_file.write("%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n"%(width, 0, tmpResults["pin"], 0, tmpResults["width"], tmpResults["width error"], tmpResults["rise"], tmpResults["rise error"], tmpResults["fall"], tmpResults["fall error"], tmpResults["area"], tmpResults["area error"], tmpResults["peak"], tmpResults["peak error"] )) print "WIDTH %d took : %1.1f s" % (width, time.time()-loop_start) output_file.close() print "Total script time : %1.1f mins"%( (time.time() - total_time) / 60)
def __init__(self, fname=None, write_waveforms=True, quiet=True): c = configparser.ConfigParser() self.quiet = quiet if fname != None: if os.path.exists(fname): if not quiet: print("reading %s" % (fname)) c.read(fname) else: print("configuration file %s doesn't exist." % (fname)) exit(0) self.fname = fname self.instrument_name = json.loads(c["config"]["instrument_name"]) self.n_range_gates = int(json.loads(c["config"]["n_range_gates"])) self.station_id = json.loads(c["config"]["station_id"]) self.lat = int(json.loads(c["config"]["lat"])) self.lon = int(json.loads(c["config"]["lon"])) self.require_gps = bool(json.loads(c["config"]["require_gps"])) self.save_raw_voltage = bool( json.loads(c["config"]["save_raw_voltage"])) self.min_gps_lock_time = json.loads(c["config"]["min_gps_lock_time"]) self.rx_channel = json.loads(c["config"]["rx_channel"]) self.sample_rate = int(json.loads(c["config"]["sample_rate"])) self.dec = int(json.loads(c["config"]["dec"])) self.data_dir = json.loads(c["config"]["data_dir"]) self.range_shift = int(json.loads(c["config"]["range_shift"])) # self.codes=json.loads(c["config"]["codes"]) self.short_name = json.loads(c["config"]["short_name"]) self.code_len = json.loads(c["config"]["code_len"]) self.code_types = json.loads(c["config"]["code_type"]) self.pulse_lengths = json.loads(c["config"]["pulse_length"]) self.ipps = json.loads(c["config"]["ipp"]) self.bws = json.loads(c["config"]["bw"]) if not quiet: print("Creating waveforms") self.n_codes = len(self.code_types) self.codes = [] self.orig_codes = [] for i in range(self.n_codes): cfname, ocode = create_waveform.waveform_to_file( station=self.station_id, clen=self.code_len, oversample=self.dec, filter_output=True, sr=self.sample_rate, bandwidth=self.bws[i], power_outside_band=0.01, pulse_length=self.pulse_lengths[i], ipp=self.ipps[i], code_type=self.code_types[i], write_file=write_waveforms) self.codes.append(cfname) self.orig_codes.append(ocode) self.freqs = json.loads(c["config"]["freqs"]) self.n_freqs = len(self.freqs) for fi in range(len(self.freqs)): # center frequency self.freqs[fi][0] = float(self.freqs[fi][0]) # code index self.freqs[fi][1] = int(self.freqs[fi][1]) self.transmit_amplitude = float( json.loads(c["config"]["transmit_amplitude"])) self.frequency_duration = json.loads(c["config"]["frequency_duration"]) self.antenna_select_freq = float( json.loads(c["config"]["antenna_select_freq"])) self.gps_holdover_time = float( json.loads(c["config"]["gps_holdover_time"])) self.tx_addr = json.loads(c["config"]["tx_addr"]) self.rx_addr = json.loads(c["config"]["rx_addr"]) self.tx_subdev = json.loads(c["config"]["tx_subdev"]) self.rx_subdev = json.loads(c["config"]["rx_subdev"]) self.ionogram_path = json.loads(c["config"]["ionogram_path"]) self.reflected_power_cal_dB = json.loads( c["config"]["reflected_power_cal_dB"]) try: os.mkdir(self.ionogram_path) except: pass if not os.path.exists(self.ionogram_path): print("Output directory %s doesn't exists and cannot be created" % (self.ionogram_path)) exit(0) try: os.mkdir(self.ionogram_path) except: pass if not os.path.exists(self.data_dir): print("Output directory %s doesn't exists and cannot be created" % (self.data_dir)) exit(0) self.s = sweep.sweep( freqs=self.freqs, codes=self.codes, sample_rate=self.sample_rate, code_amp=self. transmit_amplitude, # safe setting for waveform amplitude freq_dur=self.frequency_duration)
scope.set_cursor("x",2,cursor_high) #Create a new, timestamped, summary file timestamp = time.strftime("%y%m%d_%H.%M.%S",time.gmtime()) output_filename = "broad/Box%02d_Channel%d_%s.dat" % (box,channel,timestamp) output_file = file(output_filename,'w') output_file.write("#PWIDTH\tPIN\tWIDTH\tRISE\tFALL\tWIDTH\tAREA\n") #Start scanning! widths = range(0,cutoff+501,50) results = None for width in widths: min_volt = None if results!=None: #set a best guess for the trigger and the scale #using the last sweeps value min_volt = float(results["minimum"]) results = sweep.sweep("broad",output_filename,box,channel,width,delay,scope,min_volt,min_trigger) output_file.write("%s\t%s\t%s\t%s\t%s\t%s\t%s\n"%(width, results["pin"], results["width"], results["rise"], results["fall"], results["width"], results["area"])) output_file.close()
# Change log # Need to add a button for reset # Need to add a button for sweep # Need to add a button for ultrasonic transmit from Tkinter import * import project3 import sweep p = project3.project3() s = sweep.sweep() def spin_servo(): p.set_vals(x.get(), y.get()) root.after(100,spin_servo) root = Tk() y = Scale(root, from_=65535, to=0) y.pack(anchor=CENTER) x = Scale(root, from_=0, to=65535, orient=HORIZONTAL) x.pack(anchor=CENTER) Button(root, text='Sweep', command=s.move).pack() #Button(root, text = 'Stop Sweep',command=s.stop).pack() root.after(100,spin_servo) root.mainloop()
#Start scanning! #widths = range(0,9000,step) widths = range(0, 10000, step) tmpResults = None t_start = time.time() for width in widths: min_volt = None loopStart = time.time() if tmpResults != None: #set a best guess for the trigger and the scale #using the last sweeps value min_volt = float(tmpResults["peak"]) if min_volt == 0: # If bad data set, make none min_volt = 50e-3 # Used to be None - changed for speed up! tmpResults = sweep.sweep(saveDir, box, channel, width, delay, scope, min_volt) #results.set_meta_data("area", tmpResults["area"]) #results.set_meta_data("area error", tmpResults["area error"]) output_file.write( "%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n" % (width, 0, tmpResults["pin"], tmpResults["pin error"], tmpResults["width"], tmpResults["width error"], tmpResults["rise"], tmpResults["rise error"], tmpResults["fall"], tmpResults["fall error"], tmpResults["area"], tmpResults["area error"], tmpResults["peak"], tmpResults["peak error"])) print "WIDTH %d took : %1.1f s" % (width, time.time() - loopStart)
qt_dir = "D:/qtlab_replacement" sys.path.append(qt_dir) import init from instruments import * import sweep import time CS_Vlim = 10. currents = arange(0, -0.5, -0.005) pna = Agilent_N5242A('pna', address='pna') #cs = Yokogawa_GS210(address='gs210') rm = visa.ResourceManager() CS = rm.open_resource("2651") CS.write('''smua.source.func = smua.OUTPUT_DCAMPS; smua.source.limitv = {:f}; smua.source.autorangei = smua.AUTORANGE_ON; smua.source.leveli = 0; smua.source.output = smua.OUTPUT_ON; '''.format(CS_Vlim)) def set_current(I): CS.write("smua.source.leveli = {:e}".format(I)) time.sleep(10) sweep.sweep(pna, (currents, set_current, 'Current'), filename='test') #cs.set_current(0) CS.write('''smua.source.leveli = 0; smua.source.output = smua.OUTPUT_OFF;''')
def characterize_location(ls): sweep_val = sweep.sweep() print("finished sweep") for i in range(len(ls.sig)): ls.sig[i] = sweep_val[i]
def generate_loss_wrt_optimum(): # Creating the document from_mode = '' doc = Document('latex_tables/generated_loss_wrt_optimum') section = Section("Table of Costs") from_mode = "{:.2f}" # Setting tabular property tabular_header = 'cccccc' # Creation of the Table table = Tabular(tabular_header) table.add_row((MultiColumn(6, align='c', data='Costs'), )) table.add_hline() table.add_hline() table.add_row(['ID'] + supported_algorithms) table.add_hline() # Iterating for each map with respect to the wind map_index = 1 for current_map in maps: for current_wind in winds: # We catch the correct algorithm to use tot_cost_0, _, _ = sweep(current_map, generate_costs(current_map, current_wind), plot=False) tot_cost_1, _, _ = kNN(generate_costs(current_map, current_wind), 0) tot_cost_2, _, _ = opt_kNN( generate_costs(current_map, current_wind)) tot_cost_3, _, _ = nearest_insertion( generate_costs(current_map, current_wind)) tot_cost_4, _, _ = farthest_insertion( generate_costs(current_map, current_wind)) # The row with the data is written onto a new row and the index is incremented print(map_index) table.add_row( (map_index, "{:.2f}".format( ((tot_cost_0 / real_optimum[map_index - 1]) - 1) * 100) + '%', "{:.2f}".format( ((tot_cost_1 / real_optimum[map_index - 1]) - 1) * 100) + '%', "{:.2f}".format( ((tot_cost_2 / real_optimum[map_index - 1]) - 1) * 100) + '%', "{:.2f}".format( ((tot_cost_3 / real_optimum[map_index - 1]) - 1) * 100) + '%', "{:.2f}".format( ((tot_cost_4 / real_optimum[map_index - 1]) - 1) * 100) + '%')) map_index += 1 # We close the table table.add_hline() # And finally we compose and generate the new document with the embedded table section.append(table) doc.append(section) doc.generate_tex()
currents = arange(-1, 1, 0.01) * 1e-3 pna_preset = True cs = Yokogawa_GS210(address='GPIB0::2::INSTR') pna = Agilent_N5242A('pna', address='pna') cs.set_range(1e-3) pna.set_sweep_mode("LIN") if pna_preset: pna.set_nop(400) pna.set_power(-30.) pna.set_bandwidth(200) pna.set_centerfreq(6.6644e9) pna.set_span(50e6) cs.set_status(1) def set_current(val): cs.set_current(0.) time.sleep(0.02) cs.set_current(val) sweep.sweep(pna, (currents, set_current, 'Current')) cs.set_current(0.) cs.set_status(0) pna.close()
require_gps = True # minimum safe wait is 5 mins min_gps_lock_time = 300 # gps acquisition time can be reduced for testing purposes min_gps_lock_time = 0 # sweep definition # todo: add code definition here. if True: s = sweep.sweep( freqs=sweep.freqstiming, codes=[ "waveforms/code-l10000-b10-000000f_100k.bin", "waveforms/code-l10000-b10-000000f_50k.bin", "waveforms/code-l10000-b10-000000f_30k.bin" ], sample_rate=sample_rate, code_amp=0.8, # safe setting for waveform amplitude freq_dur=4.0) # single frequency test if False: s = sweep.sweep(freqs=[[5.305, 5.335, 0]], codes=["waveforms/code-l10000-b10-000000f_30k.bin"], code_amp=0.5, freq_dur=60.0) # This is for OBW measurements # ram disk to store about two ionosonde cycles worth of data data_path = "/media/data"