def load_experimental_data(self): # time correction factor c_t = 1 / (10 * 60) # 1 / (min * s/min) # power correction factor c_p = 250 / 1E5 # 250 W(th) / 100 kW(th) # detector efficiency e = 1 c_e = 1 / e # combine into one constant c = c_t * c_p * c_e spectrum_data = np.loadtxt('nai_gamma_spectrum.tka', skiprows=1) * c self.exp_gamma_raw = Spectrum(self.channels, spectrum_data) bg_data = np.loadtxt('background.tka', skiprows=1) * c self.background = Spectrum(self.channels, bg_data) true_data = spectrum_data - bg_data * c self.exp_gamma = Spectrum(self.channels, true_data)
def main(): dirname = sys.argv[1] data = [] parameter = [] for filename in iglob(dirname + '/*.wav'): print(filename) sig, rate = read(filename, sr=16000) sig = (sig - np.mean(sig)) / np.var(sig) sp, yphase = Spectrum(sig, 512, 256, 512, 2) data.append(sp) parameter.append([yphase, filename.replace(dirname, '')]) with open(sys.argv[2] + '_parameter.txt', 'wb') as fp: pickle.dump(parameter, fp) with open(sys.argv[2] + '.txt', 'wb') as fp: pickle.dump(data, fp)
def __init__(self, instrument, distance=10.0, spec_path=None, exozodi_level=1.0, spec_reso=1e5): self.distance = distance self.instrument = instrument self.exozodi_level = exozodi_level #Level of zodi relative to Solar System self.spec_path = spec_path self.spec_reso = spec_reso self.spec_data = self.sumZodiFlux().data self.wavelength = self.spec_data["Wavelength"] self.flux = self.spec_data["Flux"] self.spectrum = Spectrum(self.wavelength, self.flux, spec_reso=self.spec_reso)
def main(grammar, failed_tests, passed_tests) : """ """ prepare = Preparation(grammar,failed_tests, passed_tests) # get the represention of rules and tests rules = prepare.get_rules() failed = prepare.construct_matrix("failed") total_failed = failed.shape[1] passed = prepare.construct_matrix("passed") total_passed = passed.shape[1] # print(total_passed) failed_counts = prepare.basic_counts(failed) passed_counts = prepare.basic_counts(passed) # print(passed_counts) spectrum = Spectrum(failed_counts, passed_counts, total_failed, total_passed) scores = spectrum.compute_suspiciousness() spit_csv(rules, scores)
def load_theoretical_data(self): # scale56 bin structure self.scale56 = np.loadtxt('scale56.txt') * 1E3 # normalize to keV # calculate normalization tally_area = tally_area = np.pi * (1.27**2) tally_area = 1 # for now not considering the tally area c = 8.32 / (200 * 1.60218e-13 * tally_area) c *= 250 # normalize to 250 W(th) # load theoretical gamma data data = np.loadtxt('gdata_total.txt') data = data.T[1][1:] data *= c # create spectrum self.the_gamma = Spectrum(self.scale56, data)
def interpolateSpectrum(self, pointDict): """ Interpoalte on grid spectra in given parameters return spectrum object """ if self.gridParams is None: print("First load GRID") return None surAll = self.findSurronding(pointDict) if surAll is None: print("Spectrum (%.0f %.2f %.2f %.1f) out of grid" % (pointDict["teff"], pointDict["logg"], pointDict["me"], pointDict["vmic"])) return None point = [pointDict[k] for k in self.paramsList] data = [] wave = self.wave for single in surAll: for i, (s, f) in enumerate(zip(self.gridParams, self.allFiles)): #print(s ,single) if np.array_equal(single, s): spec = pd.read_csv( f, header=None, delim_whitespace=True, comment=self.comments, skiprows=self.skipRows, ) flux = spec[self.fluxColumn].values if not self.ifCommonWavelength: #TODO: this needs to be tested if wave is None: wave = spec[self.waveColumn].values else: flux = np.interp(wave, spec[self.waveColumn].values, spec[self.fluxColumn].values) data.append(flux) interpFlux = self.multilinearInterpolation(surAll, data, point) return Spectrum(wave=self.wave, flux=interpFlux)
def loadRawCalibrationSpectrum(): image_name = "test/test_image_cal.fits" try: spec = Spectrum(image_name) except SpectrumError as e: message = "{}\nLoad error".format(e) return message, None if spec is None: return message, None extracted_spectrum = np.genfromtxt("test/test_image_cal_extracted.dat", names=True) try: spec.setExtractedSpectrum(extracted_spectrum["spectrum"]) except SpectrumError as e: message = "{}\nLoad error".format(e) return message, None return "Load successful", spec
def _parse_ms_file(self, f_path): # print "Parse file:",f_path # read ms/ms file in f = open(f_path) data = f.read() f.close() # create Spectrum instance spectrum = Spectrum(f_path) # set f_name spectrum.f_name = f_path # set metlin id spectrum.metlin_id = f_path[f_path.find("pos") + 3:f_path.find(".")] # set precursor _precursor = re.findall("parentmass[: ]+([0-9\.]+)", data) if len(_precursor) > 0: precursor = float(_precursor[0]) else: raise Exception("ERROR: precursor not set for %s!" % f_path) spectrum.precursor = precursor spectrum.mass = precursor - 1.00794 # set peaks and intensity _peaks = [] seg = False for line in data.split('\n'): if line.find("collision") != -1: seg = True continue if not line: seg = False continue if seg: words = line.split() mass = float(words[0]) inten = float(words[1]) _peaks.append((mass, inten)) spectrum.peaks = _peaks return spectrum
def extract_spectra(self, description_field='', verbose=True): u""" Extract spectra from source imagery and creates well-defined spectrum objects. """ # extracting spectra as simple lists spectra = gdal_utils.extract_spectra(self.img_src, self.extract_locations, neighborhood=self.neighborhood, verbose=verbose, bad_bands=self.bad_bands, scale_factor=self.slope, nb_type=self.neighborhood_type) # converting lists to spectrum objects # defining list of all extracted spectra # iterating over location/spectrum pairs for cp, sp in zip(self.extract_locations, spectra): # retrieving location id if cp.has_key('attributes'): additional_attributes = cp['attributes'].keys() additional_attributes.remove(self.loc_id_field) loc_id = cp[self.loc_id_field] # creating new spectrum object using location id and according coordinates spectrum = Spectrum(loc_id, (cp['x'], cp['y'])) for aa in additional_attributes: spectrum.set_attribute(aa, cp['attributes'][aa]) spectrum.set_neighborhood(self.neighborhood) spectrum.set_neighborhood_type(self.neighborhood_type) spectrum.set_source(self.img_id) if description_field: spectrum.set_description(cp[description_field]) # adding values to spectrum for gb, val in zip(self.good_bands, sp): spectrum.set_value(gb, val) # adding values of bad bands to spectrum for bb in self.bad_bands: spectrum.set_invalid(bb) # adding current spectrum to list of all extracted spectra self.spectra.append(spectrum)
def __init__(self, distance=10.0, spec_path=None, inclination_deg=90.0, rotation_vel=5e3, radial_vel=1e4, spec_reso=1e5): self.distance = distance self.spec_path = spec_path self.spec_reso = spec_reso if self.spec_path != None: self.spec_data = pyfits.open(self.spec_path)[1].data self.wavelength = self.spec_data["Wavelength"] self.flux = self.spec_data["Flux"] self.spectrum = Spectrum(self.wavelength, self.flux, spec_reso=self.spec_reso) self.spec_header = pyfits.open(self.spec_path)[1].header self.PHXREFF = self.spec_header["PHXREFF"] self.inclination_deg = inclination_deg self.rotation_vel = rotation_vel self.radial_vel = radial_vel
def plot_cf252(): """Docstring.""" # load data flux = cf252_source() eb = energy_groups('scale252') # spectrum object for ease of plotting spec = Spectrum(eb, flux, 0) # setup plotting environment fig = plt.figure(0) ax = fig.add_subplot(111) ax.set_xlim(0, 20) #ax.set_yscale('log') ax.set_xlabel('Energy $MeV$') ax.set_ylabel('Spectrum') # plot ax.plot(*spec.plot('plot', 'diff')) # save fig.savefig('plot/cf252.png', dpi=300)
def read_spectra(paragraphs, formatter): """ Read the spectra data from a list of .docx paragraphs and return a list of `Spectrum` objects. :param paragraphs: a list of `Paragraph` objects. :param formatter: a `Formatter` object used to parse the raw data. :return: a list of `Spectrum` objects. """ r_spectra = [] for i, paragraph in enumerate(paragraphs): if paragraph.text.split(' ')[0] == 'Spectrum:': # This keyword signals that the next paragraphs contains the actual # spectrum data. r_spectra.append( (paragraph.text.rstrip().replace('Spectrum: ', ''), paragraphs[i + 1])) # Store the cypher given after the keyword and the spectrum # itself as a tuple of raw data, itself appended to a list of # raw data. print('Number of located spectra: {}.\n'.format(len(r_spectra))) spectra = [] # The list to store processed spectra. for r_spectrum in r_spectra: spectrum = Spectrum(r_spectrum, formatter) # Build a `Spectrum` # object for each tuple # in the list of raw data. print(spectrum) spectra.append(spectrum) # Save each `Spectrum` object into a list. for signal in spectrum.signals: print(signal) print('\n') return spectra
def compose_speclist( speclist: List[ Spectrum ], namestring: str = "" ) -> Spectrum: """ Forms a composite spectrum from the given input spectra :param speclist: List of Spectrum to compose :param namestring: Namestring to assign to the composite. Defaults to "" :type speclist: list :type namestring: str :return: Composite Spectrum :rtype: Spectrum """ from numpy import std, mean joined = { } composite = Spectrum( ns=namestring ) for spec in speclist: for wl in spec: if wl not in joined: joined[ wl ] = list() joined[ wl ].append( spec.get( wl ) ) wavelength_list = [ ] fluxlist = [ ] errlist = [ ] for wl, v in joined.items(): wavelength_list.append( wl ) if len( v ) > 1: fluxlist.append( mean( [ f[ 0 ] for f in v ] ) ) errlist.append( std( [ e[ 1 ] for e in v ] ) ) else: fluxlist.append( v[ 0 ][ 0 ] ) errlist.append( v[ 0 ][ 1 ] ) composite.setDict( wavelength_list, fluxlist, errlist ) return composite
ax.set_xticklabels(np.around(all_SNR)) ax.set_yticklabels(np.around(all_SR)) # ax.set_title(title) plt.savefig('fig/' + filename + '-heatmap.pdf', bbox_inches='tight') # set the scenarios weathers = ['clear', 'cloudy'] times = ['0.0', '0.8', '2.0', '3.9'] scenarios = it.product(times, weathers) # load data from disk, and put into 'spectra' spectra = [] for scenario in scenarios: wl, flux, label = getflux(scenario, convert_to_photons=True) new_spectrum = Spectrum(wl, flux, label) spectra.append(new_spectrum) # to increase preformance for high-res original spectra, # resample them with moderate resolution for i, spectrum in enumerate(spectra): spectrum.resample(lam_min=4.05, lam_max=19.99, n_bins=1000, overwrite_original=True) spectrum_set = SpectrumSet(spectra) # set up experiment designs exptimes = [400, 1000, 4000] all_n_bins = np.arange(2, 200, 1)
def _parse_massbank_file(self, f_path): print "Parse file:", f_path # read ms/ms file in f = open(f_path) data = f.read() f.close() # create Spectrum instance spectrum = Spectrum(f_path) # set f_name spectrum.f_name = f_path # set precursor _precursor = re.findall( "MS\$FOCUSED_ION: PRECURSOR_M/Z[: ]+([0-9\.]+)", data) if len(_precursor) > 0: precursor = float(_precursor[0]) else: _basepeak = re.findall("MS\$FOCUSED_ION: BASE_PEAK[: ]+([0-9\.]+)", data) if len(_basepeak) > 0: print("WARNING: using base peak as precursor for %s!" % f_path) precursor = float(_basepeak[0]) else: raise Exception("ERROR: precursor not set for %s!" % f_path) spectrum.precursor = precursor # set ion mode _mode = re.findall("ION_MODE ([A-Z]+)", data) if len(_mode) > 0: mode = _mode[0] else: _mode = re.findall("MODE ([A-Z]+)", data) if len(_mode) > 0: print("WARNING: ion mode is set by MODE for %s!" % f_path) mode = _mode[0] else: raise Exception("ERROR: mode not set for %s!" % f_path) spectrum.mode = mode if spectrum.mode == 'POSITIVE': spectrum.mass = spectrum.precursor - 1.00794 else: spectrum.mass = spectrum.precursor + 1.00794 _ppm = re.findall("SE\$SEARCH_PPM[: ]+([0-9\.]+)", data) if len(_ppm) > 0: ppm = int(_ppm[0]) else: raise Exception("ERROR: PPM not set for %s!" % f_path) spectrum.ppm = ppm # set peaks _peaks = [] lines = data.split("\n") ready = False for line in lines: if len(line) == 0: continue if line.find("PK$PEAK") != -1: ready = True continue if ready: if line.find("N/A") != -1: raise Exception("ERROR: no peaks in %s" % f_path) words = line.split() mass = float(words[0]) inten = float(words[1]) #mass = mass+numpy.random.normal(0,1e-8,1) # add noise #mass = float("%.3f" % mass) _peaks.append((mass, inten)) spectrum.peaks = _peaks _ce = re.findall("COLLISION_ENERGY (\w+)", data) if len(_ce) > 0: ce = _ce[0] ce = ce.replace("eV", "") if ce.isdigit(): spectrum.ce = int(ce) return spectrum
rcParams['ytick.direction'] = 'out' rcParams['xtick.labelsize'] = 12 rcParams['ytick.labelsize'] = 12 rcParams['lines.linewidth'] = 1.85 rcParams['axes.labelsize'] = 15 rcParams.update({'figure.autolayout': True}) nebp = FluxNEBP(250) R = response_matrix f_i = nebp.values N = unfiltered1.values sig = unfiltered1.error sol = iterate(f_i, N, sig, R) solution = Spectrum(nebp.edges, sol) from_gravel = unfolded_data['e1_ne_gr'] def sample(responses, errors): l = len(responses) sampled_response = np.zeros(l) for i in range(l): resp = responses[i] err = errors[i] fun = norm(loc=resp, scale=err) rho = rand() sampled_response[i] = fun.ppf(rho) return sampled_response
from spectrum import Spectrum import os #path to where files are written to overallpath = '/Users/pohno/Box Sync/Science/Data/SFG/Solstice/11192017' #name where summedTruncatedData is written to name = 'flowrun2.txt' #path where the data is stored path = '/Users/pohno/Box Sync/Science/Data/SFG/Solstice/11192017/caf2_water/run2' #create object, loads each sample and background DFG spec = Spectrum(path) #change directory in case files are written os.chdir(overallpath) #plot pre cosmic ray removal spec.plotDFGs() spec.plotBGs() #remove cosmic rays spec.removeCRs(50) #plot after cosmic ray removal spec.plotDFGs() spec.plotBGs()
def __main__(): #initDict = readInit(init_file="SunEarth_4m.init") initDict = readInit(init_file="TMT_SuperEarth_N.init") wav_min, wav_max, t_exp = np.float32(initDict["wav_min"]), np.float32( initDict["wav_max"]), np.float32(initDict["t_exp"]) target_pl = Target(distance=np.float32(initDict["distance"]), spec_path=initDict["pl_spec_path"], inclination_deg=np.float32( initDict["pl_inclination_deg"]), rotation_vel=np.float32(initDict["pl_rotation_vel"]), radial_vel=np.float32(initDict["pl_radial_vel"]), spec_reso=np.float32(initDict["spec_reso"])) target_st = Target(distance=np.float32(initDict["distance"]), spec_path=initDict["st_spec_path"], inclination_deg=np.float32( initDict["st_inclination_deg"]), rotation_vel=np.float32(initDict["st_rotation_vel"]), radial_vel=np.float32(initDict["st_radial_vel"]), spec_reso=np.float32(initDict["spec_reso"])) wav_med = (wav_min + wav_max) / 2.0 if initDict["spec_tran_path"] != "None": atmosphere = Atmosphere(spec_tran_path=initDict["spec_tran_path"], spec_radi_path=initDict["spec_radi_path"]) else: atmosphere = None instrument = Instrument( wav_med, telescope_size=np.float32(initDict["telescope_size"]), pl_st_contrast=np.float32(initDict["pl_st_contrast"]), spec_reso=np.float32(initDict["spec_reso"]), read_noise=np.float32(initDict["read_noise"]), dark_current=np.float32(initDict["dark_current"]), fiber_size=np.float32(initDict["fiber_size"]), pixel_sampling=np.float32(initDict["pixel_sampling"]), throughput=np.float32(initDict["throughput"]), wfc_residual=np.float32(initDict["wfc_residual"]), num_surfaces=np.float32(initDict["num_surfaces"]), temperature=np.float32(initDict["temperature"])) thermal_background = ThermTarget(instrument, spec_reso=np.float32( initDict["spec_reso"])) zodi = ZodiTarget(instrument, distance=np.float32(initDict["distance"]), spec_path=initDict["zodi_spec_path"], exozodi_level=np.float32(initDict["exozodi_level"]), spec_reso=np.float32(initDict["spec_reso"])) hci_hrs = HCI_HRS_Observation(wav_min, wav_max, t_exp, target_pl, target_st, instrument, thermal_background, zodi, atmosphere=atmosphere) print( "Star flux: {0} \nLeaked star flux: {1}\nPlanet flux: {2}\nPlanet flux per pixel: {3}\nThermal background flux: {4}\nThermal background flux per pixel: {5}\nSky flux: {6}\nSky flux per pixel: {7}\nSky transmission: {8}\nTotal pixel number: {9}\n" .format( hci_hrs.star_total_flux, hci_hrs.star_total_flux * instrument.pl_st_contrast, hci_hrs.planet_total_flux, hci_hrs.planet_total_flux / (len(hci_hrs.obs_spec_resample.flux) + 0.0), hci_hrs.therm_total_flux, hci_hrs.therm_total_flux / (len(hci_hrs.obs_therm_resample.flux) + 0.0), hci_hrs.sky_total_flux, hci_hrs.sky_total_flux / (len(hci_hrs.obs_therm_resample.flux) + 0.0), hci_hrs.sky_transmission, len(hci_hrs.obs_therm_resample.flux))) spec = pyfits.open(initDict["template_path"]) template = Spectrum(spec[1].data["Wavelength"], spec[1].data["Flux"], spec_reso=np.float32(initDict["spec_reso"])) if initDict["spec_tran_path"] != "None": hci_hrs_red = HCI_HRS_Reduction(hci_hrs, template, save_flag=False, obj_tag=initDict["obj_tag"], template_tag=initDict["template_tag"], speckle_flag=False) else: hci_hrs_red = HCI_HRS_Reduction(hci_hrs, template, save_flag=False, obj_tag=initDict["obj_tag"], template_tag=initDict["template_tag"], speckle_flag=True)
n = 1000000 for i in range(n): ind1, ind2 = randint(0, 7), randint(0, 7) score = loaded[ind1] + loaded[ind2] loaded_count[score - 1] += 1 for i in range(n): ind1, ind2 = randint(0, 6), randint(0, 6) score = fair[ind1] + fair[ind2] fair_count[score - 1] += 1 loaded_count = loaded_count / n fair_count = fair_count / n edges = np.array(range(13)) + 0.5 loaded_data = Spectrum(edges[1:], loaded_count[1:]) fair_data = Spectrum(edges[1:], fair_count[1:]) var = 0 for i, val in enumerate(loaded_count[1:]): var += (7 - (i + 2))**2 * val print('The variance is: {}'.format(var)) # plotting fig = plt.figure(999, figsize=(9.62, 5.08)) ax = fig.add_subplot(111) ax.plot(loaded_data.step_x, loaded_data.step_y, label='Loaded Dice', color='darkblue')
def main(): for run_number in range(0, 1): print 'Run number {}'.format(run_number) sim_data = [] for scenario_choice in ['a', 'b']: for vcs in [True, False]: for lambda_a, lambda_c in lambda_vals: print 'Starting with scenario {} for vcs {}. Lambda A = {} and Lambda C = {}.'.format( scenario_choice, vcs, lambda_a, lambda_c) # Initializing scenario A if scenario_choice == 'a': station_a = Station('A', lambda_a, 'Sender', backoff_range, total_slots, slot_duration) station_b = Station('B', 0, 'Receiver', backoff_range, total_slots, slot_duration) station_c = Station('C', lambda_c, 'Sender', backoff_range, total_slots, slot_duration) station_d = Station('D', 0, 'Receiver', backoff_range, total_slots, slot_duration) station_a.set_station_communicating(station_b) station_b.set_station_communicating(station_a) station_c.set_station_communicating(station_d) station_d.set_station_communicating(station_c) station_a.set_collision_domain( [station_b, station_c, station_d]) station_b.set_collision_domain( [station_a, station_c, station_d]) station_c.set_collision_domain( [station_a, station_b, station_d]) station_d.set_collision_domain( [station_a, station_b, station_c]) spectrum = Spectrum() scenario = Scenario( [station_a, station_b, station_c, station_d], spectrum, vcs, scenario_choice) # Initializing scenario B if scenario_choice == 'b': station_a = Station('A', lambda_a, 'Sender', backoff_range, total_slots, slot_duration) station_b = Station('B', 0, 'Receiver', backoff_range, total_slots, slot_duration) station_c = Station('C', lambda_c, 'Sender', backoff_range, total_slots, slot_duration) station_a.set_station_communicating(station_b) station_b.set_station_communicating(station_a) station_c.set_station_communicating(station_b) station_a.set_collision_domain([station_b]) station_b.set_collision_domain([station_a, station_c]) station_c.set_collision_domain([station_b]) spectrum = Spectrum() scenario = Scenario([station_a, station_b, station_c], spectrum, vcs, scenario_choice) for slot_num in range(0, total_slots): prepare_transmitting_stations( scenario.sending_stations, slot_num ) # Checking to see if a node is trying to send a packet at a given slot. check_difs_counters( scenario.sending_stations ) # Checking to see if the difs counter for any node is 0 to start the backoff. check_backoff_counters( scenario.sending_stations, scenario.spectrum, scenario.vcs ) # Checking to see if the backoff counter for any node is 0 so we can send a packet. if scenario.vcs: check_RTS_counter( scenario.spectrum, scenario.sending_stations ) # if we are using VCS, check the RTS counter check_CTS_counter( scenario.spectrum, scenario.sending_stations ) # if we are using VCS, check the CTS counter check_data_counters( scenario.spectrum, scenario.sending_stations ) # Checking to see if the data counter is done. check_sifs_counters( scenario.sending_stations, scenario.spectrum ) # Checking to see if the sifs counter for any node is 0 to free the medium. check_ack_counters( scenario.spectrum, scenario.sending_stations ) # Checking to see if the awk counter is done. end_of_slot( scenario ) # Decreasing all counters in the scenario. # DEBUG information # try: # print 'On slot {}'.format(slot_num) # print 'A next time slot: {}'.format(station_a.time_slots[0]) # print 'A difs counter: {}'.format(station_a.difs_counter) # print 'A backoff counter: {}'.format(station_a.backoff) # print 'A data counter: {}'.format(station_a.data_counter) # print 'A sifs counter: {}'.format(station_a.sifs_counter) # print 'A ack counter: {}'.format(station_a.ack_counter) # print 'A rts counter: {}'.format(station_a.rts_counter) # print 'A cts counter: {}'.format(station_a.cts_counter) # print 'A wait times: {}'.format(station_a.wait_time) # print 'C next time slot: {}'.format(station_c.time_slots[0]) # print 'C difs counter: {}'.format(station_c.difs_counter) # print 'C backoff counter: {}'.format(station_c.backoff) # print 'C data counter: {}'.format(station_c.data_counter) # print 'C sifs counter: {}'.format(station_c.sifs_counter) # print 'C ack counter: {}'.format(station_c.ack_counter) # print 'C rts counter: {}'.format(station_c.rts_counter) # print 'C cts counter: {}'.format(station_c.cts_counter) # print 'C wait times: {}'.format(station_c.wait_time) # print 'Spectrum List:' # for a in spectrum.sending_station: # print a.name # print 'Spectrum status: {}\n'.format(spectrum.status) # except IndexError, e: # print 'No more data to send. Breaking' # break # print 'A {}\nC {}\nDIV: {}\n\n'.format(station_a.slots_transmitting, station_c.slots_transmitting, station_a.slots_transmitting / float(station_c.slots_transmitting)) single_sim_data = { # using hash table to record all of the information of a single simulation 'lambda_a': lambda_a, 'lambda_c': lambda_c, 'a_collisions': station_a.num_collisions, 'c_collisions': station_c.num_collisions, 'a_throughput': station_a.num_data_transmit / float(simulation_time), 'c_throughput': station_c.num_data_transmit / float(simulation_time), 'a_slots_transmitting': station_a.slots_transmitting, 'c_slots_transmitting': station_c.slots_transmitting, 'FI': station_a.slots_transmitting / float(station_c.slots_transmitting), 'vcs': vcs, 'scenario': scenario_choice } sim_data.append(single_sim_data) # print single_sim_data for sim in sim_data: print sim plt.figure(0) plt.figure(figsize=(8, 8)) x_vals = [ sim['lambda_c'] for sim in sim_data if sim['lambda_a'] == sim['lambda_c'] and sim['vcs'] and sim['scenario'] == 'a' ] no_vcs_a_y_vals = [ sim['a_throughput'] for sim in sim_data if sim['lambda_a'] == sim['lambda_c'] and not sim['vcs'] and sim['scenario'] == 'a' ] vcs_a_y_vals = [ sim['a_throughput'] for sim in sim_data if sim['lambda_a'] == sim['lambda_c'] and sim['vcs'] and sim['scenario'] == 'a' ] no_vcs_b_y_vals = [ sim['a_throughput'] for sim in sim_data if sim['lambda_a'] == sim['lambda_c'] and not sim['vcs'] and sim['scenario'] == 'b' ] vcs_b_y_vals = [ sim['a_throughput'] for sim in sim_data if sim['lambda_a'] == sim['lambda_c'] and sim['vcs'] and sim['scenario'] == 'b' ] plt.plot(x_vals, no_vcs_a_y_vals, '-bo', linewidth=2.0, markersize=10, label='Scenario A CSMA') plt.plot(x_vals, vcs_a_y_vals, '-rs', linewidth=2.0, markersize=10, label='Scenario A CSMA w. Virtual Sensing') plt.plot(x_vals, no_vcs_b_y_vals, '-g+', linewidth=2.0, markersize=10, label='Scenario B CSMA') plt.plot(x_vals, vcs_b_y_vals, '-kx', linewidth=2.0, markersize=10, label='Scenario B CSMA w. Virtual Sensing') plt.legend(loc=2, markerscale=0.8, prop={'size': 8}) plt.xlim((45, 305)) plt.ylabel(r'$T$ (Kbps)') plt.xlabel(r'$\lambda$ (frames/sec)') plt.title( r'1.a Node A: Throughput $T$ (Kbps) vs Rate $\lambda$ (frames/sec)' ) plt.savefig('fig1-a' + str(run_number) + '.png') plt.figure(1) plt.figure(figsize=(8, 8)) x_vals = [ sim['lambda_c'] for sim in sim_data if sim['lambda_a'] == sim['lambda_c'] and sim['vcs'] and sim['scenario'] == 'a' ] no_vcs_a_y_vals = [ sim['c_throughput'] for sim in sim_data if sim['lambda_a'] == sim['lambda_c'] and not sim['vcs'] and sim['scenario'] == 'a' ] vcs_a_y_vals = [ sim['c_throughput'] for sim in sim_data if sim['lambda_a'] == sim['lambda_c'] and sim['vcs'] and sim['scenario'] == 'a' ] no_vcs_b_y_vals = [ sim['c_throughput'] for sim in sim_data if sim['lambda_a'] == sim['lambda_c'] and not sim['vcs'] and sim['scenario'] == 'b' ] vcs_b_y_vals = [ sim['c_throughput'] for sim in sim_data if sim['lambda_a'] == sim['lambda_c'] and sim['vcs'] and sim['scenario'] == 'b' ] plt.plot(x_vals, no_vcs_a_y_vals, '-bo', linewidth=2.0, markersize=10, label='Scenario A CSMA') plt.plot(x_vals, vcs_a_y_vals, '-rs', linewidth=2.0, markersize=10, label='Scenario A CSMA w. Virtual Sensing') plt.plot(x_vals, no_vcs_b_y_vals, '-g+', linewidth=2.0, markersize=10, label='Scenario B CSMA') plt.plot(x_vals, vcs_b_y_vals, '-kx', linewidth=2.0, markersize=10, label='Scenario B CSMA w. Virtual Sensing') plt.legend(loc=2, markerscale=0.8, prop={'size': 8}) plt.xlim((45, 305)) plt.ylabel(r'$T$ (Kbps)') plt.xlabel(r'$\lambda$ (frames/sec)') plt.title( r'1.b Node C: Throughput $T$ (Kbps) vs Rate $\lambda$ (frames/sec)' ) plt.savefig('fig1-b' + str(run_number) + '.png') plt.figure(2) plt.figure(figsize=(8, 8)) x_vals = [ sim['lambda_c'] for sim in sim_data if sim['lambda_a'] == ( 2 * sim['lambda_c']) and sim['vcs'] and sim['scenario'] == 'a' ] no_vcs_a_y_vals = [ sim['a_throughput'] for sim in sim_data if sim['lambda_a'] == (2 * sim['lambda_c']) and not sim['vcs'] and sim['scenario'] == 'a' ] vcs_a_y_vals = [ sim['a_throughput'] for sim in sim_data if sim['lambda_a'] == ( 2 * sim['lambda_c']) and sim['vcs'] and sim['scenario'] == 'a' ] no_vcs_b_y_vals = [ sim['a_throughput'] for sim in sim_data if sim['lambda_a'] == (2 * sim['lambda_c']) and not sim['vcs'] and sim['scenario'] == 'b' ] vcs_b_y_vals = [ sim['a_throughput'] for sim in sim_data if sim['lambda_a'] == ( 2 * sim['lambda_c']) and sim['vcs'] and sim['scenario'] == 'b' ] plt.plot(x_vals, no_vcs_a_y_vals, '-bo', linewidth=2.0, markersize=10, label='Scenario A CSMA') plt.plot(x_vals, vcs_a_y_vals, '-rs', linewidth=2.0, markersize=10, label='Scenario A CSMA w. Virtual Sensing') plt.plot(x_vals, no_vcs_b_y_vals, '-g+', linewidth=2.0, markersize=10, label='Scenario B CSMA') plt.plot(x_vals, vcs_b_y_vals, '-kx', linewidth=2.0, markersize=10, label='Scenario B CSMA w. Virtual Sensing') plt.legend(loc=2, markerscale=0.8, prop={'size': 8}) plt.xlim((45, 305)) plt.ylabel(r'$T$ (Kbps)') plt.xlabel(r'$\lambda$ (frames/sec)') plt.title( r'1.c Node A: Throughput $T$ (Kbps) vs Rate $\lambda$ (frames/sec) when $\lambda$A = 2$\lambda$C' ) plt.savefig('fig1-c' + str(run_number) + '.png') plt.figure(3) plt.figure(figsize=(8, 8)) x_vals = [ sim['lambda_c'] for sim in sim_data if sim['lambda_a'] == ( 2 * sim['lambda_c']) and sim['vcs'] and sim['scenario'] == 'a' ] no_vcs_a_y_vals = [ sim['c_throughput'] for sim in sim_data if sim['lambda_a'] == (2 * sim['lambda_c']) and not sim['vcs'] and sim['scenario'] == 'a' ] vcs_a_y_vals = [ sim['c_throughput'] for sim in sim_data if sim['lambda_a'] == ( 2 * sim['lambda_c']) and sim['vcs'] and sim['scenario'] == 'a' ] no_vcs_b_y_vals = [ sim['c_throughput'] for sim in sim_data if sim['lambda_a'] == (2 * sim['lambda_c']) and not sim['vcs'] and sim['scenario'] == 'b' ] vcs_b_y_vals = [ sim['c_throughput'] for sim in sim_data if sim['lambda_a'] == ( 2 * sim['lambda_c']) and sim['vcs'] and sim['scenario'] == 'b' ] plt.plot(x_vals, no_vcs_a_y_vals, '-bo', linewidth=2.0, markersize=10, label='Scenario A CSMA') plt.plot(x_vals, vcs_a_y_vals, '-rs', linewidth=2.0, markersize=10, label='Scenario A CSMA w. Virtual Sensing') plt.plot(x_vals, no_vcs_b_y_vals, '-g+', linewidth=2.0, markersize=10, label='Scenario B CSMA') plt.plot(x_vals, vcs_b_y_vals, '-kx', linewidth=2.0, markersize=10, label='Scenario B CSMA w. Virtual Sensing') plt.legend(loc=2, markerscale=0.8, prop={'size': 8}) plt.xlim((45, 305)) plt.ylabel(r'$T$ (Kbps)') plt.xlabel(r'$\lambda$ (frames/sec)') plt.title( r'1.d Node C: Throughput $T$ (Kbps) vs Rate $\lambda$ (frames/sec) when $\lambda$A = 2$\lambda$C' ) plt.savefig('fig1-d' + str(run_number) + '.png') plt.figure(4) plt.figure(figsize=(8, 8)) x_vals = [ sim['lambda_c'] for sim in sim_data if sim['lambda_c'] == sim['lambda_a'] and sim['vcs'] and sim['scenario'] == 'a' ] no_vcs_a_y_vals = [ sim['a_collisions'] for sim in sim_data if sim['lambda_a'] == sim['lambda_c'] and not sim['vcs'] and sim['scenario'] == 'a' ] vcs_a_y_vals = [ sim['a_collisions'] for sim in sim_data if sim['lambda_a'] == sim['lambda_c'] and sim['vcs'] and sim['scenario'] == 'a' ] no_vcs_b_y_vals = [ sim['a_collisions'] for sim in sim_data if sim['lambda_a'] == sim['lambda_c'] and not sim['vcs'] and sim['scenario'] == 'b' ] vcs_b_y_vals = [ sim['a_collisions'] for sim in sim_data if sim['lambda_a'] == sim['lambda_c'] and sim['vcs'] and sim['scenario'] == 'b' ] plt.plot(x_vals, no_vcs_a_y_vals, '-bo', linewidth=2.0, markersize=10, label='Scenario A CSMA') plt.plot(x_vals, vcs_a_y_vals, '-rs', linewidth=2.0, markersize=10, label='Scenario A CSMA w. Virtual Sensing') plt.plot(x_vals, no_vcs_b_y_vals, '-g+', linewidth=2.0, markersize=10, label='Scenario B CSMA') plt.plot(x_vals, vcs_b_y_vals, '-kx', linewidth=2.0, markersize=10, label='Scenario B CSMA w. Virtual Sensing') plt.legend(loc=2, markerscale=0.8, prop={'size': 8}) plt.xlim((45, 305)) plt.ylabel(r'$N$ (Number of Collisions)') plt.xlabel(r'$\lambda$ (frames/sec)') plt.title( r'2.a Node A: Number of Collisions $N$ vs Rate $\lambda$ (frames/sec)' ) plt.savefig('fig2-a' + str(run_number) + '.png') plt.figure(5) plt.figure(figsize=(8, 8)) x_vals = [ sim['lambda_c'] for sim in sim_data if sim['lambda_a'] == sim['lambda_c'] and sim['vcs'] and sim['scenario'] == 'a' ] no_vcs_a_y_vals = [ sim['c_collisions'] for sim in sim_data if sim['lambda_a'] == sim['lambda_c'] and not sim['vcs'] and sim['scenario'] == 'a' ] vcs_a_y_vals = [ sim['c_collisions'] for sim in sim_data if sim['lambda_a'] == sim['lambda_c'] and sim['vcs'] and sim['scenario'] == 'a' ] no_vcs_b_y_vals = [ sim['c_collisions'] for sim in sim_data if sim['lambda_a'] == sim['lambda_c'] and not sim['vcs'] and sim['scenario'] == 'b' ] vcs_b_y_vals = [ sim['c_collisions'] for sim in sim_data if sim['lambda_a'] == sim['lambda_c'] and sim['vcs'] and sim['scenario'] == 'b' ] plt.plot(x_vals, no_vcs_a_y_vals, '-bo', linewidth=2.0, markersize=10, label='Scenario A CSMA') plt.plot(x_vals, vcs_a_y_vals, '-rs', linewidth=2.0, markersize=10, label='Scenario A CSMA w. Virtual Sensing') plt.plot(x_vals, no_vcs_b_y_vals, '-g+', linewidth=2.0, markersize=10, label='Scenario B CSMA') plt.plot(x_vals, vcs_b_y_vals, '-kx', linewidth=2.0, markersize=10, label='Scenario B CSMA w. Virtual Sensing') plt.legend(loc=2, markerscale=0.8, prop={'size': 8}) plt.xlim((45, 305)) plt.ylabel(r'$N$ (Number of Collisions)') plt.xlabel(r'$\lambda$ (frames/sec)') plt.title( r'2.b Node C: Number of Collisions $N$ vs Rate $\lambda$ (frames/sec)' ) plt.savefig('fig2-b' + str(run_number) + '.png') plt.figure(6) plt.figure(figsize=(8, 8)) x_vals = [ sim['lambda_c'] for sim in sim_data if sim['lambda_a'] == ( 2 * sim['lambda_c']) and sim['vcs'] and sim['scenario'] == 'a' ] no_vcs_a_y_vals = [ sim['a_collisions'] for sim in sim_data if sim['lambda_a'] == (2 * sim['lambda_c']) and not sim['vcs'] and sim['scenario'] == 'a' ] vcs_a_y_vals = [ sim['a_collisions'] for sim in sim_data if sim['lambda_a'] == ( 2 * sim['lambda_c']) and sim['vcs'] and sim['scenario'] == 'a' ] no_vcs_b_y_vals = [ sim['a_collisions'] for sim in sim_data if sim['lambda_a'] == (2 * sim['lambda_c']) and not sim['vcs'] and sim['scenario'] == 'b' ] vcs_b_y_vals = [ sim['a_collisions'] for sim in sim_data if sim['lambda_a'] == ( 2 * sim['lambda_c']) and sim['vcs'] and sim['scenario'] == 'b' ] plt.plot(x_vals, no_vcs_a_y_vals, '-bo', linewidth=2.0, markersize=10, label='Scenario A CSMA') plt.plot(x_vals, vcs_a_y_vals, '-rs', linewidth=2.0, markersize=10, label='Scenario A CSMA w. Virtual Sensing') plt.plot(x_vals, no_vcs_b_y_vals, '-g+', linewidth=2.0, markersize=10, label='Scenario B CSMA') plt.plot(x_vals, vcs_b_y_vals, '-kx', linewidth=2.0, markersize=10, label='Scenario B CSMA w. Virtual Sensing') plt.legend(loc=2, markerscale=0.8, prop={'size': 8}) plt.xlim((45, 305)) plt.ylabel(r'$T$ (Kbps)') plt.xlabel(r'$\lambda$ (frames/sec)') plt.title( r'2.c Node A: Number of Collisions $N$ vs Rate $\lambda$ (frames/sec) when $\lambda$A = 2$\lambda$C' ) plt.savefig('fig2-c' + str(run_number) + '.png') plt.figure(7) plt.figure(figsize=(8, 8)) x_vals = [ sim['lambda_c'] for sim in sim_data if sim['lambda_a'] == ( 2 * sim['lambda_c']) and sim['vcs'] and sim['scenario'] == 'a' ] no_vcs_a_y_vals = [ sim['c_collisions'] for sim in sim_data if sim['lambda_a'] == (2 * sim['lambda_c']) and not sim['vcs'] and sim['scenario'] == 'a' ] vcs_a_y_vals = [ sim['c_collisions'] for sim in sim_data if sim['lambda_a'] == ( 2 * sim['lambda_c']) and sim['vcs'] and sim['scenario'] == 'a' ] no_vcs_b_y_vals = [ sim['c_collisions'] for sim in sim_data if sim['lambda_a'] == (2 * sim['lambda_c']) and not sim['vcs'] and sim['scenario'] == 'b' ] vcs_b_y_vals = [ sim['c_collisions'] for sim in sim_data if sim['lambda_a'] == ( 2 * sim['lambda_c']) and sim['vcs'] and sim['scenario'] == 'b' ] plt.plot(x_vals, no_vcs_a_y_vals, '-bo', linewidth=2.0, markersize=10, label='Scenario A CSMA') plt.plot(x_vals, vcs_a_y_vals, '-rs', linewidth=2.0, markersize=10, label='Scenario A CSMA w. Virtual Sensing') plt.plot(x_vals, no_vcs_b_y_vals, '-g+', linewidth=2.0, markersize=10, label='Scenario B CSMA') plt.plot(x_vals, vcs_b_y_vals, '-kx', linewidth=2.0, markersize=10, label='Scenario B CSMA w. Virtual Sensing') plt.legend(loc=2, markerscale=0.8, prop={'size': 8}) plt.xlim((45, 305)) plt.ylabel(r'$T$ (Kbps)') plt.xlabel(r'$\lambda$ (frames/sec)') plt.title( r'2.d Node C: Number of Collisions $N$ vs Rate $\lambda$ (frames/sec) when $\lambda$A = 2$\lambda$C' ) plt.savefig('fig2-d' + str(run_number) + '.png') plt.figure(8) plt.figure(figsize=(8, 8)) x_vals = [ sim['lambda_c'] for sim in sim_data if sim['lambda_a'] == sim['lambda_c'] and sim['vcs'] and sim['scenario'] == 'a' ] y_vals_a = [ sim['FI'] for sim in sim_data if sim['lambda_a'] == sim['lambda_c'] and not sim['vcs'] and sim['scenario'] == 'a' ] y_vals_b = [ sim['FI'] for sim in sim_data if sim['lambda_a'] == sim['lambda_c'] and not sim['vcs'] and sim['scenario'] == 'b' ] vcs_y_vals_a = [ sim['FI'] for sim in sim_data if sim['lambda_a'] == sim['lambda_c'] and sim['vcs'] and sim['scenario'] == 'a' ] vcs_y_vals_b = [ sim['FI'] for sim in sim_data if sim['lambda_a'] == sim['lambda_c'] and sim['vcs'] and sim['scenario'] == 'b' ] plt.plot(x_vals, y_vals_a, '-bo', linewidth=2.0, markersize=10, label='Scenario A CSMA') plt.plot(x_vals, vcs_y_vals_a, '-rs', linewidth=2.0, markersize=10, label='Scenario A CSMA w. Virtual Sensing') plt.plot(x_vals, y_vals_b, '-g+', linewidth=2.0, markersize=10, label='Scenario B CSMA') plt.plot(x_vals, vcs_y_vals_b, '-kx', linewidth=2.0, markersize=10, label='Scenario B CSMA w. Virtual Sensing') plt.legend(loc=2, markerscale=0.8, prop={'size': 8}) plt.xlim((45, 305)) plt.ylabel(r'$FI$ (Fairness Index)') plt.xlabel(r'$\lambda$ (frames/sec)') plt.title('3.a Fairness Index') plt.savefig('fig3-a' + str(run_number) + '.png') plt.figure(9) plt.figure(figsize=(8, 8)) x_vals = [ sim['lambda_c'] for sim in sim_data if sim['lambda_a'] == ( 2 * sim['lambda_c']) and sim['vcs'] and sim['scenario'] == 'a' ] y_vals_a = [ sim['FI'] for sim in sim_data if sim['lambda_a'] == (2 * sim['lambda_c']) and not sim['vcs'] and sim['scenario'] == 'a' ] y_vals_b = [ sim['FI'] for sim in sim_data if sim['lambda_a'] == (2 * sim['lambda_c']) and not sim['vcs'] and sim['scenario'] == 'b' ] vcs_y_vals_a = [ sim['FI'] for sim in sim_data if sim['lambda_a'] == ( 2 * sim['lambda_c']) and sim['vcs'] and sim['scenario'] == 'a' ] vcs_y_vals_b = [ sim['FI'] for sim in sim_data if sim['lambda_a'] == ( 2 * sim['lambda_c']) and sim['vcs'] and sim['scenario'] == 'b' ] plt.plot(x_vals, y_vals_a, '-bo', linewidth=2.0, markersize=10, label='Scenario A CSMA') plt.plot(x_vals, vcs_y_vals_a, '-rs', linewidth=2.0, markersize=10, label='Scenario A CSMA w. Virtual Sensing') plt.plot(x_vals, y_vals_b, '-g+', linewidth=2.0, markersize=10, label='Scenario B CSMA') plt.plot(x_vals, vcs_y_vals_b, '-kx', linewidth=2.0, markersize=10, label='Scenario B CSMA w. Virtual Sensing') plt.legend(loc=2, markerscale=0.8, prop={'size': 8}) plt.xlim((45, 305)) plt.ylabel(r'$T$ (Kbps)') plt.xlabel(r'$\lambda$ (frames/sec)') plt.title(r'3.b Fairness Index when $\lambda$A = 2$\lambda$C') plt.savefig('fig3-b' + str(run_number) + '.png') #plt.show() plt.close('all') print 'DONE\n'
def fit_spec_loader(path: str, filename: str, mask_dict: dict = DEF_MASK_DICT) -> Spectrum: """ Loads a FIT spectrum file from SDSS DR 7 or lower. Converts it into Spectrum type. Note: error_dict has the actual mask values as keys. Loader will iterate through these keys and delete any points where these keys are found. The dict format is an artifact where the values attached to each key are the SDSS error names in text. :param path: /path/to/file :param filename: filename.fits :param mask_dict: Defaults to DEF_ERR_DICT defined in this file if not passed :type path: str :type filename: str :type mask_dict: dict :rtype: Spectrum """ from astropy.io.fits import getheader, getdata from fileio.utils import fileCheck, join from catalog import shenCat fileCheck(path, filename) shenCat.load() infile = join(path, filename) # Assemble basic info from the header # Check if the HW redshift is included in the shenCat. If so, assign it, # otherwise use the one in the file header = getheader(infile, 0) namestring = "%05i-%04i-%03i" % (header['MJD'], header['PLATEID'], header['FIBERID']) z = shenCat.subkey(namestring, 'z') if namestring in shenCat else float( header['z']) gmag = float(header['MAG'].split()[1]) # Stored as UGRIZ data = getdata(infile, 0) flux_data = data[0].tolist( ) # first apertrure is the calibrated spectrum flux density # data[ 1 ] is the continuum-subtracted spectrum. Not of interest err_data = data[2].tolist() # third is the +/- of flux denisty mask_data = data[3].tolist() # error mask # Wavelength values are not stored in FIT files. Only three values are available, and these are used to # generate the wavelengths which correspond to the pixels # i.e. wl[ pixel 0 ] -> flux density[ 0 ], error[ 0 ], mask[ 0 ], etc # # Those 3 values are: # naxis1 : number of pixels stored # coeff0 : Log10 of the first wavelength # coeff1 : Log10 of the dispersion coefficient # # Log10( wavelengths ) are generated by the function: log_wl_n( n ) = c0 + c1 * n # where n is the nth pixel # Then the wavelength, in angstroms is given 10^(log_wl_n) c0 = header['coeff0'] c1 = header['coeff1'] num_pixels = header['naxis1'] # The actual wavelength generation happens here wavelengths = [pow(10, c0 + c1 * n) for n in num_pixels] out_spec = Spectrum(namestring=namestring, z=z, gmag=gmag) out_spec.setDict(wavelengths, flux_data, err_data) # Mask out the errors for i in range(len(err_data)): if __bit_mask(mask_data[i], mask_dict): del out_spec[wavelengths[i]] return out_spec
def collapse_rfs(edge_indices): """Docstring""" # get response functions responses = response_data() # check edge_indices are a list assert type(edge_indices) is list # check that the indices are in increasing order pass # check that the indices are in the rfs pass # add a zero to the front of the edge_indices edge_indices.insert(0, 0) # loop through rfs for name, response in responses.items(): # pull out the data edges, values, error = response.edges, response.int, response.int_error # create new structures for the values and errors new_edges = np.zeros(len(edge_indices)) new_values, new_error = [ np.zeros(len(edge_indices) - 1) for _ in range(2) ] # calculate the weights of each bin weights = response.widths # sum over the bounds with the weighting for i in range(len(edge_indices) - 1): # put the edge in the new edges new_edges[i] = edges[edge_indices[i]] # find the fraction of the total response that makes up the bin total_fraction = np.sum( weights[edge_indices[i]:edge_indices[i + 1] + 1]) # calculate the weighted average and store new_values[i] = np.sum( values[edge_indices[i]:edge_indices[i + 1] + 1] * weights[edge_indices[i]:edge_indices[i + 1] + 1]) / total_fraction # root sum squared of the errors new_error[i] = np.sqrt( np.sum((error[edge_indices[i]:edge_indices[i + 1] + 1] * weights[edge_indices[i]:edge_indices[i + 1] + 1])** 2)) / total_fraction # add the final edge (missed by the looping) new_edges[-1] = edges[edge_indices[-1]] # store the collapsed data responses[name] = Spectrum(new_edges, new_values, new_error, form='int') # return the data return responses
def get_spectra(self): import util xpeaks = self.__find_peaks() image_length = self.image_data.shape[1] start_pixel = 1000 yvalues_at_start = xpeaks[start_pixel] self.num_spectra = len(yvalues_at_start) xthreshold = 5 ythreshold = 2 cur_num_spectra = 0 # Going from right to left for num, y in enumerate(yvalues_at_start): cur_y = y s = Spectrum([], [], self) cur_x = start_pixel for next_spec_x in range(start_pixel + 1, image_length): check_y = xpeaks[next_spec_x] # Check for xpixels to see if there exists a y pixel that's less # than some value away. spec_indices = np.where(abs(cur_y - check_y) <= ythreshold)[0] if len(spec_indices) > 0: next_ind = spec_indices[0] nexty = check_y[next_ind] s.add_peak(next_spec_x, nexty) cur_x = next_spec_x cur_y = nexty if abs(next_spec_x - cur_x) >= xthreshold: break cur_x = start_pixel cur_y = y for prev_spec_x in range(start_pixel - 1, 0, -1): check_y = xpeaks[prev_spec_x] spec_indices = np.where(abs(cur_y - check_y) <= ythreshold)[0] if len(spec_indices) > 0: prev_ind = spec_indices[0] prevy = check_y[prev_ind] s.add_peak(prev_spec_x, prevy) cur_x = prev_spec_x cur_y = prevy if abs(prev_spec_x - cur_x) >= xthreshold: break build_prep_success = s.build_prepare() if build_prep_success: cur_num_spectra += 1 self.spectra.append(s) print("Spectrum %d/%d ready for building..." % (cur_num_spectra, self.num_spectra)) else: self.num_spectra -= 1 self.__fit_overlap_boundary_parabola() self.__update_spectral_boundaries() built_spectra = [] cur_num_spectra = 0 for spectrum in self.spectra: build_success = spectrum.build() if build_success: cur_num_spectra += 1 built_spectra.append(spectrum) print("Building spectrum %d/%d" % (cur_num_spectra, self.num_spectra)) print("Min x:", spectrum.xvalues[0], "\nMax x:", spectrum.xvalues[-1]) else: self.num_spectra -= 1 self.spectra = built_spectra
import argparse from spectrum import Spectrum parser = argparse.ArgumentParser(description="A script to demonstrate an SDSS spectrum fits file handler.",\ usage="handler_demo.py --filename spec-xxxx-xxxxx-xxxx.fits") parser.add_argument("-f", "--filename", help="The spectrum fits file to read.", default=10, required=True) args = parser.parse_args() spectrum_file = args.filename spectrum = Spectrum(spectrum_file) object_type = spectrum.object_type redshift = spectrum.redshift.z velocity = spectrum.redshift.velocity distance = spectrum.redshift.distance print(f"\n-------------\nObject Type\n-------------\n{object_type}") print(f"\n--------\nRedshift\n--------\n{redshift}") print(f"\n------------------------\nVelocity (from redshift)\n------------------------\n{velocity}") print(f"\n------------------------\nDistance (from redshift)\n------------------------\n{distance}") print("\n-----------\nLuminosity\n-----------") for l in spectrum.luminosity[:5]: print(l) print("\n----\nInfo\n----") print(spectrum.display_info()) print("\n---------\nHeader 1\n---------") print(spectrum.display_headers(1)) <<<<<<< HEAD #spectrum.plot_spectrum(show=True, plotlines=None) # for no lines
def make_shot_list(self, shot_l): for i in range(0, len(shot_l)): tmp_spec = Spectrum() tmp_spec.populate(int(shot_l[i][0:8]), int(shot_l[i][9:]), 'black_comet_200_600', 'txt_file') self.shot_list.append(tmp_spec)
else: in_field = gaussian(X, Y, 1.0, w, x0=0, y0=0).astype(np.complex64) in_field /= np.sqrt(power(in_field)) ISL = 3e8 / (2 * (d1 + d2)) # Free Spectral Range print('Computing fields.') fields = get_fields(np.sqrt(1 - R) * in_field, cavity_fun, 50) # take at least 2*finesse print('Fields computed.') print('Memory used : {:.0f} Mb'.format(fields.nbytes / 1e6)) r = N // 2**7 reduced_fields = np.copy( fields[::r, ::r, :]) * r # We reduce the number of points, so renormalize s = Spectrum(lambda phase: power_at_phase(reduced_fields, phase) ) # faster to compute the spectrum than using # all the preceeding points print('Computing resonances.') resonance_phases = s.compute_resonances(n_res=1, gain_thres=0.3) print('Resonances computed.') limits = (resonance_phases[0] - np.pi, resonance_phases[0] + np.pi) phases, spectrum = s.spectrum() print('resonances = ', resonance_phases) # *** Plot some cuts of the cavity fields *** plt.rcParams['figure.figsize'] = (14.0, 6.0) plt.rcParams['font.size'] = 18
#sets the y variable as the 4th column and x as the second column of the data y = data[1:, 4] x = data[:, 1] #function that locates the peaks of the data peak_indices = signal.find_peaks_cwt(y, np.arange(1, 150), min_length=100, noise_perc=50) peak_x = [] peak_y = [] for i in peak_indices: peak_x.append(x[i]) peak_y.append(data[i, 4]) graph = Spectrum(x, y) plt.plot(graph.stepu_x, graph.stepu_y) plt.plot(peak_x, peak_y, 'ko') plt.xlabel('Energy') plt.ylabel('Net CR') plt.suptitle(foil) plt.show() #sums the area under each peak and relays that with the given energy peak peak_data = [] for i in peak_indices: peak_data.append((x[i], np.sum(y[i - 20:i + 20]))) for d in peak_data: print(d)
import matplotlib.pyplot as plt from spectrum import Spectrum plt.rc('text', usetex=True) plt.rc('font', family='serif', size=15) line = 'H1215' #line = 'OVI1031' spectrum_file_uvb = f'/disk04/sapple/cgm/absorption/ml_project/data/normal/m100n1024_s50_151/sample_galaxy_195_{line}_0_deg_0.25r200.h5' spectrum_file_no_uvb = f'/disk04/sapple/cgm/absorption/ml_project/data/no_uvb/m100n1024_s50_151/sample_galaxy_195_{line}_0_deg_0.25r200.h5' spec_uvb = Spectrum(spectrum_file_uvb) spec_no_uvb = Spectrum(spectrum_file_no_uvb) fig, ax = plt.subplots(2, 1, figsize=(10, 10)) ax = ax.flatten() ax[0].plot(spec_uvb.velocities, np.log10(spec_uvb.taus), label='Collisional + UVB') ax[0].legend(loc=1) ax[0].set_ylabel(r'$\tau $') ax[1].plot(spec_no_uvb.velocities, np.log10(spec_no_uvb.taus), label='Collisional only') ax[1].legend(loc=4) ax[1].set_xlabel('Velocity (km/s)') ax[1].set_ylabel(r'$\tau $') if line == 'H1215': ax[0].set_ylim(-6, 6) ax[1].set_ylim(-6, 6) elif line == 'OVI1031': ax[0].set_ylim(-15, 2) ax[1].set_ylim(-15, 2)
#!/usr/bin/python env import sys sys.path.append('../') from spectrum import Spectrum example_spectrum = '../test/spectrum.fits' a = Spectrum(example_spectrum) ### # Begin print('\n\nThis is a demo for the Spectrum class.') print('\n\n###################') print('# Initialisation #') print('###################') print(f'\nThe SDSS spectrum fits file "{example_spectrum}" \n'+ \ 'has been loaded into the Spectrum class and \n'+ \ 'initiated using the variable "a":\n\n'+ \ f'>>>a = Spectrum("{example_spectrum}")') print('\nSeveral variables from the header are already \n'+ \ 'initialised and can be called as follows:\n'+ \ '>>>a.ra\n'+ \ '>>>a.dec\n'+ \ '>>>a.mjd') print('')
def multi_readout_analyze(folder, ccd_height=100., plot=True, freq=None): """Analyze several readout measurements in different files for readout diagnosys The readout files in dm3 format must be contained in a folder, preferentely numered in the order of acquisition. Parameters ---------- folder : string Folder where the dm3 readout files are stored ccd_heigh : float plot : bool freq : float Frequency of the camera Returns ------- Dictionary """ from spectrum import Spectrum files = glob.glob1(folder, '*.nc') if not files: files = glob.glob1(folder, '*.dm3') spectra = [] variances = [] binnings = [] for f in files: print os.path.join(folder, f) s = Spectrum(os.path.join(folder, f)) variance, channel_mean, norm_time_mean = analyze_readout(s) s.readout_analysis = {} s.readout_analysis['variance'] = variance.mean() s.readout_analysis['pattern'] = channel_mean s.readout_analysis['time'] = norm_time_mean if not hasattr(s, 'binning'): s.binning = float(os.path.splitext(f)[0][1:]) if freq: s.readout_frequency = freq s.ccd_height = ccd_height s.save(f) spectra.append(s) binnings.append(s.binning) variances.append(variance.mean()) pixels = ccd_height / np.array(binnings) plt.scatter(pixels, variances, label='data') fit = np.polyfit(pixels, variances, 1, full=True) if plot: x = np.linspace(0, pixels.max(), 100) y = x * fit[0][0] + fit[0][1] plt.plot(x, y, label='linear fit') plt.xlabel('number of pixels') plt.ylabel('variance') plt.legend(loc='upper left') print "Variance = %s * pixels + %s" % (fit[0][0], fit[0][1]) dictio = { 'pixels': pixels, 'variances': variances, 'fit': fit, 'spectra': spectra } return dictio