def test_neg_wl_response(self):
"""Check that error is thrown if a negative wavelength is given to getFlux method"""
s = sedFilter.SED(self.testdata[:,0], self.testdata[:,1])
wl = -1.
self.assertRaises(ValueError, lambda: s.getFlux(wl))
def test_neg_z_response(self):
"""Check that error is thrown if a negative redshift is given to getFlux method"""
s = sedFilter.SED(self.testdata[:,0], self.testdata[:,1])
z = -1.
self.assertRaises(ValueError, lambda: s.getFlux(self.testdata[5,0], z))
def test_no_negative_fl_on_read(self):
"""Check that error is thrown if a negative flux is read from the data"""
tmpdata = np.copy(self.testdata)
tmpdata[0,1] = -1.
self.assertRaises(ValueError, lambda: sedFilter.SED(tmpdata[:,0], tmpdata[:,1]))
def test_resolution_wavelength(self):
"""Check the expected wavelength resolution of the SED is returned"""
s = sedFilter.SED(self.testdata[:,0], self.testdata[:,1])
nl = s.returnSedResolution()
self.assertEqual(len(self.testdata[:,0]), nl)
def test_max_wavelength(self):
"""Check the expected maximum wavelength of the SED is returned"""
s = sedFilter.SED(self.testdata[:,0], self.testdata[:,1])
lmin,lmax = s.returnSedRange()
self.assertEqual(self.testdata[-1,0], lmax)
def test_interpolation(self):
"""Check interpolation by feeding original wavelength grid back to interpolation function"""
wl = self.testdata[:,0]
fl = self.testdata[:,1]
s = sedFilter.SED(wl, fl)
for i in xrange(len(wl)):
self.assertAlmostEqual(fl[i], s.getFlux(wl[i]))
def test_no_neg_flux_returned(self):
"""Over huge wavelength, redshift domain check no negative fluxes are returned"""
s = sedFilter.SED(self.testdata[:,0], self.testdata[:,1])
lamMax = 10000000000000
nlam = 10000
dlam = lamMax/(nlam-1)
dz = 0.5
ndz = 10
for i in xrange(ndz):
z = i*dz
for n in xrange(nlam):
self.assertGreaterEqual(s.getFlux(n*dlam, z), 0.)
def test_interpolation_again(self):
"""Check interpolation by checking flux values of wls between any two wl in the grid """
wl = self.testdata[:,0]
fl = self.testdata[:,1]
s = sedFilter.SED(wl, fl)
for i in xrange(len(wl)-1):
# mid point wl
wlt = 0.5*(wl[i] + wl[i+1])
# fluxes around mid point
flBounds = [fl[i], fl[i+1]]
flMax = max(flBounds)
flMin = min(flBounds)
self.assertTrue( s.getFlux(wlt)<=flMax and s.getFlux(wlt)>=flMin )
def generateSpectrum(self, colors):
"""Generate a new SED object given colors supplied
"""
# Generate new set of eigenvalues for supplied colors
eigenvals_generated = self._gp.predict(colors)
# check if not all eigenvalues were used in GP
nGP = eigenvals_generated.shape[1]
if (nGP < self.eigenspectra.shape[0] and not self._isRetrained):
if (self._isRetrained):
raise ValueError("ERROR! cannot have ")
print nGP, self.eigenspectra.shape[0]
# find SED with closest colors
ifit = self._fitColors(colors)
#eigenvals_generated = eigenvals_generated + self.eigenvalue_coeffs[ifit, nGP+1,:]
add_on = np.reshape(self.eigenvalue_coeffs[ifit, nGP:],
(1, len(self.eigenvalue_coeffs[ifit, nGP:])))
eigenvals_generated = np.concatenate((eigenvals_generated, add_on),
axis=1)
#raise ValueError("Error! not yet implemented")
# Reconstruct SED and normalise so it sums to 1
spec_rec = np.dot(eigenvals_generated,
self.eigenspectra) + self.meanSpec
norm = np.sum(spec_rec)
spec_rec /= norm
# Protect against zero fluxes
spec_rec[np.where(spec_rec < 0)] = 0.
# Recreate SED object
sed_rec = sedFilter.SED(self._waveLen, spec_rec)
return sed_rec
def get_sed_array(sedDict,
minWavelen=2999.,
maxWavelen=12000.,
nWavelen=10000,
filterDict=None,
color_file=None):
"""Return array of SEDs on same wavelength grid (optionally along with colors as defined by filterDict)
If computing colors, first orders filters by effective wavelength, then a color is:
color_{i, i+1} = mag_filter_i - mag_filter_i+1
@param sedDict dictionary of SEDs
@param minWavelen minimum wavelength of wavelength grid
@param maxWavelen maximum wavelength of wavelength grid
@param nWavelen number of points in wavelength grid
@param filterDict dictionary of filters
@param color_file file to save SED colors to or read colors from (if exists)
"""
doColors = True
if (filterDict == None or color_file == None):
doColors = False
isFileExist = False
if doColors:
# sort based upon effective wavelength
filter_order = sedFilter.orderFiltersByLamEff(filterDict)
# check if file exists and need to calculate colors
isFileExist = os.path.isfile(color_file)
if (isFileExist):
print "\nColors already computed,",
else:
print "\nComputing colors,",
print "placing SEDs in array ..."
# loop over each SED
nSED = len(sedDict)
spectra = []
colors = []
for ised, (sedname, spec) in enumerate(sedDict.items()):
print "On SED", ised + 1, "of", nSED, sedname
# re-grid SEDs onto same wavelengths
waveLen, fl = spec.getSedData(lamMin=minWavelen,
lamMax=maxWavelen,
nLam=nWavelen)
# normalise so they sum to 1
norm = np.sum(fl)
spectra.append(fl / norm)
if doColors:
# calculate or read colors
cs = []
if (isFileExist):
# reading colors
colors_in_file = np.loadtxt(color_file)
cs = colors_in_file[ised, :]
else:
# calculating colors
spec = sedFilter.SED(waveLen, fl) #/norm)
pcalcs = phot.PhotCalcs(spec, filterDict)
# in each filter
for i in range(len(filterDict) - 1):
color = pcalcs.computeColor(filter_order[i],
filter_order[i + 1])
if (color == float('inf')):
color = 99.
cs.append(color)
# store colors for this SED
colors.append(cs)
# conver to np arrays for ease
spectra = np.array(spectra)
colors = np.array(colors)
# if had to calculate, save colors to file to re-use
if (not isFileExist and doColors):
print "Saving colors to file for future use"
np.savetxt(color_file, colors)
if doColors:
return waveLen, spectra, colors
else:
return waveLen, spectra
listOfFilters = 'LSST.filters'
pathToFilters = '../filter_data'
# create a dictionary: keyword is filter name, value is a Filter object
filterDict = sedFilter.createFilterDict(listOfFilters, pathToFilters)
# return the filter names
filterList = sedFilter.orderFiltersByLamEff(filterDict)
print 'Filter list = ', filterList
nFilter = len(filterList)
# load in elliptical SED (1st col: wavelength in A, 2nd col: fluxes in wl units)
seddata = np.loadtxt('../sed_data/El_B2004a.sed')
# turn into SED object
sed = sedFilter.SED(seddata[:, 0], seddata[:, 1])
# instantiate photometry calculations
# need cosmological model
h = 1.
omegamat = 0.3
omegaDE = 0.7
wX = -1.
wXa = 0.
cosmoModel = cosmo.cosmologyCalculator(h, omegamat, omegaDE, wX, wXa)
# need error model
# fractional flux error = 10%
pars = {}
import unittest
import os
import numpy as np
import cphotometry as cphot
import sedFilter
import cosmo
import photErrorModel as pem
# Single SED for testing
fname = os.path.join(os.path.dirname(__file__), '../sed_data/El_B2004a.sed')
seddata = np.loadtxt(fname)
TEST_SED = sedFilter.SED(seddata[:, 0], seddata[:, 1])
# List of filters for testing
listOfFilters = 'LSST.filters'
pathToFilters = '../filter_data'
TEST_FILTERDICT = sedFilter.createFilterDict(listOfFilters, pathToFilters)
FILTERLIST = sedFilter.orderFiltersByLamEff(TEST_FILTERDICT)
# List of SEDs for testing
SEDLIST = []
sedfiles = [
'../sed_data/El_B2004a.sed', '../sed_data/Sbc_B2004a.sed',
'../sed_data/Scd_B2004a.sed', '../sed_data/Im_B2004a.sed'
]
for name in sedfiles:
seddata = np.loadtxt(name)
SEDLIST.append(sedFilter.SED(seddata[:, 0], seddata[:, 1]))
# Cosmological model
COSMOMODEL = cosmo.cosmologyCalculator()
# wavelength grid to plot
lamMin = 1000.
lamMax = 10000.
nLam = 1000
# start figure
fig = plt.figure(figsize=(20,20))
ised = 1
for name in sed_names:
# create SED object
fname = sed_location + name + sed_file_ext
f = np.loadtxt(fname)
s = sedFilter.SED(f[:,0], f[:,1])
# return flux data for wavelength grid
wavelengths, fluxes = s.getSedData(lamMin=lamMin, lamMax=lamMax, nLam=nLam)
# plot
ax = fig.add_subplot(2,3,ised)
ax.plot(wavelengths, fluxes, linestyle='solid', color='black', label=name)
ax.set_xlabel('wavelength (angstroms)', fontsize=24)
ax.set_ylabel('flux', fontsize=24)
handles, labels = ax.get_legend_handles_labels()
ax.legend(labels)
ax.legend(loc='lower right',prop={'size':12})
ised+=1
def test_flux_units(self):
"""Check flux units are 'wl' (no other option implemented yet)"""
s = sedFilter.SED(self.testdata[:,0], self.testdata[:,1])
self.assertEqual(s.returnFluxUnits(),"wl")
def test_set_em_line(self):
"""Check setEmLine throws error as not implemented yet"""
s = sedFilter.SED(self.testdata[:,0], self.testdata[:,1])
s.setEmLine(4.)
