def draw_plot( ref , test): img = Image.new('RGB',(640,260),color=(80,80,80)) draw = ImageDraw.Draw(img) cmf = observer.ColorMatchingFunction() sl = locus.SpectralLocus(cmf) draw_plot_field(img, draw,sl) handle = open('resources/cie_x.json','r') X = spectrum.Spectrum() X.from_file(handle) handle.close() handle = open('resources/cie_y.json','r') Y = spectrum.Spectrum() Y.from_file(handle) handle.close() handle = open('resources/cie_z.json','r') Z = spectrum.Spectrum() Z.from_file(handle) handle.close() #scale = plot_spectrum(img, draw, Z, (0,0,255, 255), 0.85, 0.0) #plot_spectrum(img, draw, Y, (0,255,0, 255), 0.85, scale) #plot_spectrum(img, draw, X, (255,0,0, 255), 0.85, scale) scale = plot_spectrum(img, draw, ref, (255,255,0, 255), 0.85, 0.0) plot_spectrum(img, draw, test, (255,255,255, 255), 0.85, 0.0) tmp = tempfile.TemporaryFile() img.save(tmp, format='png') tmp.seek(0) sludge = tmp.read() return sludge
def __init__(self, ): self.folderHANDY = os.path.dirname(os.path.abspath(__file__)) gridDefinitionsFile = os.path.join(self.folderHANDY, "gridsDefinitions.yaml") self.continuumRegionsLogic = regionLogic.RegionLogic() self.radialVelocityEstimator = radialVelocity.RadialVelocity() self.specSynthesizer = specInterface.SynthesizeSpectrum() self.gridDefinitions = gridDefinitionsRead.gridDefinition( gridDefinitionsFile) self.spectrumNote = spectrumNote.spectrumNote() self.spectrum = sp.Spectrum() self.theoreticalSpectrum = sp.Spectrum(wave=[],\ flux=[]) self.continuum = sp.Spectrum(wave=[],\ flux=[]) self.normedSpectrum = sp.Spectrum(wave=[],\ flux=[]) self.radialVelocity = 0.0 self.oryginalWavelength = None self.minWave = 3500 self.maxWave = 7000 self.loadReferenceComposition(_reference_composition)
def tempMain(): # ywbSpec = spectrum.Spectrum(5, ((255,255,0), (240,240,240), (0,160,255)), 'emoji/') # gwrSpec = spectrum.Spectrum(5, ((0,200,0), (240,240,240), (200,0,0)), 'emoji/') # ywbSpec.disp() # gwrSpec.disp() # spec2d = spectrum.make2dSpectrum(10, ywbSpec, gwrSpec, 'emoji/') # spectrum.disp2d(spec2d) spec1 = spectrum.Spectrum(10, ((255, 255, 200), (255, 255, 100)), 'emoji/') spec2 = spectrum.Spectrum(10, ((200, 200, 255), (100, 100, 255)), 'emoji/') spec3 = spectrum.Spectrum(10, ((255, 200, 200), (255, 100, 100)), 'emoji/') spec2d = spectrum.make2dSpectrum(10, spec1, spec2, 'emoji/') spectrum.disp2d(spec2d)
def RedshiftSpectrum(spect, z, dL=None, cosmo=None): ''' Redshift restframe spectrum to observed frame, apply cosmological dimming Inputs: spec = Rest frame spectrum to be redshifted, instance of class Spectrum z = redshift to which spectrum will be shifted one of [dL,cosmology] must be specified dL = luminosity distance associated with z, quantity (can be specified here to save time) cosmology = cosmology in which to calculate dL(z) if it hasn't been specified, astropy.cosmology instance Output: z_obs = Observed Spectrum, instance of class Spectrum ''' if dL == None: dL = cosmo.luminosity_distance(z) print(dL) dL = dL.to('cm') #fNuNew = (spect.spec*u.Unit('m')**2)/(4*np.pi*dL**2/(1+z)) uFnuN = u.Unit('erg') / u.Unit('s') / u.Unit('Hz') / u.Unit('cm')**2 fNuNew = (spect.spec * (4 * np.pi * ((10 * u.Unit('parsec')).to('cm'))**2) / (4 * np.pi * dL**2 / (1 + z))).to(uFnuN) newWavelengths = deepcopy(spect.wavelengths * (1. + z)) newParams = deepcopy(spect.params) newParams['z'] = z return (spectrum.Spectrum(newWavelengths.value, fNuNew.value, newWavelengths.unit, fNuNew.unit, params=newParams))
def test_bench(self): sim = Simulation(self.bench()) sim.run() s = spectrum.Spectrum(self.res, self.dt, window=signal.flattop) peaks = s.findPeaks(order=4, clipdb=100) s.printPeaks(peaks) s.plot("NCO Spectrum")
def getNoiseLevelByJson(self): deviceIndex = 1L sp = spectrum.Spectrum(device=deviceIndex) deviceInfo = sp.getDeviceInfo(deviceIndex) sp.capture() (freq, power) = sp.getSpectrum() totalpower = sp.getPower() bandpower = sp.getBandPower() status = {} status["status"] = "OK" status["name"] = None status["device"] = deviceInfo["name"] status["signal_db"] = totalpower status["peak_hz"] = freq[power.argmax()] status["time"] = int(time.time()) status["powerperband"] = dict(zip([ "low", "mid", "high", ], bandpower)) # status["spectrum"] = dict(zip(list(freq),list(power))) # pylab.plot(freq, power) # pylab.show() return json.dumps(status, indent=4)
def test_bench(self): sim = Simulation(self.bench()) sim.run() s = spectrum.Spectrum(self.res,self.dt*self.cic_decimation,window=signal.flattop) ##peaks = s.findPeaks(order=4,clipdb=90) ##s.printPeaks(peaks) s.plot()
def ReadGalaxev(dotSed, dot4color): ''' Reads data from a .sed and .4color file produced by galaxev (reformatted for SEDfit -WE SHOULD CHANGE THIS) Creates spectrum objects for each rest frame spectrum !!! DOES THIS RECORD THE PARAMS RIGHT IN ALL CASES? Inputs: dotSed = filename of .sed file dot4color = filename of .4color models = which models from galaxev files to be used on of: ALL, [VALUES,1,2,3,...,n], [RANGE,min,max,step] !!! SHOULD ADD SELECTION BY AGE AND STUFF HERE Output: List of spectrum objects ''' sed = np.genfromtxt(dotSed) fourColor = np.genfromtxt(dot4color) spex = [] lSunA = u.Unit('Lsun') / u.Unit('AA') for i in range(len(fourColor)): ps = { 'log(age/year)': fourColor[i][0], 'SFR/yr': fourColor[i][-1], 'Mstars': fourColor[i][6], 'modelNumber': i } spex.append( spectrum.Spectrum(sed[:, 0], sed[:, i + 1], u.Unit('AA'), lSunA, params=ps)) return (spex)
def readSpectrum(self, fileName, colWave=0, colFlux=1, skipRows=0): """ Reading spectrum in text or FITS format and update regions and points """ if not ".fits" in fileName: self.spectrum = sp.readSpectrum(fileName,\ colWave=colWave,\ colFlux=colFlux,\ skipRows=skipRows) else: self.spectrum = sp.Spectrum() """ Check more at http://archive.eso.org/cms/eso-data/help/1dspectra.html https://www.hs.uni-hamburg.de/DE/Ins/Per/Czesla/PyA/PyA/pyaslDoc/aslDoc/readFitsSpec.html """ self.spectrum.wave, self.spectrum.flux = pyasl.read1dFitsSpec( fileName) # self.spectrum.wave = self.spectrum.wave.byteswap().newbyteorder() self.spectrum.flux = self.spectrum.flux.byteswap().newbyteorder( ) #TODO PyAstronomy bug self.spectrum.name = fileName self.radialVelocity = 0.0 self.oryginalWavelength = copy.deepcopy(self.spectrum.wave) self.spectrumNote.set_spectrum(fileName)
def convert(self, smap, illum): xx = spectrum.Spectrum() yy = spectrum.Spectrum() zz = spectrum.Spectrum() refl = spectrum.Spectrum() spectrum.mult2(smap, illum, refl) spectrum.mult2(self.my_ciex_func, refl, xx) spectrum.mult2(self.my_ciey_func, refl, yy) spectrum.mult2(self.my_ciez_func, refl, zz) X = xx.power() / self.wb_X Y = yy.power() / self.wb_Y Z = zz.power() / self.wb_Z return (X, Y, Z)
def lines(istate, vi, fstate, vf, Jmax, Tr): origin = istate.E(vi) - fstate.E(vf) Bx = 1.9898 # 1/cm h = 6.62606957e-27 # erg.sec c = 2.99792458e10 # cm/sec k = 1.3806488e-16 # erg/K def f(j): return (2 * j + 1) * exp(-j * (j + 1) * (h * c * Bx) / (k * Tr)) Qnorm = sum([f(j) for j in range(Jmax)]) # Initialize different branches, and their triplet splittings. P = {0: {}, 1: {}, 2: {}} Q = {1: {}, 2: {}} R = {0: {}, 1: {}, 2: {}} wavelengths = (P, Q, R) spec = spectrum.Spectrum() for J in range(Jmax + 1): # P branch calculations for O in range(3): if J - 1 < O or J < O: pass else: shift = F(istate, vi, J - 1, O) - F(fstate, vf, J, O) wavelength = 1 / (100 * (origin + shift)) wavelengths[0][O][J] = wavelength S = (J + O) * (J - O) / J I = S / Qnorm * exp(-J * (J - 1) * (h * c * Bx) / (k * Tr)) spec[wavelength] = I # Q branch calculations for O in range(1, 3): if J < O: pass else: shift = F(istate, vi, J, O) - F(fstate, vf, J, O) wavelength = 1 / (100 * (origin + shift)) wavelengths[1][O][J] = wavelength S = (2 * J + 1) * O * O / J I = S / Qnorm * exp(-J * (J + 1) * (h * c * Bx) / (k * Tr)) spec[wavelength] = I # R branch calculations for O in range(3): if J + 1 < O or J < O or J is 0: pass else: shift = F(istate, vi, J + 1, O) - F(fstate, vf, J, O) wavelength = 1 / (100 * (origin + shift)) wavelengths[2][O][J] = wavelength S = (J + O) * (J - O) / J I = S / Qnorm * exp(-J * (J + 1) * (h * c * Bx) / (k * Tr)) spec[wavelength] = I return spec
def test_bench(): sim = Simulation(bench()) sim.run() dt = 1.0 / 76.8e6 print("MinMax", np.min(cosa), np.max(cosa)) s = spectrum.Spectrum(cosa, dt, window=signal.flattop) peaks = s.findPeaks(order=4, clipdb=90) s.printPeaks(peaks) s.plot()
def draw_split_chart(chart, ref, test): img = Image.new('RGB', (640, 430), color=(0, 0, 0)) draw = ImageDraw.Draw(img) width = img.size[0] height = img.size[1] hsize = chart.ncolumns vsize = chart.nrows cmf = observer.ColorMatchingFunction() cmf2 = observer.ColorMatchingFunction() refl = spectrum.Spectrum() cmf.white_balance(ref) cmf2.white_balance(test) block = width / hsize border = int(0.125 * block) block = (width - (border * hsize + border)) / hsize block2 = block / 2 y1 = border for i in range(0, vsize): x1 = border for j in range(0, hsize): vertindex = i horindex = j (X, Y, Z) = cmf2.convert(chart.patches[i * hsize + j], test) print(X * .6, Y * .6, Z * .6) v = coordvector.CoordVector(X * .6, Y * .6, Z * .6) rr = v.r8 gg = v.g8 bb = v.b8 (X, Y, Z) = cmf.convert(chart.patches[i * hsize + j], ref) v = coordvector.CoordVector(X * .6, Y * .6, Z * .6) r = v.r8 g = v.g8 b = v.b8 color = (rr, gg, bb, 255) tcolor = (r, g, b, 255) draw.rectangle((x1, y1 + block2, x1 + block, y1 + block2 + block2), fill=color) draw.rectangle((x1, y1, x1 + block, y1 + block2), fill=tcolor) x1 = x1 + (border + block) y1 = y1 + (border + block) tmp = tempfile.TemporaryFile() img.save(tmp, format='png') tmp.seek(0) sludge = tmp.read() return sludge
def __init__(self): self.wb_X = 1.0 self.wb_Y = 1.0 self.wb_Z = 1.0 handle = open('resources/cie_x.json', 'r') self.my_ciex_func = spectrum.Spectrum() self.my_ciex_func.from_file(handle) handle.close() handle = open('resources/cie_y.json', 'r') self.my_ciey_func = spectrum.Spectrum() self.my_ciey_func.from_file(handle) handle.close() handle = open('resources/cie_z.json', 'r') self.my_ciez_func = spectrum.Spectrum() self.my_ciez_func.from_file(handle) handle.close()
def white_balance(self, illum): self.wb_X = 1.0 self.wb_Y = 1.0 self.wb_Z = 1.0 white = spectrum.Spectrum() refl = spectrum.Spectrum() rr = spectrum.Spectrum() gg = spectrum.Spectrum() bb = spectrum.Spectrum() spectrum.mult2(white, illum, refl) spectrum.mult2(self.my_ciex_func, refl, rr) spectrum.mult2(self.my_ciey_func, refl, gg) spectrum.mult2(self.my_ciez_func, refl, bb) self.wb_X = rr.power() self.wb_Y = gg.power() self.wb_Z = bb.power()
def __init__(self): self.patches = [] self.ncolumns = 6 self.nrows = 4 file_pat = "resources/macbeth/gmcc_%02d.json" for i in range(0, 24): handle = open(file_pat % i, 'r') sp = spectrum.Spectrum() sp.from_file(handle) self.patches.append(sp) handle.close()
def load_spectra(self, is_fits=True): print("... loading spectra: ", self.spectra_path) ### I only want the spectra in the param file self.spectra_names = self.param_file['name'].tolist() if is_fits == True: self.spectra_array = [ spectrum.Spectrum(fits.open(self.spectra_path + current), name=current, is_fits=fits) for current in self.spectra_names ] else: self.spectra_array = [ spectrum.Spectrum(pd.read_csv(self.spectra_path + current), name=current, fits=False) for current in self.spectra_names ] self.length = len(self.spectra_array) return
def freqtest(self,phase): a = 0 for i in range(2**18): self.res[i] = self.comp1(a) a += phase a = a & 0x0ffffffff ## dither ## ##a = a ^ random.randint(0,255) s = spectrum.Spectrum(self.res,self.dt,window=signal.flattop) peaks = s.findPeaks(order=4,clipdb=120) s.printPeaks(peaks) s.plot("NCO Spectrum")
def main(): # ----- Setup Problem ---------------------------------- particle = prt.Particle() material = mat.Material() Emin = 100 Emax = 1000 Ne = 125 Zmin = 0 Zmax = 30 Nz = 1000 # ----- Calculate matrix A ------------------------------------ grid = gd.Grid( Ne, Emin, Emax, Nz, Zmin, Zmax ) Enodes = grid.get_EnodesChebyshev() Ewts2 = wt2.Weights2( Enodes ) A1 = Ewts2.get_A1() A2 = Ewts2.get_A2() grid.get_Agrid( A1, A2, particle, material, 0 ) # ----- Initial Spectrum ------------------------------- idx1 = grid.find_Enode( Emax ) idx2 = grid.find_Enode( Emin ) Spec = spec.Spectrum( Enodes, idx1, idx2 ) # Spec.normalizer() #grid.get_b( Spec.gaussian( 700, 100 ) ) B = -1*np.array( Spec.gaussian( 700,500 ) ) B1 = -1*B #B = -1*grid.b # ----- Solver --------------------------------------------- for i in range( 0, Nz ): x = linalg.solve( grid.Agrid, B ) grid.phi[:,i] = x B = (-1)*x if i % 100 == 0: print( 'step: ', i ) idx4 = grid.find_Znode( 15.0 ) np.savetxt('output.txt', np.column_stack((grid.Enodes, grid.phi[:,idx4]) ), fmt="%1.4e", delimiter=' ') #np.savetxt('output.txt', np.column_stack((grid.Enodes, B1) ), fmt="%1.4e", delimiter=' ') plt.figure( 1 ) plt.plot( grid.Enodes, B1, 'r' ) #plt.plot( grid.Enodes, grid.phi[:,idx4], 'g' ) plt.plot( grid.Enodes, grid.phi[:,idx4], 'g' ) plt.show()
def main(): #------- Setup Problem ------------------------ Emin = 100 Emax = 1000 Ne = 100 Xmin = 0 Xmax = 30 Nx = 1000 particle = prt.Particle() material = mat.Material() #------ Generate A matrix -------------------- grid = gd.Grid( Ne, Emin, Emax, Nx, Xmin, Xmax ) Enodes = grid.get_EnodesChebyshev() Ewts = wgt.Weights2( Enodes ) A1 = Ewts.get_A1() A2 = Ewts.get_A2() A = grid.get_Agrid( A1, A2, particle, material ) # ----- Initial Spectrum ------------------------------- idx1 = grid.find_Enode( Emax ) idx2 = grid.find_Enode( Emin ) Spec = spec.Spectrum( Enodes, idx1, idx2 ) B = -1*np.array( Spec.gaussian( 700, 500 ) ) B1 = -1*B # ----- Solver --------------------------------------------- for i in range( 0, Nx ): x = linalg.solve( A, B ) grid.phi[:,i] = x B = (-1)*x if i % 100 == 0: print( 'step: ', i ) idx4 = grid.find_Xnode( 25.0 ) np.savetxt('output.txt', np.column_stack((grid.Enodes, grid.phi[:,idx4]) ), fmt="%1.6e", delimiter=' ') plt.figure( 1 ) plt.plot( grid.Enodes, B1, 'r' ) plt.plot( grid.Enodes, grid.phi[:,idx4], 'g' ) plt.plot( grid.Enodes, grid.phi[:,idx4], 'o' ) plt.show()
def computeSpectrumUsingSYNTHE(self, teff, logg, vmic, me, vsini, vmac, resolution, minWave=None, maxWave=None): resolution = min(resolution, 500000) if minWave is None: minWave = self.minWave if maxWave is None: maxWave = self.maxWave parameters = Parameters(teff=teff, logg=logg, metallicity=me, microturbulence=vmic, vsini=vsini, resolution=resolution, wave_min=minWave, wave_max=maxWave) try: if not (hasattr(self, '_atlas_model') and self._atlas_model.parameters == parameters): print("Start ATLAS model computation") atlasWorker = Atlas() self._atlas_model = atlasWorker.get_model(parameters) print("ALTAS model computation finished") syntheWorker = Synthe() print("Start SYNTHE spectrum computation") spectrum = syntheWorker.get_spectrum(self._atlas_model, parameters) print("SYNTHE spectrum computation finished") mask_wave = (spectrum.lines_identification['wave'] > minWave) & ( spectrum.lines_identification['wave'] < maxWave) spectrum.lines_identification = spectrum.lines_identification[ mask_wave] spectrum.lines_identification.sort_values('wave', inplace=True) self.theoreticalSpectrum = sp.Spectrum( wave=spectrum.wave, flux=spectrum.normed_flux, lines_identification=spectrum.lines_identification) except: print("ERROR: SYNTHE/ATLAS error!") print("Unexpected error:", sys.exc_info()[0])
def __init__(self, filename, run_type="F", peak_picking_type="B"): self._my_name = filename.split("/")[-1].split(".")[0] self._my_sequence = [] if run_type.upper() == "F": self._my_spectrum = spectrum.Spectrum(filename) if peak_picking_type.upper() == "O": self._my_peaks = peaks.Peaks( self._my_spectrum, 23) #placeholder for tuple with optimal data elif peak_picking_type.upper() == "B": self._my_peaks = peaks.Peaks(self._my_spectrum) #add else statement with error catches later elif run_type.upper() == "A": self._my_spectrum = None self._my_peaks = peaks.Peaks(filename)
def readSpectrum(self, fileName, colWave=0, colFlux=1, skipRows=0): """ Reading spectrum in text or FITS format and update regions and points """ if not ".fits" in fileName: self.spectrum = sp.readSpectrum(fileName,\ colWave=colWave,\ colFlux=colFlux,\ skipRows=skipRows) else: self.spectrum = sp.Spectrum() """ Check more at http://archive.eso.org/cms/eso-data/help/1dspectra.html https://www.hs.uni-hamburg.de/DE/Ins/Per/Czesla/PyA/PyA/pyaslDoc/aslDoc/readFitsSpec.html """ self.spectrum.wave = None self.spectrum.flux = None # Search FITS data for Molecfit keywords waveKey = "lambda" # use orignal wavelength not the the molecfit corrected fluxKey = "cflux" # use telluric absorption corrected flux dataKeys = [waveKey, fluxKey] fitsFile = fits.open(fileName) for hdu in fitsFile: if hdu.data is None or not hasattr(hdu.data, 'names'): continue if all(name in hdu.data.names for name in dataKeys): self.spectrum.wave = hdu.data[waveKey] self.spectrum.flux = hdu.data[fluxKey] self.spectrum.wave = self.spectrum.wave * 1000 # micrometre to nanometre break fitsFile.close() # If no Molecfit formated data is found, fall back to pyastronomy solution used in main version of HANDY if self.spectrum.wave is None or self.spectrum.flux is None: self.spectrum.wave, self.spectrum.flux = pyasl.read1dFitsSpec( fileName) self.spectrum.flux = self.spectrum.flux.byteswap( ).newbyteorder() # TODO PyAstronomy bug self.spectrum.name = fileName self.radialVelocity = 0.0 self.oryginalWavelength = copy.deepcopy(self.spectrum.wave)
def mixtest(self,phase): a = 0 for i in range(2**18): sig = np.cos(2*np.pi*24006123*i*self.dt) sig = int(round(sig * 2**11)) / float(2**11) res = sig * self.comp1(a) self.res[i] = res #rr = int((res.real * 2**17))/ float(2**17) #ri = int((res.imag * 2**17))/ float(2**17) #self.res[i] = (rr + (ri*1j)) a += phase a = a & 0x0ffffffff ## dither ## ##a = a ^ random.randint(0,255) s = spectrum.Spectrum(self.res,self.dt,window=signal.flattop) peaks = s.findPeaks(order=4,clipdb=100) s.printPeaks(peaks) s.plot("NCO Spectrum")
def dustReddenSpectrum(spec, dustlaw, ebv): ''' Apply dust reddening to rest frame galaxy spectrum Inputs: spec = spectrum object dustlaw = string, one of ['Calzetti2000','Calzetti1997','LMC','SMC','MW','Dor30'] ebv = float in (0,1) Ouput: Astropy quantity of reddened spectrum of length len(spec.spec), with units of spec.spec ''' #assert isinstance(spec,spectrum.Spectrum) assert isinstance(ebv, float) if ebv == 0.0: newSpec = deepcopy(spec) newSpec.params['ebv'] = 0.0 return (newSpec) dustLaws = ['calzetti2000', 'calzetti1997', 'lmc', 'smc', 'mw', 'dor30'] dustLawFuncs = [Calzetti2000, Calzetti1997, LMC, SMC, MW, Dor30] if dustlaw not in dustLaws: raise ValueError(dustlaw, ' is not a valid dust law.') if np.any(np.asarray(ebv) >= 1.0): raise ValueError('Values of E(B-V) must be between 0 and 1.') nDustLaw = dustLaws.index(dustlaw) specUnit = spec.spec.unit print(specUnit) wavelengthUnit = spec.wavelengths.unit reddenedSpec = dustLawFuncs[nDustLaw]( 1.0 * spec.wavelengths.to('micron').value, spec.spec.value, ebv) * u.Unit(specUnit) print(reddenedSpec) newSpec = spectrum.Spectrum(deepcopy(spec.wavelengths).value, reddenedSpec.value, wavelengthUnit, specUnit, params=deepcopy(spec.params)) newSpec.params['ebv'] = ebv return (newSpec)
def IGMAttenuateSpectrum(spec,igmLaw,igmOpacity,z): ''' Apply IGM opacity to spectrum Inputs: spec = spectrum object dustlaw = string, one of ['Madau'] igmOpacity = float > 0 Ouput: Astropy quantity of reddened spectrum of length len(spec.spec), with units of spec.spec ''' #assert isinstance(spec,spectrum.Spectrum) assert isinstance(igmOpacity,float) igmLaws = ['Madau','Inoue'] igmLawFuncs = [Madau,Inoue] if igmLaw not in igmLaws: raise ValueError(igmLaw,' is not a valid IGM Attenuation Law.') nLaw = igmLaws.index(igmLaw) specUnit = spec.spec.unit cosmicTrans = igmOpacity * igmLawFuncs[nLaw](spec.wavelengths.to('Angstrom').value,z) newSpec = spectrum.Spectrum(deepcopy(spec.wavelengths).value,cosmicTrans*deepcopy(spec.spec).value,spec.wavelengths.unit,u.Unit(specUnit),params=deepcopy(spec.params)) newSpec.params['igmOpacity']=igmOpacity return(newSpec)
def prob1a(): #plot both spectra #by eye, find peaks and ID for redshift #could fit gaussian to get mu #units of flux here do not really matter ... just looking for emission lines, don't care what units # lamb = NIRSpectrum_AA * u.AA # flux = NIRSpectrum_cgs * u.Unit('erg cm-2 s-1 AA-1') # spec = su.Spectrum1D(spectral_axis=lamb, flux=flux) # lines = plt.step(spec.spectral_axis, spec.flux) # # # #GAUSS_FIT_PIX_ERROR from 2.0 to 3.0 #GAUSS_FIT_MAX_SIGMA from 10.0 to 17.0 #... #if ( abs(fit_peak - raw_peak) > (raw_peak * 0.25) ): #0.20 to 0.25 #G.DEBUG_SHOW_GAUSS_PLOTS = True G.DISPLAY_ABSORPTION_LINES = False G.MAX_SCORE_ABSORPTION_LINES = 0.0 # the most an absorption line can contribute to the score (set to 0 to turn off) spec_obj = elixer_spectrum.Spectrum( ) # todo: needs spec_obj.identifier and spec_obj.plot_dir spec_obj.set_spectra(NIRSpectrum_AA, NIRSpectrum_cgs * 100.0, errors=None, central=22789.1429788, values_units=1) # ,fit_min_sigma=2.0) # cw = spec_obj.find_central_wavelength() spec_obj.classify() # might be none z = spec_obj.solutions[0].z plt.figure(figsize=(12, 4)) plt.title("Observed Flux density (NIR) z=%0.3f" % (z)) plt.xlabel(r"Wavelength $\AA$") plt.ylabel("Flux [$erg s^{-1} cm^{-2} \AA^{-1}$]") plt.plot(NIRSpectrum_AA, NIRSpectrum_cgs) #todo: just plot the best fit lines (NaII and H_alpha) or (OIII and H_beta) #red for H_alpha 6562.8 plt.axvline(x=spec_obj.solutions[0].central_rest * (1 + z), ls='dashed', c='r', zorder=1, alpha=0.5, label=r"$H_{\alpha}$") #NaII plt.axvline(x=6549.0 * (1 + z), ls='dashed', c='g', zorder=1, alpha=0.5, label=r"NaII") #other NaII 6583 plt.axvline(x=6583.0 * (1 + z), ls='dashed', c='g', zorder=1, alpha=0.5, label=r"NaII") # for f in spec_obj.all_found_lines: # this is an EmisssionLineInfo object # plt.axvline(x=f.raw_x0, ls='dashed', c='k', zorder=1, alpha=0.5) # for s in spec_obj.solutions: # print("z=%f, line=%s, score=%f, total lines=%d" %(s.z,s.name,s.score,len(s.lines))) # for l in s.lines: # if l.absorber: # print (" [absorber] line=%s rest=%f" %(l.name,l.w_rest)) # else: # print("line=%s rest=%f" % (l.name, l.w_rest)) plt.legend(loc='upper right', bbox_to_anchor=(0.98, 0.98), borderaxespad=0) plt.savefig(op.join(OUTDIR, "prob1a_1.png")) #plt.show() plt.close() plt.figure(figsize=(12, 4)) plt.title("Observed Flux density (mm) z=%0.3f" % (z)) plt.xlabel("Frequency [MHz]") plt.ylabel("Flux [mJy]") plt.plot(MMSpectrum_GHz * 1000.0, MMSpectrum_Jy * 1000.0) #CO(3-2) 345769. plt.axvline(x=345769.0 / (1 + z), ls='dashed', c='b', zorder=1, alpha=0.5, label="CO(3-2)") plt.legend(loc='upper right', bbox_to_anchor=(0.98, 0.98), borderaxespad=0) plt.savefig(op.join(OUTDIR, "prob1a_2.png")) # plt.show() plt.close()
error values to index values. """ # for sys.argv import sys # for array operations and FFT import numpy # internal Spectrum class import spectrum # useful arrays import constant_arrays # read the test spectrum from a file test = spectrum.Spectrum() testfile = open(sys.argv[1], 'r') test.from_file(testfile) testfile.close() # set the ref to 7589 tungsten ref_array = constant_arrays.tungsten_7589 # normalize ref p1 = numpy.sum(ref_array) ref_array = numpy.divide(ref_array, float(p1)) # trapezoid subsample test spectrum test_array = test.trapezoid_bin_10nm()[0:36] # normalize test
from flask_caching import Cache import plotspectrum import drawchart import requests import chart import spectrum abort = False app = Flask(__name__) cache = Cache(app, config={'CACHE_TYPE': 'simple'}) FAKE_SALT = os.getenv('FAKE_SALT', 'r01YxUMwfHJvWQak') colorchecker = chart.ChipChart() ref = spectrum.Spectrum() test = spectrum.Spectrum() refname = 'D65_5_nm' testname = 'generic_led_cool' reffile = open('resources/emitters/D65_5_nm.json', 'r') testfile = open('resources/emitters/generic_led_cool.json', 'r') ref.from_file(reffile) test.from_file(testfile) reffile.close() testfile.close() @app.route('/', methods=['GET', 'POST']) def index():
def modifySpecAnims(anims, colorMap, whiteSquare, lilImgDBDir='emoji/'): littleImgs = remoji.getLittleImgs(lilImgDBDir) newAnims = [] i = 0 j = 0 #Runner curSpec = None specDirOrder = [ ] #DIRECTORY NAMES IN ORDER CORRESPONDING 1:1 TO FRAMES IN THE ANIMATION #if 'spec' not os.path.isdir('../spec'): # if not os.path.isdir('../spec'): # movieMaker.wipeDir('spec/') while i < len(anims): # if type(anims[i][0]) == int: if curSpec == None: pivotColors = [] steps = anims[i].pop() #print 'anims[' + str(i) + ']: ', anims[i] for p in range(0, len(anims[i]) / 3): r = int(anims[i].pop(0)) g = int(anims[i].pop(0)) b = int(anims[i].pop(0)) tempPivotColor = [] tempPivotColor.append(r) tempPivotColor.append(g) tempPivotColor.append(b) pivotColors.append(tempPivotColor) curSpec = spectrum.Spectrum(steps, pivotColors, lilImgDBDir, littleImgs, colorMap, whiteSquare) #print curSpec.levelsPerColor, curSpec.pivotColors j = i + 1 #JUMP TO NEXT SPECTRUM while type(anims[j][0]) != int: j += 1 steps = int(anims[j].pop()) pivotColors = [] for p in range(0, len(anims[j]) / 3): #print 'p:',p #print len(anims[j]) r = int(anims[j].pop(0)) g = int(anims[j].pop(0)) b = int(anims[j].pop(0)) tempPivotColor = [] tempPivotColor.append(r) tempPivotColor.append(g) tempPivotColor.append(b) pivotColors.append(tempPivotColor) #print 'pivotColors: ', pivotColors nextSpec = spectrum.Spectrum(steps, pivotColors, lilImgDBDir, littleImgs, colorMap, whiteSquare) #print type(nextSpec), type(curSpec) spec2d = spectrum.make2dSpectrum(20, curSpec, nextSpec, lilImgDBDir, littleImgs, colorMap) transitionFrames = 0 tempNonSpecAnims = [] #COUNT TOTAL TRANSITION FRAMES IN THIS LOOP while i < (j - 1): i += 1 #print i, anims[i] newAnims.append(anims[i]) tempNonSpecAnims.append(anims[i]) moreFrames = int(anims[i][2]) transitionFrames += moreFrames i = j totSpectrums = len( spec2d ) - 1 # -1 so that last spectrum doesnt get re-used in next anim floatStep = totSpectrums / float(transitionFrames) specDirShortOrder = [] for frame in range(0, transitionFrames): approxStep = floatStep * frame roundStep = int(round(approxStep)) spec = spec2d[roundStep] dirName = spec.namify() specDirShortOrder.append(dirName) #IF THERES A PATH TO SPEC/DIRNAME, DONT BOTHER, ELSE, MAKE IT #specDirs = os.listdir('spec/') #if dirName[:-1] not in specDirs: # os.system('mkdir spec/' + dirName[:-1]) # #print 'copyingImgsToDir ..' # spec.copyImgsToDir('spec/' + dirName) movieMaker.wipeDir('spec/' + dirName) spec.copyImgsToDir('spec/' + dirName) specDirOrder.append('spec/' + dirName) #print specDirs #print dirName # print 'specDirOrder:', specDirOrder if j == (len(anims) - 1): break curSpec = nextSpec return [newAnims, specDirOrder]