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]
