def testStellarPhotometricUncertainties(self):
"""
Test in the case of a catalog of stars
"""
lsstDefaults = LSSTdefaults()
starDB = testStarsDBObj(driver=self.driver, host=self.host, database=self.dbName)
starCat = testStarCatalog(starDB, obs_metadata=self.obs_metadata)
phot = PhotometryStars()
ct = 0
for line in starCat.iter_catalog():
starSed = Sed()
starSed.readSED_flambda(os.path.join(lsst.utils.getPackageDir('sims_sed_library'),
defaultSpecMap[line[14]]))
imsimband = Bandpass()
imsimband.imsimBandpass()
fNorm = starSed.calcFluxNorm(line[15], imsimband)
starSed.multiplyFluxNorm(fNorm)
aV = numpy.float(line[16])
a_int, b_int = starSed.setupCCMab()
starSed.addCCMDust(a_int, b_int, A_v=aV)
for i in range(len(self.bandpasses)):
controlSigma = calcMagError_sed(starSed, self.totalBandpasses[i],
self.skySeds[i],
self.hardwareBandpasses[i],
FWHMeff=lsstDefaults.FWHMeff(self.bandpasses[i]),
photParams=PhotometricParameters())
testSigma = line[8+i]
self.assertAlmostEqual(controlSigma, testSigma, 4)
ct += 1
self.assertGreater(ct, 0)
def _calcSingleGalSimSed(self, sedName, zz, iAv, iRv, gAv, gRv, norm):
"""
correct the SED for redshift, dust, etc. Return an Sed object as defined in
sims_photUtils/../../Sed.py
"""
if _is_null(sedName):
return None
sed = Sed()
sed.readSED_flambda(os.path.join(self.sedDir, sedName))
imsimband = Bandpass()
imsimband.imsimBandpass()
# normalize the SED
# Consulting the file sed.py in GalSim/galsim/ it appears that GalSim expects
# its SEDs to ultimately be in units of ergs/nm so that, when called, they can
# be converted to photons/nm (see the function __call__() and the assignment of
# self._rest_photons in the __init__() of galsim's sed.py file). Thus, we need
# to read in our SEDs, normalize them, and then multiply by the exposure time
# and the effective area to get from ergs/s/cm^2/nm to ergs/nm.
#
# The gain parameter should convert between photons and ADU (so: it is the
# traditional definition of "gain" -- electrons per ADU -- multiplied by the
# quantum efficiency of the detector). Because we fold the quantum efficiency
# of the detector into our total_[u,g,r,i,z,y].dat bandpass files
# (see the readme in the THROUGHPUTS_DIR/baseline/), we only need to multiply
# by the electrons per ADU gain.
#
# We will take these parameters from an instantiation of the PhotometricParameters
# class (which can be reassigned by defining a daughter class of this class)
#
fNorm = sed.calcFluxNorm(norm, imsimband)
sed.multiplyFluxNorm(fNorm)
# apply dust extinction (internal)
if iAv != 0.0 and iRv != 0.0:
a_int, b_int = sed.setupCCMab()
sed.addCCMDust(a_int, b_int, A_v=iAv, R_v=iRv)
# 22 June 2015
# apply redshift; there is no need to apply the distance modulus from
# sims/photUtils/CosmologyWrapper; magNorm takes that into account
# however, magNorm does not take into account cosmological dimming
if zz != 0.0:
sed.redshiftSED(zz, dimming=True)
# apply dust extinction (galactic)
if gAv != 0.0 and gRv != 0.0:
a_int, b_int = sed.setupCCMab()
sed.addCCMDust(a_int, b_int, A_v=gAv, R_v=gRv)
return sed
def calcADUwrapper(sedName=None, magNorm=None, redshift=None, internalAv=None, internalRv=None,
galacticAv=None, galacticRv=None, bandpass=None):
"""
Read in an SED and calculat the number of ADU produced by that SED in a specified bandpass
Parameters
----------
sedName is a string specifying the file name of the SED
magNorm is the normalizing magnitude of the SED in the imsimBandpass
redshift is the redshift of the SED
internalAv is the Av due to internal dust of the source (if a galaxy)
internalRv is the Rv due to internal dust of the source (if a galaxy)
galacticAv is the Av due to Milky Way dust between observer and source
galacticRv is the Rv due to Milky Way dust between observer and source
bandpass is an intantiation of Bandpass representing the band in which the ADUs are measured
Returns
-------
A float representing the number of ADUs measured in the bandpass
"""
imsimband = Bandpass()
imsimband.imsimBandpass()
sed = Sed()
sed.readSED_flambda(sedName)
fNorm = sed.calcFluxNorm(magNorm, imsimband)
sed.multiplyFluxNorm(fNorm)
if internalAv is not None and internalRv is not None:
if internalAv != 0.0 and internalRv != 0.0:
a_int, b_int = sed.setupCCMab()
sed.addCCMDust(a_int, b_int, A_v=internalAv, R_v=internalRv)
if redshift is not None and redshift != 0.0:
sed.redshiftSED(redshift, dimming=True)
a_int, b_int = sed.setupCCMab()
sed.addCCMDust(a_int, b_int, A_v=galacticAv, R_v=galacticRv)
adu = sed.calcADU(bandpass, photParams=PhotometricParameters())
return adu
def test_stars(self):
obs = ObservationMetaData(bandpassName=['c_u', 'c_g'], m5=[25.0, 26.0])
db_dtype = np.dtype([('id', np.int),
('raJ2000', np.float),
('decJ2000', np.float),
('sedFilename', str, 100),
('magNorm', np.float),
('galacticAv', np.float)])
inputDir = os.path.join(getPackageDir('sims_catUtils'), 'tests', 'testData')
inputFile = os.path.join(inputDir, 'IndicesTestCatalogStars.txt')
db = fileDBObject(inputFile, dtype=db_dtype, runtable='test', idColKey='id')
catName = os.path.join(getPackageDir('sims_catUtils'), 'tests', 'scratchSpace', 'cartoonStarCat.txt')
cat = CartoonStars(db, obs_metadata=obs)
cat.write_catalog(catName)
dtype = np.dtype([(name, np.float) for name in cat.column_outputs])
controlData = np.genfromtxt(catName, dtype=dtype, delimiter=',')
if os.path.exists(catName):
os.unlink(catName)
db_columns = db.query_columns(['id', 'raJ2000', 'decJ2000', 'sedFilename', 'magNorm', 'galacticAv'])
sedDir = os.path.join(getPackageDir('sims_sed_library'), 'starSED', 'kurucz')
for ix, line in enumerate(next(db_columns)):
spectrum = Sed()
spectrum.readSED_flambda(os.path.join(sedDir, line[3]))
fnorm = spectrum.calcFluxNorm(line[4], self.normband)
spectrum.multiplyFluxNorm(fnorm)
a_x, b_x = spectrum.setupCCMab()
spectrum.addCCMDust(a_x, b_x, A_v=line[5])
umag = spectrum.calcMag(self.uband)
self.assertAlmostEqual(umag, controlData['cartoon_u'][ix], 3)
gmag = spectrum.calcMag(self.gband)
self.assertAlmostEqual(gmag, controlData['cartoon_g'][ix], 3)
umagError, gamma = calcMagError_m5(umag, self.uband, obs.m5['c_u'], PhotometricParameters())
gmagError, gamma = calcMagError_m5(gmag, self.gband, obs.m5['c_g'], PhotometricParameters())
self.assertAlmostEqual(umagError, controlData['sigma_cartoon_u'][ix], 3)
self.assertAlmostEqual(gmagError, controlData['sigma_cartoon_g'][ix], 3)
def _create_library_one_sed(_galaxy_sed_dir, sed_file_name_list, av_grid,
rv_grid, bandpass_dict, out_dict):
n_obj = len(av_grid) * len(rv_grid)
imsim_bp = Bandpass()
imsim_bp.imsimBandpass()
t_start = time.time()
for i_sed, sed_file_name in enumerate(sed_file_name_list):
if i_sed > 0 and i_sed % 10 == 0:
duration = (time.time() - t_start) / 3600.0
pred = len(sed_file_name_list) * duration / i_sed
print('%d of %d; dur %.2e pred %.2e' %
(i_sed, len(sed_file_name_list), duration, pred))
base_spec = Sed()
base_spec.readSED_flambda(os.path.join(_galaxy_sed_dir, sed_file_name))
ax, bx = base_spec.setupCCMab()
mag_norm = base_spec.calcMag(imsim_bp)
sed_names = np.array([defaultSpecMap[sed_file_name]] * n_obj)
rv_out_list = np.zeros(n_obj, dtype=float)
av_out_list = np.zeros(n_obj, dtype=float)
sed_mag_norm = mag_norm * np.ones(n_obj, dtype=float)
sed_mag_list = []
i_obj = 0
for av in av_grid:
for rv in rv_grid:
spec = Sed(wavelen=base_spec.wavelen,
flambda=base_spec.flambda)
spec.addCCMDust(ax, bx, A_v=av, R_v=rv)
av_out_list[i_obj] = av
rv_out_list[i_obj] = rv
sed_mag_list.append(tuple(bandpass_dict.magListForSed(spec)))
i_obj += 1
out_dict[sed_file_name] = (sed_names, sed_mag_norm, sed_mag_list,
av_out_list, rv_out_list)
def testStellarPhotometricUncertainties(self):
"""
Test in the case of a catalog of stars
"""
lsstDefaults = LSSTdefaults()
starDB = testStarsDBObj(driver=self.driver,
host=self.host,
database=self.dbName)
starCat = testStarCatalog(starDB, obs_metadata=self.obs_metadata)
ct = 0
for line in starCat.iter_catalog():
starSed = Sed()
starSed.readSED_flambda(
os.path.join(getPackageDir('sims_sed_library'),
defaultSpecMap[line[14]]))
imsimband = Bandpass()
imsimband.imsimBandpass()
fNorm = starSed.calcFluxNorm(line[15], imsimband)
starSed.multiplyFluxNorm(fNorm)
aV = np.float(line[16])
a_int, b_int = starSed.setupCCMab()
starSed.addCCMDust(a_int, b_int, A_v=aV)
for i in range(len(self.bandpasses)):
controlSigma = calcMagError_sed(
starSed,
self.totalBandpasses[i],
self.skySeds[i],
self.hardwareBandpasses[i],
FWHMeff=lsstDefaults.FWHMeff(self.bandpasses[i]),
photParams=PhotometricParameters())
testSigma = line[8 + i]
self.assertAlmostEqual(controlSigma, testSigma, 4)
ct += 1
self.assertGreater(ct, 0)
def calcADUwrapper(sedName=None, magNorm=None, redshift=None, internalAv=None, internalRv=None,
galacticAv=None, galacticRv=None, bandpass=None):
imsimband = Bandpass()
imsimband.imsimBandpass()
sed = Sed()
sed.readSED_flambda(sedName)
fNorm = sed.calcFluxNorm(magNorm, imsimband)
sed.multiplyFluxNorm(fNorm)
if internalAv is not None and internalRv is not None:
if internalAv != 0.0 and internalRv != 0.0:
a_int, b_int = sed.setupCCMab()
sed.addCCMDust(a_int, b_int, A_v=internalAv, R_v=internalRv)
if redshift is not None and redshift != 0.0:
sed.redshiftSED(redshift, dimming=True)
a_int, b_int = sed.setupCCMab()
sed.addCCMDust(a_int, b_int, A_v=galacticAv, R_v=galacticRv)
adu = sed.calcADU(bandpass, photParams=PhotometricParameters())
return adu
def get_dust_grid():
# Construct a look-up table to determine the factor
# by which to multiply the flares' flux to account for
# dust as a function of E(B-V). Recall that we are
# modeling all MLT flares as 9000K blackbodies.
lsstBandpassDict = BandpassDict.loadTotalBandpassesFromFiles()
ebv_grid = np.arange(0.0, 7.01, 0.01)
bb_wavelen = np.arange(200.0, 1500.0, 0.1)
hc_over_k = 1.4387e7 # nm*K
temp = 9000.0 # black body temperature in Kelvin
exp_arg = hc_over_k / (temp * bb_wavelen)
exp_term = 1.0 / (np.exp(exp_arg) - 1.0)
ln_exp_term = np.log(exp_term)
# Blackbody f_lambda function;
# discard normalizing factors; we only care about finding the
# ratio of fluxes between the case with dust extinction and
# the case without dust extinction
log_bb_flambda = -5.0 * np.log(bb_wavelen) + ln_exp_term
bb_flambda = np.exp(log_bb_flambda)
bb_sed = Sed(wavelen=bb_wavelen, flambda=bb_flambda)
base_fluxes = lsstBandpassDict.fluxListForSed(bb_sed)
a_x, b_x = bb_sed.setupCCMab()
_mlt_dust_lookup = {}
_mlt_dust_lookup['ebv'] = ebv_grid
list_of_bp = lsstBandpassDict.keys()
for bp in list_of_bp:
_mlt_dust_lookup[bp] = np.zeros(len(ebv_grid))
for iebv, ebv_val in enumerate(ebv_grid):
wv, fl = bb_sed.addCCMDust(a_x,
b_x,
ebv=ebv_val,
wavelen=bb_wavelen,
flambda=bb_flambda)
dusty_bb = Sed(wavelen=wv, flambda=fl)
dusty_fluxes = lsstBandpassDict.fluxListForSed(dusty_bb)
for ibp, bp in enumerate(list_of_bp):
_mlt_dust_lookup[bp][iebv] = dusty_fluxes[ibp] / base_fluxes[ibp]
return _mlt_dust_lookup
def gen_gums_mag_cat(istart=0, nstars=100, workdir='', noisyResponse=False, verbose=False, save=True):
"""
generate a catalog of true and observed magnitudes for stars from the gums catalog
"""
# Load response functions
responses = []
response_temperatures = []
response_files = glob.glob('gaia_response_*00.npz')
for fn in response_files:
responses.append(gaia_response(restore_file=fn))
response_temperatures.append(float(fn.replace('.npz', '').split('_')[-1]))
response_temperatures = np.array(response_temperatures)
#if noisyResponse:
# response = gaia_response()
#else:
# response = gaia_response(restore_file='gaia_response_nonoise.npz')
# Load gums catalog
gum_cat = gums_catalog()
gum_cat.prune()
gum_cat = gum_cat.catalog
print 'using %i stars from GAIA' % gum_cat.size
sed = Sed()
# Load up bandpass
imsimBand = Bandpass()
imsimBand.imsimBandpass()
bps = lsst_filters()
bps.update(stubb_fitlers())
names = ['id', 'sourceExtendedId', 'raj2000', 'dej2000', 'u_truncated', 'u', 'g', 'r',
'i', 'z', 'y', 'y_truncated',
'u_truncated_noiseless', 'u_noiseless', 'g_noiseless', 'r_noiseless',
'i_noiseless', 'z_noiseless', 'y_noiseless', 'y_truncated_noiseless',
'u_truncated_true', 'u_true', 'g_true', 'r_true', 'i_true', 'z_true',
'y_true', 'y_truncated_true', 'teff', 'feH', 'logg', 'Av', 'magG']
types = [int, '|S30']
types.extend([float]*(len(names)-1))
result_cat = np.zeros(nstars, dtype=zip(names, types))
copy_keys = ['sourceExtendedId', 'raj2000', 'dej2000']
a_x = None
b_x = None
maxI = float(nstars)
for i, gems_index in enumerate(np.arange(istart, istart+nstars)):
result_cat['id'][i] = gems_index
for key in copy_keys:
result_cat[key][i] = gum_cat[key][gems_index]
# Lookup the file with the closest teff, feH, and logg to gum_cat[i]
sed, pd = read_close_Kurucz(gum_cat['teff'][gems_index], gum_cat['feH'][gems_index],
gum_cat['logg'][gems_index])
result_cat['teff'][i] = gum_cat['teff'][gems_index]
result_cat['feH'][i] = gum_cat['feH'][gems_index]
result_cat['logg'][i] = gum_cat['logg'][gems_index]
result_cat['Av'][i] = gum_cat['Av'][gems_index]
result_cat['magG'] = gum_cat['magG'][gems_index]
# Let's figure out the GAIA-G to SDSS g conversion. Assume SDSS_g ~ LSST_g
# poly fit from https://arxiv.org/pdf/1008.0815.pdf
g_mag = sed.calcMag(bps['g'])
i_mag = sed.calcMag(bps['i'])
g_i = g_mag - i_mag
gnorm = gum_cat['magG'][gems_index] + 0.0094 + 0.531*(g_i) + 0.0974*(g_i)**2 - 0.0052*(g_i)**3
if a_x is None:
a_x, b_x = sed.setupCCMab()
sed.addCCMDust(a_x, b_x, A_v=gum_cat['Av'][gems_index])
# do the magnorm here
fNorm = sed.calcFluxNorm(gnorm, bps['g'])
sed.multiplyFluxNorm(fNorm)
# Observe sed with GAIA, both with and without noise
# Wrap in a try block so if ULYSSES fails for some reason the star just gets skipped
gaia_observed = SED2GAIA(sed, workdir=workdir)
tdiff = np.abs(response_temperatures - result_cat['teff'][i])
tmatch = np.where(tdiff == tdiff.min())[0]
observed_sed = ulysses2SED(data=gaia_observed, response=responses[tmatch])
not_nan = ~np.isnan(observed_sed.flambda)
# Let's interpolate out any nans
observed_sed.flambda = np.interp(observed_sed.wavelen, observed_sed.wavelen[not_nan],
observed_sed.flambda[not_nan])
for filtername in bps:
try:
result_cat[filtername][i] = observed_sed.calcMag(bps[filtername])
except:
pass
result_cat[filtername+'_true'][i] = sed.calcMag(bps[filtername])
# Now do it on a noiseless spectra
gaia_observed = SED2GAIA(sed, workdir=workdir, noise=0)
observed_sed = ulysses2SED(data=gaia_observed, response=responses[tmatch], noisy=False)
not_nan = ~np.isnan(observed_sed.flambda)
# Let's interpolate out any nans
observed_sed.flambda = np.interp(observed_sed.wavelen, observed_sed.wavelen[not_nan],
observed_sed.flambda[not_nan])
for filtername in bps:
try:
result_cat[filtername+'_noiseless'][i] = observed_sed.calcMag(bps[filtername])
except:
pass
if verbose:
progress = i/maxI*100
text = "\rprogress = %.1f%%"%progress
sys.stdout.write(text)
sys.stdout.flush()
# Try to catch a failure example:
#if (result_cat['g'][i] < 18.) & (result_cat['g'][i] > 0.):
# if (np.abs(result_cat['g'][i]-result_cat['g_true'][i]) > 0.75) | (np.abs(result_cat['r'][i]-result_cat['r_true'][i]) > 0.75):
# import matplotlib.pylab as plt
# import pdb ; pdb.set_trace()
print ''
if save:
np.savez('%i_%i_gum_mag_cat.npz' % (istart, nstars+istart), result_cat=result_cat)
else:
return result_cat, sed, observed_sed
# galaxies require more calculations (which aren't part of manyMagCalc) and partly because we're using a different
# optimization (bandpass.manyMagCalc instead of sed.manyMagCalc).
# Start 'regular' magnitude calculation.
# Calculate dust extinction a_x and b_x vectors.
a_mw, b_mw = stars[starlist[0]].setupCCMab()
# Set up dictionary + arrays to hold calculated magnitude information.
mags1 = {}
for f in filterlist:
mags1[f] = numpy.zeros(num_star, dtype="float")
# For each star (in num_star's), apply apply MW dust, fluxnorm & calculate mags.
for i in range(num_star):
starname = starlist[star_name[i]]
tmpstar = Sed(wavelen=stars[starname].wavelen, flambda=stars[starname].flambda)
tmpstar.addCCMDust(a_mw, b_mw, ebv=ebv_mw[i])
tmpstar.multiplyFluxNorm(fluxnorm[i])
# Note that the stars have already been matched to the bandpass wavelength grid.
# Just want to be sure that fnu is already calculated.
tmpstar.flambdaTofnu()
for f in filterlist:
mags1[f][i] = tmpstar.calcMag(lsstbp[f])
dt, t = dtime(t)
print "Calculating dust/fluxnorm/%d magnitudes with some smart usage for %d stars took %f s" % (
len(filterlist),
num_star,
dt,
)
# Test Sed.manyMagCalc :
def testAddingNonesToList(self):
"""
Test what happens if you add SEDs to an SedList that have None for
one or more of the physical parameters (i.e. galacticAv, internalAv, or redshift)
"""
imsimBand = Bandpass()
imsimBand.imsimBandpass()
nSed = 10
sedNameList_0 = self.getListOfSedNames(nSed)
magNormList_0 = self.rng.random_sample(nSed) * 5.0 + 15.0
internalAvList_0 = self.rng.random_sample(nSed) * 0.3 + 0.1
redshiftList_0 = self.rng.random_sample(nSed) * 5.0
galacticAvList_0 = self.rng.random_sample(nSed) * 0.3 + 0.1
wavelen_match = np.arange(300.0, 1500.0, 10.0)
testList = SedList(sedNameList_0,
magNormList_0,
internalAvList=internalAvList_0,
redshiftList=redshiftList_0,
galacticAvList=galacticAvList_0,
wavelenMatch=wavelen_match)
sedNameList_1 = self.getListOfSedNames(nSed)
magNormList_1 = list(self.rng.random_sample(nSed) * 5.0 + 15.0)
internalAvList_1 = list(self.rng.random_sample(nSed) * 0.3 + 0.1)
redshiftList_1 = list(self.rng.random_sample(nSed) * 5.0)
galacticAvList_1 = list(self.rng.random_sample(nSed) * 0.3 + 0.1)
internalAvList_1[0] = None
redshiftList_1[1] = None
galacticAvList_1[2] = None
internalAvList_1[3] = None
redshiftList_1[3] = None
internalAvList_1[4] = None
galacticAvList_1[4] = None
redshiftList_1[5] = None
galacticAvList_1[5] = None
internalAvList_1[6] = None
redshiftList_1[6] = None
galacticAvList_1[6] = None
testList.loadSedsFromList(sedNameList_1,
magNormList_1,
internalAvList=internalAvList_1,
galacticAvList=galacticAvList_1,
redshiftList=redshiftList_1)
self.assertEqual(len(testList), 2 * nSed)
np.testing.assert_array_equal(wavelen_match, testList.wavelenMatch)
for ix in range(len(sedNameList_0)):
self.assertAlmostEqual(internalAvList_0[ix],
testList.internalAvList[ix], 10)
self.assertAlmostEqual(galacticAvList_0[ix],
testList.galacticAvList[ix], 10)
self.assertAlmostEqual(redshiftList_0[ix],
testList.redshiftList[ix], 10)
for ix in range(len(sedNameList_1)):
self.assertAlmostEqual(internalAvList_1[ix],
testList.internalAvList[ix + nSed], 10)
self.assertAlmostEqual(galacticAvList_1[ix],
testList.galacticAvList[ix + nSed], 10)
self.assertAlmostEqual(redshiftList_1[ix],
testList.redshiftList[ix + nSed], 10)
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_0, magNormList_0, internalAvList_0,
galacticAvList_0, redshiftList_0)):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name + '.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=iav)
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix]
np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_1, magNormList_1, internalAvList_1,
galacticAvList_1, redshiftList_1)):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name + '.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
if iav is not None:
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=iav)
if zz is not None:
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
if gav is not None:
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix + nSed]
np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
def testFlush(self):
"""
Test that the flush method of SedList behaves properly
"""
imsimBand = Bandpass()
imsimBand.imsimBandpass()
nSed = 10
sedNameList_0 = self.getListOfSedNames(nSed)
magNormList_0 = self.rng.random_sample(nSed) * 5.0 + 15.0
internalAvList_0 = self.rng.random_sample(nSed) * 0.3 + 0.1
redshiftList_0 = self.rng.random_sample(nSed) * 5.0
galacticAvList_0 = self.rng.random_sample(nSed) * 0.3 + 0.1
wavelen_match = np.arange(300.0, 1500.0, 10.0)
testList = SedList(sedNameList_0,
magNormList_0,
internalAvList=internalAvList_0,
redshiftList=redshiftList_0,
galacticAvList=galacticAvList_0,
wavelenMatch=wavelen_match)
self.assertEqual(len(testList), nSed)
np.testing.assert_array_equal(wavelen_match, testList.wavelenMatch)
for ix in range(len(sedNameList_0)):
self.assertAlmostEqual(internalAvList_0[ix],
testList.internalAvList[ix], 10)
self.assertAlmostEqual(galacticAvList_0[ix],
testList.galacticAvList[ix], 10)
self.assertAlmostEqual(redshiftList_0[ix],
testList.redshiftList[ix], 10)
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_0, magNormList_0, internalAvList_0,
galacticAvList_0, redshiftList_0)):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name + '.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=iav)
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix]
np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
testList.flush()
sedNameList_1 = self.getListOfSedNames(nSed // 2)
magNormList_1 = self.rng.random_sample(nSed // 2) * 5.0 + 15.0
internalAvList_1 = self.rng.random_sample(nSed // 2) * 0.3 + 0.1
redshiftList_1 = self.rng.random_sample(nSed // 2) * 5.0
galacticAvList_1 = self.rng.random_sample(nSed // 2) * 0.3 + 0.1
testList.loadSedsFromList(sedNameList_1,
magNormList_1,
internalAvList=internalAvList_1,
galacticAvList=galacticAvList_1,
redshiftList=redshiftList_1)
self.assertEqual(len(testList), nSed / 2)
self.assertEqual(len(testList.redshiftList), nSed / 2)
self.assertEqual(len(testList.internalAvList), nSed / 2)
self.assertEqual(len(testList.galacticAvList), nSed / 2)
np.testing.assert_array_equal(wavelen_match, testList.wavelenMatch)
for ix in range(len(sedNameList_1)):
self.assertAlmostEqual(internalAvList_1[ix],
testList.internalAvList[ix], 10)
self.assertAlmostEqual(galacticAvList_1[ix],
testList.galacticAvList[ix], 10)
self.assertAlmostEqual(redshiftList_1[ix],
testList.redshiftList[ix], 10)
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_1, magNormList_1, internalAvList_1,
galacticAvList_1, redshiftList_1)):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name + '.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=iav)
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix]
np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
def testAddingNonesToList(self):
"""
Test what happens if you add SEDs to an SedList that have None for
one or more of the physical parameters (i.e. galacticAv, internalAv, or redshift)
"""
imsimBand = Bandpass()
imsimBand.imsimBandpass()
nSed = 10
sedNameList_0 = self.getListOfSedNames(nSed)
magNormList_0 = numpy.random.random_sample(nSed)*5.0 + 15.0
internalAvList_0 = numpy.random.random_sample(nSed)*0.3 + 0.1
redshiftList_0 = numpy.random.random_sample(nSed)*5.0
galacticAvList_0 = numpy.random.random_sample(nSed)*0.3 + 0.1
wavelen_match = numpy.arange(300.0, 1500.0, 10.0)
testList = SedList(sedNameList_0, magNormList_0, internalAvList=internalAvList_0, \
redshiftList=redshiftList_0, galacticAvList=galacticAvList_0,
wavelenMatch=wavelen_match)
sedNameList_1 = self.getListOfSedNames(nSed)
magNormList_1 = list(numpy.random.random_sample(nSed)*5.0 + 15.0)
internalAvList_1 = list(numpy.random.random_sample(nSed)*0.3 + 0.1)
redshiftList_1 = list(numpy.random.random_sample(nSed)*5.0)
galacticAvList_1 = list(numpy.random.random_sample(nSed)*0.3 + 0.1)
internalAvList_1[0] = None
redshiftList_1[1] = None
galacticAvList_1[2] = None
internalAvList_1[3] = None
redshiftList_1[3] = None
internalAvList_1[4] = None
galacticAvList_1[4] = None
redshiftList_1[5] = None
galacticAvList_1[5] = None
internalAvList_1[6] = None
redshiftList_1[6] = None
galacticAvList_1[6] = None
testList.loadSedsFromList(sedNameList_1, magNormList_1,
internalAvList=internalAvList_1,
galacticAvList=galacticAvList_1,
redshiftList=redshiftList_1)
self.assertEqual(len(testList), 2*nSed)
numpy.testing.assert_array_equal(wavelen_match, testList.wavelenMatch)
for ix in range(len(sedNameList_0)):
self.assertAlmostEqual(internalAvList_0[ix], testList.internalAvList[ix], 10)
self.assertAlmostEqual(galacticAvList_0[ix], testList.galacticAvList[ix], 10)
self.assertAlmostEqual(redshiftList_0[ix], testList.redshiftList[ix], 10)
for ix in range(len(sedNameList_1)):
self.assertAlmostEqual(internalAvList_1[ix], testList.internalAvList[ix+nSed], 10)
self.assertAlmostEqual(galacticAvList_1[ix], testList.galacticAvList[ix+nSed], 10)
self.assertAlmostEqual(redshiftList_1[ix], testList.redshiftList[ix+nSed], 10)
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_0, magNormList_0, internalAvList_0, \
galacticAvList_0, redshiftList_0)):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=iav)
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix]
numpy.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
numpy.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
numpy.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_1, magNormList_1, internalAvList_1, \
galacticAvList_1, redshiftList_1)):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
if iav is not None:
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=iav)
if zz is not None:
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
if gav is not None:
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix+nSed]
numpy.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
numpy.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
numpy.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
def testAddingToList(self):
"""
Test that we can add Seds to an already instantiated SedList
"""
imsimBand = Bandpass()
imsimBand.imsimBandpass()
nSed = 10
sedNameList_0 = self.getListOfSedNames(nSed)
magNormList_0 = numpy.random.random_sample(nSed)*5.0 + 15.0
internalAvList_0 = numpy.random.random_sample(nSed)*0.3 + 0.1
redshiftList_0 = numpy.random.random_sample(nSed)*5.0
galacticAvList_0 = numpy.random.random_sample(nSed)*0.3 + 0.1
wavelen_match = numpy.arange(300.0, 1500.0, 10.0)
testList = SedList(sedNameList_0, magNormList_0, internalAvList=internalAvList_0, \
redshiftList=redshiftList_0, galacticAvList=galacticAvList_0,
wavelenMatch=wavelen_match)
# experiment with adding different combinations of physical parameter lists
# as None and not None
for addIav in [True, False]:
for addRedshift in [True, False]:
for addGav in [True, False]:
testList = SedList(sedNameList_0, magNormList_0, internalAvList=internalAvList_0, \
redshiftList=redshiftList_0, galacticAvList=galacticAvList_0,
wavelenMatch=wavelen_match)
sedNameList_1 = self.getListOfSedNames(nSed)
magNormList_1 = numpy.random.random_sample(nSed)*5.0 + 15.0
if addIav:
internalAvList_1 = numpy.random.random_sample(nSed)*0.3 + 0.1
else:
internalAvList_1 = None
if addRedshift:
redshiftList_1 = numpy.random.random_sample(nSed)*5.0
else:
redshiftList_1 = None
if addGav:
galacticAvList_1 = numpy.random.random_sample(nSed)*0.3 + 0.1
else:
galacticAvList_1 = None
testList.loadSedsFromList(sedNameList_1, magNormList_1,
internalAvList=internalAvList_1,
galacticAvList=galacticAvList_1,
redshiftList=redshiftList_1)
self.assertEqual(len(testList), 2*nSed)
numpy.testing.assert_array_equal(wavelen_match, testList.wavelenMatch)
for ix in range(len(sedNameList_0)):
self.assertAlmostEqual(internalAvList_0[ix], testList.internalAvList[ix], 10)
self.assertAlmostEqual(galacticAvList_0[ix], testList.galacticAvList[ix], 10)
self.assertAlmostEqual(redshiftList_0[ix], testList.redshiftList[ix], 10)
for ix in range(len(sedNameList_1)):
if addIav:
self.assertAlmostEqual(internalAvList_1[ix], testList.internalAvList[ix+nSed], 10)
else:
self.assertTrue(testList.internalAvList[ix+nSed] is None)
if addGav:
self.assertAlmostEqual(galacticAvList_1[ix], testList.galacticAvList[ix+nSed], 10)
else:
self.assertTrue(testList.galacticAvList[ix+nSed] is None)
if addRedshift:
self.assertAlmostEqual(redshiftList_1[ix], testList.redshiftList[ix+nSed], 10)
else:
self.assertTrue(testList.redshiftList[ix+nSed] is None)
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_0, magNormList_0, internalAvList_0, \
galacticAvList_0, redshiftList_0)):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=iav)
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix]
numpy.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
numpy.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
numpy.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
if not addIav:
internalAvList_1 = [None] * nSed
if not addRedshift:
redshiftList_1 = [None] * nSed
if not addGav:
galacticAvList_1 = [None] * nSed
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_1, magNormList_1, internalAvList_1, \
galacticAvList_1, redshiftList_1)):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
if addIav:
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=iav)
if addRedshift:
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
if addGav:
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix+nSed]
numpy.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
numpy.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
numpy.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
def test_mixed_stars(self):
"""
Here we will test the (somewhat absurd) case of a catalog with two different bandpasses
(lsst_ and cartoon_) in order to verify that gamma values are being cached correctly
"""
lsst_u_band = Bandpass()
lsst_u_band.readThroughput(os.path.join(getPackageDir('throughputs'), 'baseline', 'total_u.dat'))
lsst_g_band = Bandpass()
lsst_g_band.readThroughput(os.path.join(getPackageDir('throughputs'), 'baseline', 'total_g.dat'))
obs = ObservationMetaData(bandpassName=['c_u', 'c_g', 'u', 'g'],
m5=[25.0, 26.0, 15.0, 16.0])
# make the difference in m5 between the two bandpass systems extreme
# so that, in the unit test, we can be sure that the correct values
# are being used for the correct getters
db_dtype = np.dtype([('id', np.int),
('raJ2000', np.float),
('decJ2000', np.float),
('sedFilename', str, 100),
('magNorm', np.float),
('galacticAv', np.float)])
inputDir = os.path.join(getPackageDir('sims_catUtils'), 'tests', 'testData')
inputFile = os.path.join(inputDir, 'IndicesTestCatalogStars.txt')
db = fileDBObject(inputFile, dtype=db_dtype, runtable='test', idColKey='id')
catName = os.path.join(getPackageDir('sims_catUtils'), 'tests', 'scratchSpace', 'cartoonStarCat.txt')
cat = CartoonStars(db, obs_metadata=obs, column_outputs=['lsst_u', 'lsst_g',
'sigma_lsst_u', 'sigma_lsst_g'])
cat.write_catalog(catName)
dtype = np.dtype([(name, np.float) for name in cat._column_outputs])
controlData = np.genfromtxt(catName, dtype=dtype, delimiter=',')
if os.path.exists(catName):
os.unlink(catName)
db_columns = db.query_columns(['id', 'raJ2000', 'decJ2000', 'sedFilename', 'magNorm', 'galacticAv'])
sedDir = os.path.join(getPackageDir('sims_sed_library'), 'starSED', 'kurucz')
for ix, line in enumerate(next(db_columns)):
spectrum = Sed()
spectrum.readSED_flambda(os.path.join(sedDir, line[3]))
fnorm = spectrum.calcFluxNorm(line[4], self.normband)
spectrum.multiplyFluxNorm(fnorm)
a_x, b_x = spectrum.setupCCMab()
spectrum.addCCMDust(a_x, b_x, A_v=line[5])
umag = spectrum.calcMag(self.uband)
self.assertAlmostEqual(umag, controlData['cartoon_u'][ix], 3)
gmag = spectrum.calcMag(self.gband)
self.assertAlmostEqual(gmag, controlData['cartoon_g'][ix], 3)
lsst_umag = spectrum.calcMag(lsst_u_band)
self.assertAlmostEqual(lsst_umag, controlData['lsst_u'][ix], 3)
lsst_gmag = spectrum.calcMag(lsst_g_band)
self.assertAlmostEqual(lsst_gmag, controlData['lsst_g'][ix], 3)
umagError, gamma = calcMagError_m5(umag, self.uband, obs.m5['c_u'], PhotometricParameters())
gmagError, gamma = calcMagError_m5(gmag, self.gband, obs.m5['c_g'], PhotometricParameters())
self.assertAlmostEqual(umagError, controlData['sigma_cartoon_u'][ix], 3)
self.assertAlmostEqual(gmagError, controlData['sigma_cartoon_g'][ix], 3)
lsst_umagError, gamma = calcMagError_m5(lsst_umag, lsst_u_band,
obs.m5['u'], PhotometricParameters())
lsst_gmagError, gamma = calcMagError_m5(lsst_gmag, lsst_g_band,
obs.m5['g'], PhotometricParameters())
self.assertAlmostEqual(lsst_umagError, controlData['sigma_lsst_u'][ix], 3)
self.assertAlmostEqual(lsst_gmagError, controlData['sigma_lsst_g'][ix], 3)
self.assertGreater(np.abs(lsst_umagError-umagError), 0.01)
self.assertGreater(np.abs(lsst_gmagError-gmagError), 0.01)
def testAlternateNormalizingBandpass(self):
"""
A reiteration of testAddingToList, but testing with a non-imsimBandpass
normalizing bandpass
"""
normalizingBand = Bandpass()
normalizingBand.readThroughput(os.path.join(getPackageDir('throughputs'),'baseline','total_r.dat'))
nSed = 10
sedNameList_0 = self.getListOfSedNames(nSed)
magNormList_0 = numpy.random.random_sample(nSed)*5.0 + 15.0
internalAvList_0 = numpy.random.random_sample(nSed)*0.3 + 0.1
redshiftList_0 = numpy.random.random_sample(nSed)*5.0
galacticAvList_0 = numpy.random.random_sample(nSed)*0.3 + 0.1
wavelen_match = numpy.arange(300.0, 1500.0, 10.0)
testList = SedList(sedNameList_0, magNormList_0,
normalizingBandpass=normalizingBand,
internalAvList=internalAvList_0,
redshiftList=redshiftList_0, galacticAvList=galacticAvList_0,
wavelenMatch=wavelen_match)
sedNameList_1 = self.getListOfSedNames(nSed)
magNormList_1 = numpy.random.random_sample(nSed)*5.0 + 15.0
internalAvList_1 = numpy.random.random_sample(nSed)*0.3 + 0.1
redshiftList_1 = numpy.random.random_sample(nSed)*5.0
galacticAvList_1 = numpy.random.random_sample(nSed)*0.3 + 0.1
testList.loadSedsFromList(sedNameList_1, magNormList_1,
internalAvList=internalAvList_1,
galacticAvList=galacticAvList_1,
redshiftList=redshiftList_1)
self.assertEqual(len(testList), 2*nSed)
numpy.testing.assert_array_equal(wavelen_match, testList.wavelenMatch)
for ix in range(len(sedNameList_0)):
self.assertAlmostEqual(internalAvList_0[ix], testList.internalAvList[ix], 10)
self.assertAlmostEqual(galacticAvList_0[ix], testList.galacticAvList[ix], 10)
self.assertAlmostEqual(redshiftList_0[ix], testList.redshiftList[ix], 10)
for ix in range(len(sedNameList_1)):
self.assertAlmostEqual(internalAvList_1[ix], testList.internalAvList[ix+nSed], 10)
self.assertAlmostEqual(galacticAvList_1[ix], testList.galacticAvList[ix+nSed], 10)
self.assertAlmostEqual(redshiftList_1[ix], testList.redshiftList[ix+nSed], 10)
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_0, magNormList_0, internalAvList_0, \
galacticAvList_0, redshiftList_0)):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, normalizingBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=iav)
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix]
numpy.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
numpy.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
numpy.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_1, magNormList_1, internalAvList_1, \
galacticAvList_1, redshiftList_1)):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, normalizingBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=iav)
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix+nSed]
numpy.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
numpy.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
numpy.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
def testFlush(self):
"""
Test that the flush method of SedList behaves properly
"""
imsimBand = Bandpass()
imsimBand.imsimBandpass()
nSed = 10
sedNameList_0 = self.getListOfSedNames(nSed)
magNormList_0 = numpy.random.random_sample(nSed)*5.0 + 15.0
internalAvList_0 = numpy.random.random_sample(nSed)*0.3 + 0.1
redshiftList_0 = numpy.random.random_sample(nSed)*5.0
galacticAvList_0 = numpy.random.random_sample(nSed)*0.3 + 0.1
wavelen_match = numpy.arange(300.0, 1500.0, 10.0)
testList = SedList(sedNameList_0, magNormList_0, internalAvList=internalAvList_0, \
redshiftList=redshiftList_0, galacticAvList=galacticAvList_0,
wavelenMatch=wavelen_match)
self.assertEqual(len(testList), nSed)
numpy.testing.assert_array_equal(wavelen_match, testList.wavelenMatch)
for ix in range(len(sedNameList_0)):
self.assertAlmostEqual(internalAvList_0[ix], testList.internalAvList[ix], 10)
self.assertAlmostEqual(galacticAvList_0[ix], testList.galacticAvList[ix], 10)
self.assertAlmostEqual(redshiftList_0[ix], testList.redshiftList[ix], 10)
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_0, magNormList_0, internalAvList_0, \
galacticAvList_0, redshiftList_0)):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=iav)
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix]
numpy.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
numpy.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
numpy.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
testList.flush()
sedNameList_1 = self.getListOfSedNames(nSed/2)
magNormList_1 = numpy.random.random_sample(nSed/2)*5.0 + 15.0
internalAvList_1 = numpy.random.random_sample(nSed/2)*0.3 + 0.1
redshiftList_1 = numpy.random.random_sample(nSed/2)*5.0
galacticAvList_1 = numpy.random.random_sample(nSed/2)*0.3 + 0.1
testList.loadSedsFromList(sedNameList_1, magNormList_1,
internalAvList=internalAvList_1,
galacticAvList=galacticAvList_1,
redshiftList=redshiftList_1)
self.assertEqual(len(testList), nSed/2)
self.assertEqual(len(testList.redshiftList), nSed/2)
self.assertEqual(len(testList.internalAvList), nSed/2)
self.assertEqual(len(testList.galacticAvList), nSed/2)
numpy.testing.assert_array_equal(wavelen_match, testList.wavelenMatch)
for ix in range(len(sedNameList_1)):
self.assertAlmostEqual(internalAvList_1[ix], testList.internalAvList[ix], 10)
self.assertAlmostEqual(galacticAvList_1[ix], testList.galacticAvList[ix], 10)
self.assertAlmostEqual(redshiftList_1[ix], testList.redshiftList[ix], 10)
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_1, magNormList_1, internalAvList_1, \
galacticAvList_1, redshiftList_1)):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=iav)
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix]
numpy.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
numpy.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
numpy.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
def testGalaxyPhotometricUncertainties(self):
"""
Test in the case of a catalog of galaxies
"""
lsstDefaults = LSSTdefaults()
galDB = testGalaxyTileDBObj(driver=self.driver,
host=self.host,
database=self.dbName)
galCat = testGalaxyCatalog(galDB, obs_metadata=self.obs_metadata)
imsimband = Bandpass()
imsimband.imsimBandpass()
ct = 0
for line in galCat.iter_catalog():
bulgeSedName = line[50]
diskSedName = line[51]
agnSedName = line[52]
magNormBulge = line[53]
magNormDisk = line[54]
magNormAgn = line[55]
avBulge = line[56]
avDisk = line[57]
redshift = line[58]
bulgeSed = Sed()
bulgeSed.readSED_flambda(
os.path.join(getPackageDir('sims_sed_library'),
defaultSpecMap[bulgeSedName]))
fNorm = bulgeSed.calcFluxNorm(magNormBulge, imsimband)
bulgeSed.multiplyFluxNorm(fNorm)
diskSed = Sed()
diskSed.readSED_flambda(
os.path.join(getPackageDir('sims_sed_library'),
defaultSpecMap[diskSedName]))
fNorm = diskSed.calcFluxNorm(magNormDisk, imsimband)
diskSed.multiplyFluxNorm(fNorm)
agnSed = Sed()
agnSed.readSED_flambda(
os.path.join(getPackageDir('sims_sed_library'),
defaultSpecMap[agnSedName]))
fNorm = agnSed.calcFluxNorm(magNormAgn, imsimband)
agnSed.multiplyFluxNorm(fNorm)
a_int, b_int = bulgeSed.setupCCMab()
bulgeSed.addCCMDust(a_int, b_int, A_v=avBulge)
a_int, b_int = diskSed.setupCCMab()
diskSed.addCCMDust(a_int, b_int, A_v=avDisk)
bulgeSed.redshiftSED(redshift, dimming=True)
diskSed.redshiftSED(redshift, dimming=True)
agnSed.redshiftSED(redshift, dimming=True)
bulgeSed.resampleSED(wavelen_match=self.totalBandpasses[0].wavelen)
diskSed.resampleSED(wavelen_match=bulgeSed.wavelen)
agnSed.resampleSED(wavelen_match=bulgeSed.wavelen)
np.testing.assert_almost_equal(bulgeSed.wavelen, diskSed.wavelen)
np.testing.assert_almost_equal(bulgeSed.wavelen, agnSed.wavelen)
fl = bulgeSed.flambda + diskSed.flambda + agnSed.flambda
totalSed = Sed(wavelen=bulgeSed.wavelen, flambda=fl)
sedList = [totalSed, bulgeSed, diskSed, agnSed]
for i, spectrum in enumerate(sedList):
if i == 0:
msgroot = 'failed on total'
elif i == 1:
msgroot = 'failed on bulge'
elif i == 2:
msgroot = 'failed on disk'
elif i == 3:
msgroot = 'failed on agn'
for j, b in enumerate(self.bandpasses):
controlSigma = calcMagError_sed(
spectrum,
self.totalBandpasses[j],
self.skySeds[j],
self.hardwareBandpasses[j],
FWHMeff=lsstDefaults.FWHMeff(b),
photParams=PhotometricParameters())
testSigma = line[26 + (i * 6) + j]
msg = '%e neq %e; ' % (testSigma, controlSigma) + msgroot
self.assertAlmostEqual(testSigma,
controlSigma,
10,
msg=msg)
ct += 1
self.assertGreater(ct, 0)
counts = star.calcADU(rband, expTime=30)
print "This would correspond to roughly %f counts in the LSST focal plane, in a 30s exposure." % (
counts)
# For fun, let's see what else can happen.
ebv = 0.5
print ""
print "Let's try adding %.2f E(B-V) dust extinction to this star." % (ebv)
a, b = star.setupCCMab()
# You can use addCCMDust on the 'star' object itself, but I'm illustrating here how you could also
# do otherwise - preserve the original 'star' object as is, and create a new Sed object that does
# include the effects of dust ('dustystar'). Star's data will be unchanged by the dust.
dustywavelen, dustyflambda = star.addCCMDust(a,
b,
ebv=ebv,
wavelen=star.wavelen,
flambda=star.flambda)
dustystar = Sed(wavelen=dustywavelen, flambda=dustyflambda)
magdust = dustystar.calcMag(rband)
print "With this dust, the magnitude of the star in this bandpass is now %.4f." % (
magdust)
redshift = 0.2
print "What if this star was at a redshift of %f?" % (redshift)
# Here (unlike above with the dust), I'm applying the redshift to the 'star' object itself.
# Star's data will be changed by the redshifting.
star.redshiftSED(redshift, dimming=True)
magredshift = star.calcMag(rband)
print ""
print "Redshifted to %.2f, and adding cosmological dimming, the magnitude is now %.4f" \
# create the a,b arrays for all the stars (because we resampled the stars onto the
# same wavelength range we can just calculate a/b once, and this is slow)
a, b = stars[starskeys[0]].setupCCMab()
# pretend we want to read mags into an array .. you could just as easily put it into a
# dictionary or list, with small variations in the code
mags = n.empty(len(starskeys), dtype="float")
mags2 = n.empty(len(starskeys), dtype="float")
sedlist = []
for i in range(len(starskeys)):
# make a copy of the original SED *if* you want to 'reuse' the SED for multiple magnitude
# calculations with various fluxnorms and dust applications (otherwise just use the object
# you instantiated above)
tmpstar = Sed(wavelen=stars[starskeys[i]].wavelen, flambda=stars[starskeys[i]].flambda)
tmpstar.addCCMDust(a, b, ebv=ebv[i])
tmpstar.multiplyFluxNorm(fluxnorm[i])
mags[i] = tmpstar.calcMag(rband)
# This is for showing an example of the manyMagCalc function on bandpass
sedlist.append(tmpstar)
# Now, pretend we're actually wanting to calculate the magnitude in multiple bandpasses.
# (ignore the part that uses exampleBandpass.dat as the source .. you would replace that with
# rootdir + "total_" + filter where filter is a member of lsstfilterlist
lsstfilterlist = ["u", "g", "r", "i", "z", "y"]
lsst = {}
rootdir = "./"
for filter in lsstfilterlist:
lsst[filter] = Bandpass()
lsst[filter].readThroughput(rootdir + "exampleBandpass.dat")
def test_flare_magnitudes_mixed_with_dummy(self):
"""
Test that we get the expected magnitudes out
"""
db = MLT_test_DB(database=self.db_name, driver='sqlite')
# load the quiescent SEDs of the objects in our catalog
sed_list = SedList(['lte028-5.0+0.5a+0.0.BT-Settl.spec.gz'] * 4,
[17.1, 17.2, 17.3, 17.4],
galacticAvList=[2.432, 1.876, 2.654, 2.364])
bp_dict = BandpassDict.loadTotalBandpassesFromFiles()
# calculate the quiescent fluxes of the objects in our catalog
baseline_fluxes = bp_dict.fluxListForSedList(sed_list)
bb_wavelen = np.arange(100.0, 1600.0, 0.1)
bb_flambda = blackbody_lambda(bb_wavelen * 10.0, 9000.0)
# this data is taken from the setUpClass() classmethod above
t0_list = [456.2, 41006.2, 117.2, 10456.2]
av_list = [2.432, 1.876, 2.654, 2.364]
parallax_list = np.array([0.25, 0.15, 0.3, 0.22])
distance_list = 1.0 / (206265.0 *
radiansFromArcsec(0.001 * parallax_list))
distance_list *= 3.0857e16 # convert to cm
dtype = np.dtype([('id', int), ('u', float), ('g', float)])
photParams = PhotometricParameters()
ss = Sed()
quiet_cat_name = os.path.join(self.scratch_dir,
'mlt_mixed_with_dummy_quiet_cat.txt')
flare_cat_name = os.path.join(self.scratch_dir,
'mlt_mixed_with_dummy_flaring_cat.txt')
# loop over several MJDs and verify that, to within a
# milli-mag, our flaring model gives us the magnitudes
# expected, given the light curves specified in
# setUpClass()
for mjd in (59580.0, 60000.0, 70000.0, 80000.0):
obs = ObservationMetaData(mjd=mjd)
quiet_cat = QuiescentCatalog(db, obs_metadata=obs)
quiet_cat.write_catalog(quiet_cat_name)
flare_cat = FlaringCatalogDummy(db, obs_metadata=obs)
flare_cat._mlt_lc_file = self.mlt_lc_name
flare_cat.write_catalog(flare_cat_name)
quiescent_data = np.genfromtxt(quiet_cat_name,
dtype=dtype,
delimiter=',')
flaring_data = np.genfromtxt(flare_cat_name,
dtype=dtype,
delimiter=',')
for ix in range(len(flaring_data)):
obj_id = flaring_data['id'][ix]
self.assertEqual(obj_id, ix)
msg = (
'failed on object %d; mjd %.2f\n u_quiet %e u_flare %e\n g_quiet %e g_flare %e'
% (obj_id, mjd, quiescent_data['u'][obj_id],
flaring_data['u'][obj_id], quiescent_data['g'][obj_id],
flaring_data['g'][obj_id]))
self.assertEqual(quiescent_data['id'][obj_id],
flaring_data['id'][obj_id],
msg=msg)
self.assertAlmostEqual(ss.magFromFlux(
baseline_fluxes[obj_id][0]),
quiescent_data['u'][obj_id],
3,
msg=msg)
self.assertAlmostEqual(ss.magFromFlux(
baseline_fluxes[obj_id][1]),
quiescent_data['g'][obj_id],
3,
msg=msg)
if obj_id != 3:
# the models below are as specified in the
# setUpClass() method
if obj_id == 0 or obj_id == 1:
amp = 1.0e32
dt = 3652.5
t_min = flare_cat._survey_start - t0_list[obj_id]
tt = mjd - t_min
while tt > dt:
tt -= dt
u_flux = amp * (1.0 + np.power(np.sin(tt / 100.0), 2))
g_flux = amp * (1.0 + np.power(np.cos(tt / 100.0), 2))
elif obj_id == 2:
amp = 2.0e31
dt = 365.25
t_min = flare_cat._survey_start - t0_list[obj_id]
tt = mjd - t_min
while tt > dt:
tt -= dt
u_flux = amp * (1.0 + np.power(np.sin(tt / 50.0), 2))
g_flux = amp * (1.0 + np.power(np.cos(tt / 50.0), 2))
# calculate the multiplicative effect of dust on a 9000K
# black body
bb_sed = Sed(wavelen=bb_wavelen, flambda=bb_flambda)
u_bb_flux = bb_sed.calcFlux(bp_dict['u'])
g_bb_flux = bb_sed.calcFlux(bp_dict['g'])
a_x, b_x = bb_sed.setupCCMab()
bb_sed.addCCMDust(a_x, b_x, A_v=av_list[obj_id])
u_bb_dusty_flux = bb_sed.calcFlux(bp_dict['u'])
g_bb_dusty_flux = bb_sed.calcFlux(bp_dict['g'])
dust_u = u_bb_dusty_flux / u_bb_flux
dust_g = g_bb_dusty_flux / g_bb_flux
area = 4.0 * np.pi * np.power(distance_list[obj_id], 2)
tot_u_flux = baseline_fluxes[obj_id][
0] + u_flux * dust_u * photParams.effarea / area
tot_g_flux = baseline_fluxes[obj_id][
1] + g_flux * dust_g * photParams.effarea / area
self.assertAlmostEqual(ss.magFromFlux(tot_u_flux),
flaring_data['u'][obj_id],
3,
msg=msg)
self.assertAlmostEqual(ss.magFromFlux(tot_g_flux),
flaring_data['g'][obj_id],
3,
msg=msg)
self.assertGreater(np.abs(flaring_data['g'][obj_id] -
quiescent_data['g'][obj_id]),
0.001,
msg=msg)
self.assertGreater(np.abs(flaring_data['u'][obj_id] -
quiescent_data['u'][obj_id]),
0.001,
msg=msg)
else:
self.assertAlmostEqual(flaring_data['g'][obj_id],
quiescent_data['g'][obj_id] + 3 *
(mjd - 59580.0) / 10000.0,
3,
msg=msg)
self.assertAlmostEqual(flaring_data['u'][obj_id],
quiescent_data['u'][obj_id] + 2 *
(mjd - 59580.0) / 10000.0,
3,
msg=msg)
if os.path.exists(quiet_cat_name):
os.unlink(quiet_cat_name)
if os.path.exists(flare_cat_name):
os.unlink(flare_cat_name)
# create the a,b arrays for all the gals (because we resampled the gals onto the
# same wavelength range we can just calculate a/b once, and this is slow)
a_gal, b_gal = gals[galaxykeys[0]].setupCCMab()
# pretend we want to read mags into an array .. you could just as easily put it into a
# dictionary or list, with small variations in the code
mags = n.empty(len(galaxykeys), dtype='float')
for i in range(len(galaxykeys)):
# make a copy of the original SED if you want to 'reuse' the SED for multiple magnitude
# calculations with various fluxnorms, redshifts and dusts
tmpgal = Sed(wavelen=gals[galaxykeys[i]].wavelen,
flambda=gals[galaxykeys[i]].flambda)
# add the dust internal to the distant galaxy
tmpgal.addCCMDust(a_gal, b_gal, ebv=ebv_gal[i])
# redshift the galaxy
tmpgal.redshiftSED(redshifts[i], dimming=False)
# add the dust from our milky way - have to recalculate a/b because now wavelenghts
# for each galaxy are *different*
a_mw, b_mw = tmpgal.setupCCMab()
tmpgal.addCCMDust(a_mw, b_mw, ebv=ebv_mw[i])
tmpgal.multiplyFluxNorm(fluxnorm[i])
mags[i] = tmpgal.calcMag(rband)
# show results
print "#sedname fluxnorm redshift ebv_gal ebv_mw magnitude "
for i in range(len(galaxykeys)):
print "%s %.5g %.3f %.5f %.5f %.5f" % (galaxykeys[i], fluxnorm[i],
redshifts[i], ebv_gal[i],
ebv_mw[i], mags[i])
sed.readSED_flambda(full_sed_name)
dustless.readSED_flambda(full_sed_name)
rest_sed.readSED_flambda(full_sed_name)
rest_sed_dustless.readSED_flambda(full_sed_name)
f_norm = getImsimFluxNorm(sed, mag_norm)
sed.multiplyFluxNorm(f_norm)
dustless.multiplyFluxNorm(f_norm)
f_norm = getImsimFluxNorm(rest_sed, rest_mag_norm)
rest_sed.multiplyFluxNorm(f_norm)
rest_sed_dustless.multiplyFluxNorm(f_norm)
a_x, b_x = sed.setupCCMab()
R_v = av/ebv
sed.addCCMDust(a_x, b_x, ebv=ebv, R_v=R_v)
rest_sed.addCCMDust(a_x, b_x, ebv=ebv, R_v=R_v)
sed.redshiftSED(full_redshift, dimming=True)
dustless.redshiftSED(full_redshift, dimming=True)
mag_list = lsst_bp_dict.magListForSed(sed)
dustless_list = lsst_bp_dict.magListForSed(dustless)
rest_list = lsst_bp_dict.magListForSed(rest_sed)
rest_dustless_list = lsst_bp_dict.magListForSed(rest_sed_dustless)
dd = 0.0
dd += (mag_list[0] - uu)**2
dd += (mag_list[1] - gg)**2
dd += (mag_list[2] - rr)**2
dd += (mag_list[3] - ii)**2
# by simply running 'python example_fastgals.py', but on my mac it was about 1.7 times faster optimized, with
# wavelen_step = 0.1 nm. (wavelen_step will have an impact on the speed difference).
# (w/ wavelen_step=0.25, find a 2.5 times faster speedup in the optimized version).
# Start 'regular' magnitude calculation.
# Calculate internal a/b on the wavelength range required for calculating internal dust extinction.
a_int, b_int = gals[gallist[0]].setupCCMab()
# Set up dictionary + arrays to hold calculated magnitude information.
mags1 = {}
for f in filterlist:
mags1[f] = numpy.zeros(num_gal, dtype='float')
# For each galaxy (in num_gal's), apply internal dust, redshift, apply MW dust, fluxnorm & calculate mags.
for i in range(num_gal):
galname = gallist[gal_name[i]]
tmpgal = Sed(wavelen=gals[galname].wavelen, flambda=gals[galname].flambda)
tmpgal.addCCMDust(a_int, b_int, ebv=ebv_int[i])
tmpgal.redshiftSED(redshifts[i])
a_mw, b_mw = tmpgal.setupCCMab()
tmpgal.addCCMDust(a_mw, b_mw, ebv=ebv_mw[i])
tmpgal.multiplyFluxNorm(fluxnorm[i])
# If you comment out the synchronize sed here, then the difference between this method and the optimized
# version increases to a 2.5 times difference. (i.e. this 'synchronizeSED' buys you 1.6x faster, by itself.)
tmpgal.synchronizeSED(wavelen_min=wavelen_min,
wavelen_max=wavelen_max,
wavelen_step=wavelen_step)
for f in filterlist:
mags1[f][i] = tmpgal.calcMag(lsstbp[f])
dt, t = dtime(t)
print "Calculating dust/redshift/dust/fluxnorm/%d magnitudes for %d galaxies took %f s" \
%(len(filterlist), num_gal, dt)
def testObjectPlacement(self):
"""
Test that GalSim places objects on the correct pixel by drawing
images, reading them in, and then comparing the flux contained in
circles of 2 fwhm radii about the object's expected positions with
the actual expected flux of the objects.
"""
scratchDir = os.path.join(getPackageDir('sims_GalSimInterface'), 'tests', 'scratchSpace')
catName = os.path.join(scratchDir, 'placementCatalog.dat')
imageRoot = os.path.join(scratchDir, 'placementImage')
dbFileName = os.path.join(scratchDir, 'placementInputCatalog.dat')
cameraDir = os.path.join(getPackageDir('sims_GalSimInterface'), 'tests', 'cameraData')
camera = ReturnCamera(cameraDir)
detector = camera[0]
imageName = '%s_%s_u.fits' % (imageRoot, detector.getName())
controlSed = Sed()
controlSed.readSED_flambda(
os.path.join(getPackageDir('sims_sed_library'),
'flatSED','sed_flat.txt.gz')
)
uBandpass = Bandpass()
uBandpass.readThroughput(
os.path.join(getPackageDir('throughputs'),
'baseline','total_u.dat')
)
controlBandpass = Bandpass()
controlBandpass.imsimBandpass()
ff = controlSed.calcFluxNorm(self.magNorm, uBandpass)
controlSed.multiplyFluxNorm(ff)
a_int, b_int = controlSed.setupCCMab()
controlSed.addCCMDust(a_int, b_int, A_v=0.1, R_v=3.1)
nSamples = 5
numpy.random.seed(42)
pointingRaList = numpy.random.random_sample(nSamples)*360.0
pointingDecList = numpy.random.random_sample(nSamples)*180.0 - 90.0
rotSkyPosList = numpy.random.random_sample(nSamples)*360.0
fwhmList = numpy.random.random_sample(nSamples)*1.0 + 0.3
actualCounts = None
for pointingRA, pointingDec, rotSkyPos, fwhm in \
zip(pointingRaList, pointingDecList, rotSkyPosList, fwhmList):
obs = ObservationMetaData(unrefractedRA=pointingRA,
unrefractedDec=pointingDec,
boundType='circle',
boundLength=4.0,
mjd=49250.0,
rotSkyPos=rotSkyPos)
xDisplacementList = numpy.random.random_sample(nSamples)*60.0-30.0
yDisplacementList = numpy.random.random_sample(nSamples)*60.0-30.0
create_text_catalog(obs, dbFileName, xDisplacementList, yDisplacementList,
mag_norm=[self.magNorm]*len(xDisplacementList))
db = placementFileDBObj(dbFileName, runtable='test')
cat = placementCatalog(db, obs_metadata=obs)
if actualCounts is None:
actualCounts = controlSed.calcADU(uBandpass, cat.photParams)
psf = SNRdocumentPSF(fwhm=fwhm)
cat.setPSF(psf)
cat.camera = camera
cat.write_catalog(catName)
cat.write_images(nameRoot=imageRoot)
objRaList = []
objDecList = []
with open(catName, 'r') as inFile:
for line in inFile:
if line[0] != '#':
words = line.split(';')
objRaList.append(numpy.radians(numpy.float(words[2])))
objDecList.append(numpy.radians(numpy.float(words[3])))
objRaList = numpy.array(objRaList)
objDecList = numpy.array(objDecList)
self.check_placement(imageName, objRaList, objDecList,
[fwhm]*len(objRaList),
numpy.array([actualCounts]*len(objRaList)),
cat.photParams.gain, detector, camera, obs, epoch=2000.0)
if os.path.exists(dbFileName):
os.unlink(dbFileName)
if os.path.exists(catName):
os.unlink(catName)
if os.path.exists(imageName):
os.unlink(imageName)
def test_object_extraction_galaxies(self):
"""
Test that method to get GalSimCelestialObjects from
InstanceCatalogs works
"""
galaxy_phosim_file = os.path.join(self.data_dir, 'phosim_galaxies.txt')
commands = desc.imsim.metadata_from_file(galaxy_phosim_file)
obs_md = desc.imsim.phosim_obs_metadata(commands)
phot_params = desc.imsim.photometricParameters(commands)
(gs_object_arr, gs_object_dict) = desc.imsim.sources_from_file(
galaxy_phosim_file, obs_md, phot_params)
id_arr = np.zeros(len(gs_object_arr), dtype=int)
for i_obj in range(len(gs_object_arr)):
id_arr[i_obj] = gs_object_arr[i_obj].uniqueId
truth_dtype = np.dtype([('uniqueId', int), ('x_pupil', float),
('y_pupil', float), ('sedFilename', str, 200),
('magNorm', float), ('raJ2000', float),
('decJ2000', float), ('redshift', float),
('gamma1', float), ('gamma2', float),
('kappa', float), ('galacticAv', float),
('galacticRv', float), ('internalAv', float),
('internalRv', float), ('minorAxis', float),
('majorAxis', float), ('positionAngle', float),
('sindex', float)])
truth_data = np.genfromtxt(os.path.join(self.data_dir,
'truth_galaxies.txt'),
dtype=truth_dtype,
delimiter=';')
np.testing.assert_array_equal(truth_data['uniqueId'], id_arr)
######## test that galaxy parameters are correctly read in
g1 = truth_data['gamma1'] / (1.0 - truth_data['kappa'])
g2 = truth_data['gamma2'] / (1.0 - truth_data['kappa'])
mu = 1.0 / ((1.0 - truth_data['kappa'])**2 -
(truth_data['gamma1']**2 + truth_data['gamma2']**2))
for i_obj, gs_obj in enumerate(gs_object_arr):
self.assertAlmostEqual(gs_obj.mu / mu[i_obj], 1.0, 6)
self.assertAlmostEqual(gs_obj.g1 / g1[i_obj], 1.0, 6)
self.assertAlmostEqual(gs_obj.g2 / g2[i_obj], 1.0, 6)
self.assertGreater(np.abs(gs_obj.mu), 0.0)
self.assertGreater(np.abs(gs_obj.g1), 0.0)
self.assertGreater(np.abs(gs_obj.g2), 0.0)
self.assertAlmostEqual(gs_obj.halfLightRadiusRadians,
truth_data['majorAxis'][i_obj], 13)
self.assertAlmostEqual(gs_obj.minorAxisRadians,
truth_data['minorAxis'][i_obj], 13)
self.assertAlmostEqual(gs_obj.majorAxisRadians,
truth_data['majorAxis'][i_obj], 13)
self.assertAlmostEqual(gs_obj.positionAngleRadians,
truth_data['positionAngle'][i_obj], 7)
self.assertAlmostEqual(gs_obj.sindex, truth_data['sindex'][i_obj],
10)
######## test that pupil coordinates are correct to within
######## half a milliarcsecond
x_pup_test, y_pup_test = _pupilCoordsFromRaDec(truth_data['raJ2000'],
truth_data['decJ2000'],
obs_metadata=obs_md)
for i_obj, gs_obj in enumerate(gs_object_arr):
self.assertEqual(truth_data['uniqueId'][i_obj], gs_obj.uniqueId)
dd = np.sqrt((x_pup_test[i_obj] - gs_obj.xPupilRadians)**2 +
(y_pup_test[i_obj] - gs_obj.yPupilRadians)**2)
dd = arcsecFromRadians(dd)
self.assertLess(dd, 0.0005)
######## test that fluxes are correctly calculated
bp_dict = BandpassDict.loadTotalBandpassesFromFiles()
imsim_bp = Bandpass()
imsim_bp.imsimBandpass()
phot_params = PhotometricParameters(nexp=1, exptime=30.0)
for i_obj, gs_obj in enumerate(gs_object_arr):
sed = Sed()
full_sed_name = os.path.join(os.environ['SIMS_SED_LIBRARY_DIR'],
truth_data['sedFilename'][i_obj])
sed.readSED_flambda(full_sed_name)
fnorm = sed.calcFluxNorm(truth_data['magNorm'][i_obj], imsim_bp)
sed.multiplyFluxNorm(fnorm)
a_x, b_x = sed.setupCCMab()
sed.addCCMDust(a_x,
b_x,
A_v=truth_data['internalAv'][i_obj],
R_v=truth_data['internalRv'][i_obj])
sed.redshiftSED(truth_data['redshift'][i_obj], dimming=True)
sed.resampleSED(wavelen_match=bp_dict.wavelenMatch)
a_x, b_x = sed.setupCCMab()
sed.addCCMDust(a_x,
b_x,
A_v=truth_data['galacticAv'][i_obj],
R_v=truth_data['galacticRv'][i_obj])
for bp in ('u', 'g', 'r', 'i', 'z', 'y'):
flux = sed.calcADU(bp_dict[bp], phot_params) * phot_params.gain
self.assertAlmostEqual(flux / gs_obj.flux(bp), 1.0, 6)
######## test that objects are assigned to the right chip in
######## gs_object_dict
unique_id_dict = {}
for chip_name in gs_object_dict:
local_unique_id_list = []
for gs_object in gs_object_dict[chip_name]:
local_unique_id_list.append(gs_object.uniqueId)
local_unique_id_list = set(local_unique_id_list)
unique_id_dict[chip_name] = local_unique_id_list
valid = 0
valid_chip_names = set()
for unq, xpup, ypup in zip(truth_data['uniqueId'],
truth_data['x_pupil'],
truth_data['y_pupil']):
chip_name = chipNameFromPupilCoordsLSST(xpup, ypup)[0]
if chip_name is not None:
self.assertIn(unq, unique_id_dict[chip_name])
valid_chip_names.add(chip_name)
valid += 1
self.assertGreater(valid, 10)
self.assertGreater(len(valid_chip_names), 5)
print "After scaling, magnitude of SED is now %.4f (desired magnitude was %.4f)" %(mag, mag_desired)
# And let's calculate what the expected photon counts for LSST would be.
counts = star.calcADU(rband, expTime=30)
print "This would correspond to roughly %f counts in the LSST focal plane, in a 30s exposure." %(counts)
# For fun, let's see what else can happen.
ebv = 0.5
print ""
print "Let's try adding %.2f E(B-V) dust extinction to this star." %(ebv)
a, b = star.setupCCMab()
# You can use addCCMDust on the 'star' object itself, but I'm illustrating here how you could also
# do otherwise - preserve the original 'star' object as is, and create a new Sed object that does
# include the effects of dust ('dustystar'). Star's data will be unchanged by the dust.
dustywavelen, dustyflambda = star.addCCMDust(a, b, ebv=ebv, wavelen=star.wavelen, flambda=star.flambda)
dustystar = Sed(wavelen=dustywavelen, flambda=dustyflambda)
magdust = dustystar.calcMag(rband)
print "With this dust, the magnitude of the star in this bandpass is now %.4f." %(magdust)
redshift = 0.2
print "What if this star was at a redshift of %f?" %(redshift)
# Here (unlike above with the dust), I'm applying the redshift to the 'star' object itself.
# Star's data will be changed by the redshifting.
star.redshiftSED(redshift, dimming=True)
magredshift = star.calcMag(rband)
print ""
print "Redshifted to %.2f, and adding cosmological dimming, the magnitude is now %.4f" \
%(redshift, magredshift)
print " (this was a pretty hot star, so redshifting brings more flux into this particular bandpass.)"
print ""
def testAddingToList(self):
"""
Test that we can add Seds to an already instantiated SedList
"""
imsimBand = Bandpass()
imsimBand.imsimBandpass()
nSed = 10
sedNameList_0 = self.getListOfSedNames(nSed)
magNormList_0 = self.rng.random_sample(nSed) * 5.0 + 15.0
internalAvList_0 = self.rng.random_sample(nSed) * 0.3 + 0.1
redshiftList_0 = self.rng.random_sample(nSed) * 5.0
galacticAvList_0 = self.rng.random_sample(nSed) * 0.3 + 0.1
wavelen_match = np.arange(300.0, 1500.0, 10.0)
testList = SedList(sedNameList_0,
magNormList_0,
internalAvList=internalAvList_0,
redshiftList=redshiftList_0,
galacticAvList=galacticAvList_0,
wavelenMatch=wavelen_match)
# experiment with adding different combinations of physical parameter lists
# as None and not None
for addIav in [True, False]:
for addRedshift in [True, False]:
for addGav in [True, False]:
testList = SedList(sedNameList_0,
magNormList_0,
internalAvList=internalAvList_0,
redshiftList=redshiftList_0,
galacticAvList=galacticAvList_0,
wavelenMatch=wavelen_match)
sedNameList_1 = self.getListOfSedNames(nSed)
magNormList_1 = self.rng.random_sample(nSed) * 5.0 + 15.0
if addIav:
internalAvList_1 = self.rng.random_sample(
nSed) * 0.3 + 0.1
else:
internalAvList_1 = None
if addRedshift:
redshiftList_1 = self.rng.random_sample(nSed) * 5.0
else:
redshiftList_1 = None
if addGav:
galacticAvList_1 = self.rng.random_sample(
nSed) * 0.3 + 0.1
else:
galacticAvList_1 = None
testList.loadSedsFromList(sedNameList_1,
magNormList_1,
internalAvList=internalAvList_1,
galacticAvList=galacticAvList_1,
redshiftList=redshiftList_1)
self.assertEqual(len(testList), 2 * nSed)
np.testing.assert_array_equal(wavelen_match,
testList.wavelenMatch)
for ix in range(len(sedNameList_0)):
self.assertAlmostEqual(internalAvList_0[ix],
testList.internalAvList[ix], 10)
self.assertAlmostEqual(galacticAvList_0[ix],
testList.galacticAvList[ix], 10)
self.assertAlmostEqual(redshiftList_0[ix],
testList.redshiftList[ix], 10)
for ix in range(len(sedNameList_1)):
if addIav:
self.assertAlmostEqual(
internalAvList_1[ix],
testList.internalAvList[ix + nSed], 10)
else:
self.assertIsNone(testList.internalAvList[ix +
nSed])
if addGav:
self.assertAlmostEqual(
galacticAvList_1[ix],
testList.galacticAvList[ix + nSed], 10)
else:
self.assertIsNone(testList.galacticAvList[ix +
nSed])
if addRedshift:
self.assertAlmostEqual(
redshiftList_1[ix],
testList.redshiftList[ix + nSed], 10)
else:
self.assertIsNone(testList.redshiftList[ix + nSed])
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_0, magNormList_0, internalAvList_0,
galacticAvList_0, redshiftList_0)):
sedControl = Sed()
sedControl.readSED_flambda(
os.path.join(self.sedDir, name + '.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=iav)
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix]
np.testing.assert_array_equal(sedControl.wavelen,
sedTest.wavelen)
np.testing.assert_array_equal(sedControl.flambda,
sedTest.flambda)
np.testing.assert_array_equal(sedControl.fnu,
sedTest.fnu)
if not addIav:
internalAvList_1 = [None] * nSed
if not addRedshift:
redshiftList_1 = [None] * nSed
if not addGav:
galacticAvList_1 = [None] * nSed
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_1, magNormList_1, internalAvList_1,
galacticAvList_1, redshiftList_1)):
sedControl = Sed()
sedControl.readSED_flambda(
os.path.join(self.sedDir, name + '.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
if addIav:
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=iav)
if addRedshift:
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
if addGav:
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix + nSed]
np.testing.assert_array_equal(sedControl.wavelen,
sedTest.wavelen)
np.testing.assert_array_equal(sedControl.flambda,
sedTest.flambda)
np.testing.assert_array_equal(sedControl.fnu,
sedTest.fnu)
def testObjectPlacement(self):
"""
Test that GalSim places objects on the correct pixel by drawing
images, reading them in, and then comparing the flux contained in
circles of 2 fwhm radii about the object's expected positions with
the actual expected flux of the objects.
"""
scratchDir = tempfile.mkdtemp(dir=ROOT, prefix='testObjectPlacement-')
catName = os.path.join(scratchDir, 'placementCatalog.dat')
imageRoot = os.path.join(scratchDir, 'placementImage')
dbFileName = os.path.join(scratchDir, 'placementInputCatalog.dat')
cameraDir = os.path.join(getPackageDir('sims_GalSimInterface'), 'tests', 'cameraData')
camera = ReturnCamera(cameraDir)
detector = camera[0]
imageName = '%s_%s_u.fits' % (imageRoot, detector.getName())
controlSed = Sed()
controlSed.readSED_flambda(os.path.join(getPackageDir('sims_sed_library'),
'flatSED', 'sed_flat.txt.gz'))
uBandpass = Bandpass()
uBandpass.readThroughput(os.path.join(getPackageDir('throughputs'),
'baseline', 'total_u.dat'))
controlBandpass = Bandpass()
controlBandpass.imsimBandpass()
ff = controlSed.calcFluxNorm(self.magNorm, uBandpass)
controlSed.multiplyFluxNorm(ff)
a_int, b_int = controlSed.setupCCMab()
controlSed.addCCMDust(a_int, b_int, A_v=0.1, R_v=3.1)
nSamples = 3
rng = np.random.RandomState(42)
pointingRaList = rng.random_sample(nSamples)*360.0
pointingDecList = rng.random_sample(nSamples)*180.0 - 90.0
rotSkyPosList = rng.random_sample(nSamples)*360.0
fwhmList = rng.random_sample(nSamples)*1.0 + 0.3
actualCounts = None
for pointingRA, pointingDec, rotSkyPos, fwhm in \
zip(pointingRaList, pointingDecList, rotSkyPosList, fwhmList):
obs = ObservationMetaData(pointingRA=pointingRA,
pointingDec=pointingDec,
boundType='circle',
boundLength=4.0,
mjd=49250.0,
rotSkyPos=rotSkyPos)
xDisplacementList = rng.random_sample(nSamples)*60.0-30.0
yDisplacementList = rng.random_sample(nSamples)*60.0-30.0
create_text_catalog(obs, dbFileName, xDisplacementList, yDisplacementList,
mag_norm=[self.magNorm]*len(xDisplacementList))
db = placementFileDBObj(dbFileName, runtable='test')
cat = placementCatalog(db, obs_metadata=obs)
cat.camera_wrapper = GalSimCameraWrapper(camera)
if actualCounts is None:
actualCounts = controlSed.calcADU(uBandpass, cat.photParams)
psf = SNRdocumentPSF(fwhm=fwhm)
cat.setPSF(psf)
cat.write_catalog(catName)
cat.write_images(nameRoot=imageRoot)
objRaList = []
objDecList = []
with open(catName, 'r') as inFile:
for line in inFile:
if line[0] != '#':
words = line.split(';')
objRaList.append(np.radians(np.float(words[2])))
objDecList.append(np.radians(np.float(words[3])))
objRaList = np.array(objRaList)
objDecList = np.array(objDecList)
self.assertGreater(len(objRaList), 0) # make sure we aren't testing
# an empty catalog/image
self.check_placement(imageName, objRaList, objDecList,
[fwhm]*len(objRaList),
np.array([actualCounts]*len(objRaList)),
cat.photParams.gain, detector, camera, obs, epoch=2000.0)
if os.path.exists(dbFileName):
os.unlink(dbFileName)
if os.path.exists(catName):
os.unlink(catName)
if os.path.exists(imageName):
os.unlink(imageName)
if os.path.exists(scratchDir):
shutil.rmtree(scratchDir)
def testAlternateNormalizingBandpass(self):
"""
A reiteration of testAddingToList, but testing with a non-imsimBandpass
normalizing bandpass
"""
normalizingBand = Bandpass()
normalizingBand.readThroughput(
os.path.join(getPackageDir('throughputs'), 'baseline',
'total_r.dat'))
nSed = 10
sedNameList_0 = self.getListOfSedNames(nSed)
magNormList_0 = self.rng.random_sample(nSed) * 5.0 + 15.0
internalAvList_0 = self.rng.random_sample(nSed) * 0.3 + 0.1
redshiftList_0 = self.rng.random_sample(nSed) * 5.0
galacticAvList_0 = self.rng.random_sample(nSed) * 0.3 + 0.1
wavelen_match = np.arange(300.0, 1500.0, 10.0)
testList = SedList(sedNameList_0,
magNormList_0,
normalizingBandpass=normalizingBand,
internalAvList=internalAvList_0,
redshiftList=redshiftList_0,
galacticAvList=galacticAvList_0,
wavelenMatch=wavelen_match)
sedNameList_1 = self.getListOfSedNames(nSed)
magNormList_1 = self.rng.random_sample(nSed) * 5.0 + 15.0
internalAvList_1 = self.rng.random_sample(nSed) * 0.3 + 0.1
redshiftList_1 = self.rng.random_sample(nSed) * 5.0
galacticAvList_1 = self.rng.random_sample(nSed) * 0.3 + 0.1
testList.loadSedsFromList(sedNameList_1,
magNormList_1,
internalAvList=internalAvList_1,
galacticAvList=galacticAvList_1,
redshiftList=redshiftList_1)
self.assertEqual(len(testList), 2 * nSed)
np.testing.assert_array_equal(wavelen_match, testList.wavelenMatch)
for ix in range(len(sedNameList_0)):
self.assertAlmostEqual(internalAvList_0[ix],
testList.internalAvList[ix], 10)
self.assertAlmostEqual(galacticAvList_0[ix],
testList.galacticAvList[ix], 10)
self.assertAlmostEqual(redshiftList_0[ix],
testList.redshiftList[ix], 10)
for ix in range(len(sedNameList_1)):
self.assertAlmostEqual(internalAvList_1[ix],
testList.internalAvList[ix + nSed], 10)
self.assertAlmostEqual(galacticAvList_1[ix],
testList.galacticAvList[ix + nSed], 10)
self.assertAlmostEqual(redshiftList_1[ix],
testList.redshiftList[ix + nSed], 10)
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_0, magNormList_0, internalAvList_0,
galacticAvList_0, redshiftList_0)):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name + '.gz'))
fnorm = sedControl.calcFluxNorm(norm, normalizingBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=iav)
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix]
np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_1, magNormList_1, internalAvList_1,
galacticAvList_1, redshiftList_1)):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name + '.gz'))
fnorm = sedControl.calcFluxNorm(norm, normalizingBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=iav)
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix + nSed]
np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
# same wavelength range we can just calculate a/b once, and this is slow)
a, b = stars[starskeys[0]].setupCCMab()
# pretend we want to read mags into an array .. you could just as easily put it into a
# dictionary or list, with small variations in the code
mags = n.empty(len(starskeys), dtype='float')
mags2 = n.empty(len(starskeys), dtype='float')
sedlist = []
for i in range(len(starskeys)):
# make a copy of the original SED *if* you want to 'reuse' the SED for multiple magnitude
# calculations with various fluxnorms and dust applications (otherwise just use the object
# you instantiated above)
tmpstar = Sed(wavelen=stars[starskeys[i]].wavelen,
flambda=stars[starskeys[i]].flambda)
tmpstar.addCCMDust(a, b, ebv=ebv[i])
tmpstar.multiplyFluxNorm(fluxnorm[i])
mags[i] = tmpstar.calcMag(rband)
# This is for showing an example of the manyMagCalc function on bandpass
sedlist.append(tmpstar)
# Now, pretend we're actually wanting to calculate the magnitude in multiple bandpasses.
# (ignore the part that uses exampleBandpass.dat as the source .. you would replace that with
# rootdir + "total_" + filter where filter is a member of lsstfilterlist
lsstfilterlist = ['u', 'g', 'r', 'i', 'z', 'y']
lsst = {}
rootdir = "./"
for filter in lsstfilterlist:
lsst[filter] = Bandpass()
lsst[filter].readThroughput(rootdir + "exampleBandpass.dat")
# you have to do this now - sbToPhi to use the multi-mag calc
def testSetUp(self):
"""
Test the SedList can be successfully initialized
"""
############## Try just reading in an normalizing some SEDs
nSed = 10
sedNameList = self.getListOfSedNames(nSed)
magNormList = self.rng.random_sample(nSed) * 5.0 + 15.0
testList = SedList(sedNameList, magNormList)
self.assertEqual(len(testList), nSed)
self.assertIsNone(testList.internalAvList)
self.assertIsNone(testList.galacticAvList)
self.assertIsNone(testList.redshiftList)
self.assertIsNone(testList.wavelenMatch)
self.assertTrue(testList.cosmologicalDimming)
imsimBand = Bandpass()
imsimBand.imsimBandpass()
for name, norm, sedTest in zip(sedNameList, magNormList, testList):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name + '.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
################# now add an internalAv
sedNameList = self.getListOfSedNames(nSed)
magNormList = self.rng.random_sample(nSed) * 5.0 + 15.0
internalAvList = self.rng.random_sample(nSed) * 0.3 + 0.1
testList = SedList(sedNameList,
magNormList,
internalAvList=internalAvList)
self.assertIsNone(testList.galacticAvList)
self.assertIsNone(testList.redshiftList)
self.assertIsNone(testList.wavelenMatch)
self.assertTrue(testList.cosmologicalDimming)
for avControl, avTest in zip(internalAvList, testList.internalAvList):
self.assertAlmostEqual(avControl, avTest, 10)
for name, norm, av, sedTest in zip(sedNameList, magNormList,
internalAvList, testList):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name + '.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=av)
np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
################ now add redshift
sedNameList = self.getListOfSedNames(nSed)
magNormList = self.rng.random_sample(nSed) * 5.0 + 15.0
internalAvList = self.rng.random_sample(nSed) * 0.3 + 0.1
redshiftList = self.rng.random_sample(nSed) * 5.0
testList = SedList(sedNameList,
magNormList,
internalAvList=internalAvList,
redshiftList=redshiftList)
self.assertIsNone(testList.galacticAvList)
self.assertIsNone(testList.wavelenMatch)
self.assertTrue(testList.cosmologicalDimming)
for avControl, avTest in zip(internalAvList, testList.internalAvList):
self.assertAlmostEqual(avControl, avTest, 10)
for zControl, zTest in zip(redshiftList, testList.redshiftList):
self.assertAlmostEqual(zControl, zTest, 10)
for name, norm, av, zz, sedTest in \
zip(sedNameList, magNormList, internalAvList, redshiftList, testList):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name + '.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=av)
sedControl.redshiftSED(zz, dimming=True)
np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
################# without cosmological dimming
sedNameList = self.getListOfSedNames(nSed)
magNormList = self.rng.random_sample(nSed) * 5.0 + 15.0
internalAvList = self.rng.random_sample(nSed) * 0.3 + 0.1
redshiftList = self.rng.random_sample(nSed) * 5.0
testList = SedList(sedNameList,
magNormList,
internalAvList=internalAvList,
redshiftList=redshiftList,
cosmologicalDimming=False)
self.assertIsNone(testList.galacticAvList)
self.assertIsNone(testList.wavelenMatch)
self.assertFalse(testList.cosmologicalDimming)
for avControl, avTest in zip(internalAvList, testList.internalAvList):
self.assertAlmostEqual(avControl, avTest, 10)
for zControl, zTest in zip(redshiftList, testList.redshiftList):
self.assertAlmostEqual(zControl, zTest, 10)
for name, norm, av, zz, sedTest in \
zip(sedNameList, magNormList, internalAvList, redshiftList, testList):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name + '.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=av)
sedControl.redshiftSED(zz, dimming=False)
np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
################ now add galacticAv
sedNameList = self.getListOfSedNames(nSed)
magNormList = self.rng.random_sample(nSed) * 5.0 + 15.0
internalAvList = self.rng.random_sample(nSed) * 0.3 + 0.1
redshiftList = self.rng.random_sample(nSed) * 5.0
galacticAvList = self.rng.random_sample(nSed) * 0.3 + 0.1
testList = SedList(sedNameList,
magNormList,
internalAvList=internalAvList,
redshiftList=redshiftList,
galacticAvList=galacticAvList)
self.assertIsNone(testList.wavelenMatch)
self.assertTrue(testList.cosmologicalDimming)
for avControl, avTest in zip(internalAvList, testList.internalAvList):
self.assertAlmostEqual(avControl, avTest, 10)
for zControl, zTest in zip(redshiftList, testList.redshiftList):
self.assertAlmostEqual(zControl, zTest, 10)
for avControl, avTest in zip(galacticAvList, testList.galacticAvList):
self.assertAlmostEqual(avControl, avTest, 10)
for name, norm, av, zz, gav, sedTest in \
zip(sedNameList, magNormList, internalAvList,
redshiftList, galacticAvList, testList):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name + '.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=av)
sedControl.redshiftSED(zz, dimming=True)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=gav)
np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
################ now use a wavelen_match
sedNameList = self.getListOfSedNames(nSed)
magNormList = self.rng.random_sample(nSed) * 5.0 + 15.0
internalAvList = self.rng.random_sample(nSed) * 0.3 + 0.1
redshiftList = self.rng.random_sample(nSed) * 5.0
galacticAvList = self.rng.random_sample(nSed) * 0.3 + 0.1
wavelen_match = np.arange(300.0, 1500.0, 10.0)
testList = SedList(sedNameList,
magNormList,
internalAvList=internalAvList,
redshiftList=redshiftList,
galacticAvList=galacticAvList,
wavelenMatch=wavelen_match)
self.assertTrue(testList.cosmologicalDimming)
for avControl, avTest in zip(internalAvList, testList.internalAvList):
self.assertAlmostEqual(avControl, avTest, 10)
for zControl, zTest in zip(redshiftList, testList.redshiftList):
self.assertAlmostEqual(zControl, zTest, 10)
for avControl, avTest in zip(galacticAvList, testList.galacticAvList):
self.assertAlmostEqual(avControl, avTest, 10)
np.testing.assert_array_equal(wavelen_match, testList.wavelenMatch)
for name, norm, av, zz, gav, sedTest in \
zip(sedNameList, magNormList, internalAvList,
redshiftList, galacticAvList, testList):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name + '.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=av)
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=gav)
np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
def testGalaxyPhotometricUncertainties(self):
"""
Test in the case of a catalog of galaxies
"""
lsstDefaults = LSSTdefaults()
phot = PhotometryGalaxies()
galDB = testGalaxyTileDBObj(driver=self.driver, host=self.host, database=self.dbName)
galCat = testGalaxyCatalog(galDB, obs_metadata=self.obs_metadata)
imsimband = Bandpass()
imsimband.imsimBandpass()
ct = 0
for line in galCat.iter_catalog():
bulgeSedName = line[50]
diskSedName = line[51]
agnSedName = line[52]
magNormBulge = line[53]
magNormDisk = line[54]
magNormAgn = line[55]
avBulge = line[56]
avDisk = line[57]
redshift = line[58]
bulgeSed = Sed()
bulgeSed.readSED_flambda(os.path.join(lsst.utils.getPackageDir('sims_sed_library'),
defaultSpecMap[bulgeSedName]))
fNorm=bulgeSed.calcFluxNorm(magNormBulge, imsimband)
bulgeSed.multiplyFluxNorm(fNorm)
diskSed = Sed()
diskSed.readSED_flambda(os.path.join(lsst.utils.getPackageDir('sims_sed_library'),
defaultSpecMap[diskSedName]))
fNorm = diskSed.calcFluxNorm(magNormDisk, imsimband)
diskSed.multiplyFluxNorm(fNorm)
agnSed = Sed()
agnSed.readSED_flambda(os.path.join(lsst.utils.getPackageDir('sims_sed_library'),
defaultSpecMap[agnSedName]))
fNorm = agnSed.calcFluxNorm(magNormAgn, imsimband)
agnSed.multiplyFluxNorm(fNorm)
a_int, b_int = bulgeSed.setupCCMab()
bulgeSed.addCCMDust(a_int, b_int, A_v=avBulge)
a_int, b_int = diskSed.setupCCMab()
diskSed.addCCMDust(a_int, b_int, A_v=avDisk)
bulgeSed.redshiftSED(redshift, dimming=True)
diskSed.redshiftSED(redshift, dimming=True)
agnSed.redshiftSED(redshift, dimming=True)
bulgeSed.resampleSED(wavelen_match=self.totalBandpasses[0].wavelen)
diskSed.resampleSED(wavelen_match=bulgeSed.wavelen)
agnSed.resampleSED(wavelen_match=bulgeSed.wavelen)
numpy.testing.assert_almost_equal(bulgeSed.wavelen, diskSed.wavelen)
numpy.testing.assert_almost_equal(bulgeSed.wavelen, agnSed.wavelen)
fl = bulgeSed.flambda + diskSed.flambda + agnSed.flambda
totalSed = Sed(wavelen=bulgeSed.wavelen, flambda=fl)
sedList = [totalSed, bulgeSed, diskSed, agnSed]
for i, spectrum in enumerate(sedList):
if i==0:
msgroot = 'failed on total'
elif i==1:
msgroot = 'failed on bulge'
elif i==2:
msgroot = 'failed on disk'
elif i==3:
msgroot = 'failed on agn'
for j, b in enumerate(self.bandpasses):
controlSigma = calcMagError_sed(spectrum, self.totalBandpasses[j],
self.skySeds[j],
self.hardwareBandpasses[j],
FWHMeff=lsstDefaults.FWHMeff(b),
photParams=PhotometricParameters())
testSigma = line[26+(i*6)+j]
msg = '%e neq %e; ' % (testSigma, controlSigma) + msgroot
self.assertAlmostEqual(testSigma, controlSigma, 10, msg=msg)
ct += 1
self.assertGreater(ct, 0)
def get_TotalMags(result, bandpasses=('u','g','r','i','z','y')):
datadir = os.environ.get("SIMS_SED_LIBRARY_DIR")
tpath = os.getenv('LSST_THROUGHPUTS_DEFAULT')
bands = {"u":None, "g":None, "r":None, "i":None, "z":None, "y":None}
for k in bands:
bands[k] = Bandpass()
bands[k].readThroughput(os.path.join(tpath, "total_%s.dat"%k))
# Set up phi, the wavelength-normalized system response for each filter,
# for each bandpass for manyMagCalc method.
bplist = []
for f in ['u','g','r','i','z','y']:
bands[f].sbTophi()
bplist.append(bands[f])
ids = result['galid']
diskfile = result['sedFilenameDisk']
bulgefile = result['sedFilenameBulge']
agnfile = result['sedFilenameAgn']
diskmn = result['magNormDisk']
bulgemn = result['magNormBulge']
agnmn = result['magNormAgn']
bulgeAv = result['internalAvBulge']
diskAv = result['internalAvDisk']
redshift = result['redshift']
imsimband = Bandpass()
imsimband.imsimBandpass()
sedDict = {}
retMags = dict([(k, []) for k in bands])
a_int = None
b_int = None
tmpwavelen = None
for id, df, dm, dav, bf, bm, bav, af, am, z in zip(ids, diskfile, diskmn, diskAv,
bulgefile, bulgemn, bulgeAv, agnfile, agnmn, redshift):
tmpflux = None
for comp in ((df, dm, dav, 'galaxySED', False), (bf, bm, bav, 'galaxySED', False), (af, am, None, 'agnSED', True)):
#Zero out the AGN contribution
#for comp in ((df, dm, dav, 'galaxySED', False), (bf, bm, bav, 'galaxySED', False), (af, 99.99, None, 'agnSED', True)):
if not comp[0] == u'None':
if sedDict.has_key(comp[0]):
sed = copy.deepcopy(sedDict[comp[0]])
else:
sed = Sed()
print os.path.join(datadir,comp[3],comp[0])
sed.readSED_flambda(os.path.join(datadir,comp[3],comp[0]))
if comp[4]:
sed.resampleSED(wavelen_match=tmpwavelen)
sedDict[comp[0]] = sed
if a_int is None:
phiarray, dlambda = sed.setupPhiArray(bplist)
a_int, b_int = sed.setupCCMab()
#Careful, this assumes that a disk or bulge sed is read
#before any agn sed
tmpwavelen = sed.wavelen
fNorm = sed.calcFluxNorm(comp[1], imsimband)
sed.multiplyFluxNorm(fNorm)
#I guess this assumes rv=3.1??
if comp[2]:
sed.addCCMDust(a_int, b_int, A_v=comp[2])
wavelenArr=sed.wavelen
if tmpflux is None:
tmpflux = sed.flambda
else:
tmpflux += sed.flambda
newgal = Sed(wavelen=wavelenArr, flambda=tmpflux)
#a_mw, b_mw = sed.setupCCMab()
#sed.addCCMDust(a_mw, b_mw, A_v=mwav)
newgal.redshiftSED(z, dimming=True)
newgal.resampleSED(wavelen_match=bplist[0].wavelen)
newgal.flambdaTofnu()
mags = newgal.manyMagCalc(phiarray, dlambda)
for i,k in enumerate(['u','g','r','i','z','y']):
retMags[k].append(mags[i])
return retMags
def testSetUp(self):
"""
Test the SedList can be successfully initialized
"""
############## Try just reading in an normalizing some SEDs
nSed = 10
sedNameList = self.getListOfSedNames(nSed)
magNormList = numpy.random.random_sample(nSed)*5.0 + 15.0
testList = SedList(sedNameList, magNormList)
self.assertEqual(len(testList), nSed)
self.assertTrue(testList.internalAvList is None)
self.assertTrue(testList.galacticAvList is None)
self.assertTrue(testList.redshiftList is None)
self.assertTrue(testList.wavelenMatch is None)
self.assertTrue(testList.cosmologicalDimming is True)
imsimBand = Bandpass()
imsimBand.imsimBandpass()
for name, norm, sedTest in zip(sedNameList, magNormList, testList):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
numpy.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
numpy.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
numpy.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
################# now add an internalAv
sedNameList = self.getListOfSedNames(nSed)
magNormList = numpy.random.random_sample(nSed)*5.0 + 15.0
internalAvList = numpy.random.random_sample(nSed)*0.3 + 0.1
testList = SedList(sedNameList, magNormList, internalAvList=internalAvList)
self.assertTrue(testList.galacticAvList is None)
self.assertTrue(testList.redshiftList is None)
self.assertTrue(testList.wavelenMatch is None)
self.assertTrue(testList.cosmologicalDimming is True)
for avControl, avTest in zip(internalAvList, testList.internalAvList):
self.assertAlmostEqual(avControl, avTest, 10)
for name, norm, av, sedTest in zip(sedNameList, magNormList, internalAvList, testList):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=av)
numpy.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
numpy.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
numpy.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
################ now add redshift
sedNameList = self.getListOfSedNames(nSed)
magNormList = numpy.random.random_sample(nSed)*5.0 + 15.0
internalAvList = numpy.random.random_sample(nSed)*0.3 + 0.1
redshiftList = numpy.random.random_sample(nSed)*5.0
testList = SedList(sedNameList, magNormList, internalAvList=internalAvList,
redshiftList=redshiftList)
self.assertTrue(testList.galacticAvList is None)
self.assertTrue(testList.wavelenMatch is None)
self.assertTrue(testList.cosmologicalDimming is True)
for avControl, avTest in zip(internalAvList, testList.internalAvList):
self.assertAlmostEqual(avControl, avTest, 10)
for zControl, zTest in zip(redshiftList, testList.redshiftList):
self.assertAlmostEqual(zControl, zTest, 10)
for name, norm, av, zz, sedTest in \
zip(sedNameList, magNormList, internalAvList, redshiftList, testList):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=av)
sedControl.redshiftSED(zz, dimming=True)
numpy.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
numpy.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
numpy.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
################# without cosmological dimming
sedNameList = self.getListOfSedNames(nSed)
magNormList = numpy.random.random_sample(nSed)*5.0 + 15.0
internalAvList = numpy.random.random_sample(nSed)*0.3 + 0.1
redshiftList = numpy.random.random_sample(nSed)*5.0
testList = SedList(sedNameList, magNormList, internalAvList=internalAvList,
redshiftList=redshiftList, cosmologicalDimming=False)
self.assertTrue(testList.galacticAvList is None)
self.assertTrue(testList.wavelenMatch is None)
self.assertTrue(testList.cosmologicalDimming is False)
for avControl, avTest in zip(internalAvList, testList.internalAvList):
self.assertAlmostEqual(avControl, avTest, 10)
for zControl, zTest in zip(redshiftList, testList.redshiftList):
self.assertAlmostEqual(zControl, zTest, 10)
for name, norm, av, zz, sedTest in \
zip(sedNameList, magNormList, internalAvList, redshiftList, testList):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=av)
sedControl.redshiftSED(zz, dimming=False)
numpy.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
numpy.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
numpy.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
################ now add galacticAv
sedNameList = self.getListOfSedNames(nSed)
magNormList = numpy.random.random_sample(nSed)*5.0 + 15.0
internalAvList = numpy.random.random_sample(nSed)*0.3 + 0.1
redshiftList = numpy.random.random_sample(nSed)*5.0
galacticAvList = numpy.random.random_sample(nSed)*0.3 + 0.1
testList = SedList(sedNameList, magNormList, internalAvList=internalAvList,
redshiftList=redshiftList, galacticAvList=galacticAvList)
self.assertTrue(testList.wavelenMatch is None)
self.assertTrue(testList.cosmologicalDimming is True)
for avControl, avTest in zip(internalAvList, testList.internalAvList):
self.assertAlmostEqual(avControl, avTest, 10)
for zControl, zTest in zip(redshiftList, testList.redshiftList):
self.assertAlmostEqual(zControl, zTest, 10)
for avControl, avTest in zip(galacticAvList, testList.galacticAvList):
self.assertAlmostEqual(avControl, avTest, 10)
for name, norm, av, zz, gav, sedTest in \
zip(sedNameList, magNormList, internalAvList, \
redshiftList, galacticAvList, testList):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=av)
sedControl.redshiftSED(zz, dimming=True)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=gav)
numpy.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
numpy.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
numpy.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
################ now use a wavelen_match
sedNameList = self.getListOfSedNames(nSed)
magNormList = numpy.random.random_sample(nSed)*5.0 + 15.0
internalAvList = numpy.random.random_sample(nSed)*0.3 + 0.1
redshiftList = numpy.random.random_sample(nSed)*5.0
galacticAvList = numpy.random.random_sample(nSed)*0.3 + 0.1
wavelen_match = numpy.arange(300.0, 1500.0, 10.0)
testList = SedList(sedNameList, magNormList, internalAvList=internalAvList,
redshiftList=redshiftList, galacticAvList=galacticAvList,
wavelenMatch=wavelen_match)
self.assertTrue(testList.cosmologicalDimming is True)
for avControl, avTest in zip(internalAvList, testList.internalAvList):
self.assertAlmostEqual(avControl, avTest, 10)
for zControl, zTest in zip(redshiftList, testList.redshiftList):
self.assertAlmostEqual(zControl, zTest, 10)
for avControl, avTest in zip(galacticAvList, testList.galacticAvList):
self.assertAlmostEqual(avControl, avTest, 10)
numpy.testing.assert_array_equal(wavelen_match, testList.wavelenMatch)
for name, norm, av, zz, gav, sedTest in \
zip(sedNameList, magNormList, internalAvList, \
redshiftList, galacticAvList, testList):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=av)
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=gav)
numpy.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
numpy.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
numpy.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
# create the a,b arrays for all the gals (because we resampled the gals onto the
# same wavelength range we can just calculate a/b once, and this is slow)
a_gal, b_gal = gals[galaxykeys[0]].setupCCMab()
# pretend we want to read mags into an array .. you could just as easily put it into a
# dictionary or list, with small variations in the code
mags = n.empty(len(galaxykeys), dtype='float')
for i in range(len(galaxykeys)):
# make a copy of the original SED if you want to 'reuse' the SED for multiple magnitude
# calculations with various fluxnorms, redshifts and dusts
tmpgal = Sed(wavelen=gals[galaxykeys[i]].wavelen, flambda=gals[galaxykeys[i]].flambda)
# add the dust internal to the distant galaxy
tmpgal.addCCMDust(a_gal, b_gal, ebv=ebv_gal[i])
# redshift the galaxy
tmpgal.redshiftSED(redshifts[i], dimming=False)
# add the dust from our milky way - have to recalculate a/b because now wavelenghts
# for each galaxy are *different*
a_mw, b_mw = tmpgal.setupCCMab()
tmpgal.addCCMDust(a_mw, b_mw, ebv=ebv_mw[i])
tmpgal.multiplyFluxNorm(fluxnorm[i])
mags[i] = tmpgal.calcMag(rband)
# show results
print "#sedname fluxnorm redshift ebv_gal ebv_mw magnitude "
for i in range(len(galaxykeys)):
print "%s %.5g %.3f %.5f %.5f %.5f" %(galaxykeys[i], fluxnorm[i], redshifts[i], ebv_gal[i], ebv_mw[i], mags[i])
def sources_from_file(file_name, obs_md, phot_params, numRows=None):
"""
Read in an InstanceCatalog and extract all of the astrophysical
sources from it
Parameters
----------
file_name: str
The name of the InstanceCatalog
obs_md: ObservationMetaData
The ObservationMetaData characterizing the pointing
phot_params: PhotometricParameters
The PhotometricParameters characterizing this telescope
numRows: int (optional)
The number of rows of the InstanceCatalog to read in (including the
header)
Returns
-------
gs_obj_arr: numpy array
Contains the GalSimCelestialObjects for all of the
astrophysical sources in this InstanceCatalog
out_obj_dict: dict
Keyed on the names of the detectors in the LSST camera.
The values are numpy arrays of GalSimCelestialObjects
that should be simulated for that detector, including
objects that are near the edge of the chip or
just bright (in which case, they might still illuminate
the detector).
"""
camera = get_obs_lsstSim_camera()
num_objects = 0
ct_rows = 0
with fopen(file_name, mode='rt') as input_file:
for line in input_file:
ct_rows += 1
params = line.strip().split()
if params[0] == 'object':
num_objects += 1
if numRows is not None and ct_rows >= numRows:
break
# RA, Dec in the coordinate system expected by PhoSim
ra_phosim = np.zeros(num_objects, dtype=float)
dec_phosim = np.zeros(num_objects, dtype=float)
sed_name = [None] * num_objects
mag_norm = 55.0 * np.ones(num_objects, dtype=float)
gamma1 = np.zeros(num_objects, dtype=float)
gamma2 = np.zeros(num_objects, dtype=float)
kappa = np.zeros(num_objects, dtype=float)
internal_av = np.zeros(num_objects, dtype=float)
internal_rv = np.zeros(num_objects, dtype=float)
galactic_av = np.zeros(num_objects, dtype=float)
galactic_rv = np.zeros(num_objects, dtype=float)
semi_major_arcsec = np.zeros(num_objects, dtype=float)
semi_minor_arcsec = np.zeros(num_objects, dtype=float)
position_angle_degrees = np.zeros(num_objects, dtype=float)
sersic_index = np.zeros(num_objects, dtype=float)
npoints = np.zeros(num_objects, dtype=int)
redshift = np.zeros(num_objects, dtype=float)
unique_id = np.zeros(num_objects, dtype=int)
object_type = np.zeros(num_objects, dtype=int)
i_obj = -1
with fopen(file_name, mode='rt') as input_file:
for line in input_file:
params = line.strip().split()
if params[0] != 'object':
continue
i_obj += 1
if numRows is not None and i_obj >= num_objects:
break
unique_id[i_obj] = int(params[1])
ra_phosim[i_obj] = float(params[2])
dec_phosim[i_obj] = float(params[3])
mag_norm[i_obj] = float(params[4])
sed_name[i_obj] = params[5]
redshift[i_obj] = float(params[6])
gamma1[i_obj] = float(params[7])
gamma2[i_obj] = float(params[8])
kappa[i_obj] = float(params[9])
if params[12].lower() == 'point':
object_type[i_obj] = _POINT_SOURCE
i_gal_dust_model = 14
if params[13].lower() != 'none':
i_gal_dust_model = 16
internal_av[i_obj] = float(params[14])
internal_rv[i_obj] = float(params[15])
if params[i_gal_dust_model].lower() != 'none':
galactic_av[i_obj] = float(params[i_gal_dust_model + 1])
galactic_rv[i_obj] = float(params[i_gal_dust_model + 2])
elif params[12].lower() == 'sersic2d':
object_type[i_obj] = _SERSIC_2D
semi_major_arcsec[i_obj] = float(params[13])
semi_minor_arcsec[i_obj] = float(params[14])
position_angle_degrees[i_obj] = float(params[15])
sersic_index[i_obj] = float(params[16])
i_gal_dust_model = 18
if params[17].lower() != 'none':
i_gal_dust_model = 20
internal_av[i_obj] = float(params[18])
internal_rv[i_obj] = float(params[19])
if params[i_gal_dust_model].lower() != 'none':
galactic_av[i_obj] = float(params[i_gal_dust_model + 1])
galactic_rv[i_obj] = float(params[i_gal_dust_model + 2])
elif params[12].lower() == 'knots':
object_type[i_obj] = _RANDOM_WALK
semi_major_arcsec[i_obj] = float(params[13])
semi_minor_arcsec[i_obj] = float(params[14])
position_angle_degrees[i_obj] = float(params[15])
npoints[i_obj] = int(params[16])
i_gal_dust_model = 18
if params[17].lower() != 'none':
i_gal_dust_model = 20
internal_av[i_obj] = float(params[18])
internal_rv[i_obj] = float(params[19])
if params[i_gal_dust_model].lower() != 'none':
galactic_av[i_obj] = float(params[i_gal_dust_model + 1])
galactic_rv[i_obj] = float(params[i_gal_dust_model + 2])
else:
raise RuntimeError("Do not know how to handle "
"object type: %s" % params[12])
ra_appGeo, dec_appGeo = PhoSimAstrometryBase._appGeoFromPhoSim(
np.radians(ra_phosim), np.radians(dec_phosim), obs_md)
(ra_obs_rad, dec_obs_rad) = _observedFromAppGeo(ra_appGeo,
dec_appGeo,
obs_metadata=obs_md,
includeRefraction=True)
semi_major_radians = radiansFromArcsec(semi_major_arcsec)
semi_minor_radians = radiansFromArcsec(semi_minor_arcsec)
position_angle_radians = np.radians(position_angle_degrees)
x_pupil, y_pupil = _pupilCoordsFromObserved(ra_obs_rad, dec_obs_rad,
obs_md)
bp_dict = BandpassDict.loadTotalBandpassesFromFiles()
sed_dir = lsstUtils.getPackageDir('sims_sed_library')
object_is_valid = np.array([True] * num_objects)
invalid_objects = np.where(
np.logical_or(
np.logical_or(
mag_norm > 50.0,
np.logical_and(galactic_av == 0.0, galactic_rv == 0.0)),
np.logical_or(
np.logical_and(object_type == _SERSIC_2D,
semi_major_arcsec < semi_minor_arcsec),
np.logical_and(object_type == _RANDOM_WALK, npoints <= 0))))
object_is_valid[invalid_objects] = False
if len(invalid_objects[0]) > 0:
message = "\nOmitted %d suspicious objects from " % len(
invalid_objects[0])
message += "the instance catalog:\n"
n_bad_mag_norm = len(np.where(mag_norm > 50.0)[0])
message += " %d had mag_norm > 50.0\n" % n_bad_mag_norm
n_bad_av = len(
np.where(np.logical_and(galactic_av == 0.0,
galactic_rv == 0.0))[0])
message += " %d had galactic_Av == galactic_Rv == 0\n" % n_bad_av
n_bad_axes = len(
np.where(
np.logical_and(object_type == _SERSIC_2D,
semi_major_arcsec < semi_minor_arcsec))[0])
message += " %d had semi_major_axis < semi_minor_axis\n" % n_bad_axes
n_bad_knots = len(
np.where(np.logical_and(object_type == _RANDOM_WALK,
npoints <= 0))[0])
message += " %d had n_points <= 0 \n" % n_bad_knots
warnings.warn(message)
wav_int = None
wav_gal = None
gs_object_arr = []
for i_obj in range(num_objects):
if not object_is_valid[i_obj]:
continue
if object_type[i_obj] == _POINT_SOURCE:
gs_type = 'pointSource'
elif object_type[i_obj] == _SERSIC_2D:
gs_type = 'sersic'
elif object_type[i_obj] == _RANDOM_WALK:
gs_type = 'RandomWalk'
# load the SED
sed_obj = Sed()
sed_obj.readSED_flambda(os.path.join(sed_dir, sed_name[i_obj]))
fnorm = getImsimFluxNorm(sed_obj, mag_norm[i_obj])
sed_obj.multiplyFluxNorm(fnorm)
if internal_av[i_obj] != 0.0:
if wav_int is None or not np.array_equal(sed_obj.wavelen, wav_int):
a_int, b_int = sed_obj.setupCCMab()
wav_int = copy.deepcopy(sed_obj.wavelen)
sed_obj.addCCMDust(a_int,
b_int,
A_v=internal_av[i_obj],
R_v=internal_rv[i_obj])
if redshift[i_obj] != 0.0:
sed_obj.redshiftSED(redshift[i_obj], dimming=True)
sed_obj.resampleSED(wavelen_match=bp_dict.wavelenMatch)
if galactic_av[i_obj] != 0.0:
if wav_gal is None or not np.array_equal(sed_obj.wavelen, wav_gal):
a_g, b_g = sed_obj.setupCCMab()
wav_gal = copy.deepcopy(sed_obj.wavelen)
sed_obj.addCCMDust(a_g,
b_g,
A_v=galactic_av[i_obj],
R_v=galactic_rv[i_obj])
gs_object = GalSimCelestialObject(gs_type,
x_pupil[i_obj],
y_pupil[i_obj],
semi_major_radians[i_obj],
semi_minor_radians[i_obj],
semi_major_radians[i_obj],
position_angle_radians[i_obj],
sersic_index[i_obj],
sed_obj,
bp_dict,
phot_params,
npoints[i_obj],
gamma1=gamma1[i_obj],
gamma2=gamma2[i_obj],
kappa=kappa[i_obj],
uniqueId=unique_id[i_obj])
gs_object_arr.append(gs_object)
gs_object_arr = np.array(gs_object_arr)
# how close to the edge of the detector a source has
# to be before we will just simulate it anyway
pix_tol = 50.0
# any source brighter than this will be considered
# so bright that it should be simulated for all
# detectors, just in case light scatters onto them.
max_mag = 16.0
# down-select mag_norm, x_pupil, and y_pupil
# to only contain those objects that were
# deemed to be valid above
valid = np.where(object_is_valid)
mag_norm = mag_norm[valid]
x_pupil = x_pupil[valid]
y_pupil = y_pupil[valid]
assert len(mag_norm) == len(gs_object_arr)
assert len(x_pupil) == len(gs_object_arr)
assert len(y_pupil) == len(gs_object_arr)
out_obj_dict = {}
for det in lsst_camera():
chip_name = det.getName()
pixel_corners = getCornerPixels(chip_name, lsst_camera())
x_min = pixel_corners[0][0]
x_max = pixel_corners[2][0]
y_min = pixel_corners[0][1]
y_max = pixel_corners[3][1]
xpix, ypix = pixelCoordsFromPupilCoords(x_pupil,
y_pupil,
chipName=chip_name,
camera=lsst_camera())
on_chip = np.where(
np.logical_or(
mag_norm < max_mag,
np.logical_and(
xpix > x_min - pix_tol,
np.logical_and(
xpix < x_max + pix_tol,
np.logical_and(ypix > y_min - pix_tol,
ypix < y_max + pix_tol)))))
out_obj_dict[chip_name] = gs_object_arr[on_chip]
return gs_object_arr, out_obj_dict
def applyMLTflaring(self, valid_dexes, params, expmjd,
parallax=None, ebv=None, quiescent_mags=None):
"""
parallax, ebv, and quiescent_mags are optional kwargs for use if you are
calling this method outside the context of an InstanceCatalog (presumably
with a numpy array of expmjd)
parallax is the parallax of your objects in radians
ebv is the E(B-V) value for your objects
quiescent_mags is a dict keyed on ('u', 'g', 'r', 'i', 'z', 'y')
with the quiescent magnitudes of the objects
"""
if parallax is None:
parallax = self.column_by_name('parallax')
if ebv is None:
ebv = self.column_by_name('ebv')
global _MLT_LC_NPZ
global _MLT_LC_NPZ_NAME
global _MLT_LC_TIME_CACHE
global _MLT_LC_FLUX_CACHE
# this needs to occur before loading the MLT light curve cache,
# just in case the user wants to override the light curve cache
# file by hand before generating the catalog
if len(params) == 0:
return numpy.array([[],[],[],[],[],[]])
if quiescent_mags is None:
quiescent_mags = {}
for mag_name in ('u', 'g', 'r', 'i', 'z', 'y'):
if ('lsst_%s' % mag_name in self._actually_calculated_columns or
'delta_lsst_%s' % mag_name in self._actually_calculated_columns):
quiescent_mags[mag_name] = self.column_by_name('quiescent_lsst_%s' % mag_name)
if not hasattr(self, 'photParams'):
raise RuntimeError("To apply MLT dwarf flaring, your "
"InstanceCatalog must have a member variable "
"photParams which is an instantiation of the "
"class PhotometricParameters, which can be "
"imported from lsst.sims.photUtils. "
"This is so that your InstanceCatalog has "
"knowledge of the effective area of the LSST "
"mirror.")
if _MLT_LC_NPZ is None or _MLT_LC_NPZ_NAME != self._mlt_lc_file or _MLT_LC_NPZ.fid is None:
if not os.path.exists(self._mlt_lc_file):
catutils_scripts = os.path.join(getPackageDir('sims_catUtils'), 'support_scripts')
raise RuntimeError("The MLT flaring light curve file:\n"
+ "\n%s\n" % self._mlt_lc_file
+ "\ndoes not exist."
+"\n\n"
+ "Go into %s " % catutils_scripts
+ "and run get_mdwarf_flares.sh "
+ "to get the data")
_MLT_LC_NPZ = numpy.load(self._mlt_lc_file)
sims_clean_up.targets.append(_MLT_LC_NPZ)
_MLT_LC_NPZ_NAME = self._mlt_lc_file
_MLT_LC_TIME_CACHE = {}
_MLT_LC_FLUX_CACHE = {}
if not hasattr(self, '_mlt_dust_lookup'):
# Construct a look-up table to determine the factor
# by which to multiply the flares' flux to account for
# dust as a function of E(B-V). Recall that we are
# modeling all MLT flares as 9000K blackbodies.
if not hasattr(self, 'lsstBandpassDict'):
raise RuntimeError('You are asking for MLT dwarf flaring '
'magnitudes in a catalog that has not '
'defined lsstBandpassDict. The MLT '
'flaring magnitudes model does not know '
'how to apply dust extinction to the '
'flares without the member variable '
'lsstBandpassDict being defined.')
ebv_grid = numpy.arange(0.0, 7.01, 0.01)
bb_wavelen = numpy.arange(200.0, 1500.0, 0.1)
hc_over_k = 1.4387e7 # nm*K
temp = 9000.0 # black body temperature in Kelvin
exp_arg = hc_over_k/(temp*bb_wavelen)
exp_term = 1.0/(numpy.exp(exp_arg) - 1.0)
ln_exp_term = numpy.log(exp_term)
# Blackbody f_lambda function;
# discard normalizing factors; we only care about finding the
# ratio of fluxes between the case with dust extinction and
# the case without dust extinction
log_bb_flambda = -5.0*numpy.log(bb_wavelen) + ln_exp_term
bb_flambda = numpy.exp(log_bb_flambda)
bb_sed = Sed(wavelen=bb_wavelen, flambda=bb_flambda)
base_fluxes = self.lsstBandpassDict.fluxListForSed(bb_sed)
a_x, b_x = bb_sed.setupCCMab()
self._mlt_dust_lookup = {}
self._mlt_dust_lookup['ebv'] = ebv_grid
list_of_bp = self.lsstBandpassDict.keys()
for bp in list_of_bp:
self._mlt_dust_lookup[bp] = numpy.zeros(len(ebv_grid))
for iebv, ebv_val in enumerate(ebv_grid):
wv, fl = bb_sed.addCCMDust(a_x, b_x,
ebv=ebv_val,
wavelen=bb_wavelen,
flambda=bb_flambda)
dusty_bb = Sed(wavelen=wv, flambda=fl)
dusty_fluxes = self.lsstBandpassDict.fluxListForSed(dusty_bb)
for ibp, bp in enumerate(list_of_bp):
self._mlt_dust_lookup[bp][iebv] = dusty_fluxes[ibp]/base_fluxes[ibp]
# get the distance to each star in parsecs
_au_to_parsec = 1.0/206265.0
dd = _au_to_parsec/parallax
# get the area of the sphere through which the star's energy
# is radiating to get to us (in cm^2)
_cm_per_parsec = 3.08576e16
sphere_area = 4.0*numpy.pi*numpy.power(dd*_cm_per_parsec, 2)
flux_factor = self.photParams.effarea/sphere_area
if isinstance(expmjd, numbers.Number):
dMags = numpy.zeros((6, self.num_variable_obj(params)))
else:
dMags = numpy.zeros((6, self.num_variable_obj(params), len(expmjd)))
mag_name_tuple = ('u', 'g', 'r', 'i', 'z', 'y')
base_fluxes = {}
base_mags = {}
ss = Sed()
for mag_name in mag_name_tuple:
if ('lsst_%s' % mag_name in self._actually_calculated_columns or
'delta_lsst_%s' % mag_name in self._actually_calculated_columns):
mm = quiescent_mags[mag_name]
base_mags[mag_name] = mm
base_fluxes[mag_name] = ss.fluxFromMag(mm)
lc_name_arr = params['lc'].astype(str)
lc_names_unique = numpy.unique(lc_name_arr)
for lc_name in lc_names_unique:
if 'None' in lc_name:
continue
use_this_lc = numpy.where(numpy.char.find(lc_name_arr, lc_name)==0)
lc_name = lc_name.replace('.txt', '')
# 2017 May 1
# There isn't supposed to be a 'late_inactive' light curve.
# Unfortunately, I (Scott Daniel) assigned 'late_inactive'
# light curves to some of the stars on our database. Rather
# than fix the database table (which will take about a week of
# compute time), I am going to fix the problem here by mapping
# 'late_inactive' into 'late_active'.
if 'late' in lc_name:
lc_name = lc_name.replace('in', '')
if lc_name in _MLT_LC_TIME_CACHE:
raw_time_arr = _MLT_LC_TIME_CACHE[lc_name]
else:
raw_time_arr = _MLT_LC_NPZ['%s_time' % lc_name]
_MLT_LC_TIME_CACHE[lc_name] = raw_time_arr
time_arr = self._survey_start + raw_time_arr
dt = time_arr.max() - time_arr.min()
if isinstance(expmjd, numbers.Number):
t_interp = (expmjd + params['t0'][use_this_lc]).astype(float)
else:
n_obj = len(use_this_lc[0])
n_time = len(expmjd)
t_interp = numpy.ones(shape=(n_obj, n_time))*expmjd
t_interp += numpy.array([[tt]*n_time for tt in params['t0'][use_this_lc].astype(float)])
while t_interp.max() > time_arr.max():
bad_dexes = numpy.where(t_interp>time_arr.max())
t_interp[bad_dexes] -= dt
for i_mag, mag_name in enumerate(mag_name_tuple):
if ('lsst_%s' % mag_name in self._actually_calculated_columns or
'delta_lsst_%s' % mag_name in self._actually_calculated_columns):
flux_name = '%s_%s' % (lc_name, mag_name)
if flux_name in _MLT_LC_FLUX_CACHE:
flux_arr = _MLT_LC_FLUX_CACHE[flux_name]
else:
flux_arr = _MLT_LC_NPZ[flux_name]
_MLT_LC_FLUX_CACHE[flux_name] = flux_arr
dflux = numpy.interp(t_interp, time_arr, flux_arr)
if isinstance(expmjd, numbers.Number):
dflux *= flux_factor[use_this_lc]
else:
dflux *= numpy.array([flux_factor[use_this_lc]]*n_time).transpose()
dust_factor = numpy.interp(ebv[use_this_lc],
self._mlt_dust_lookup['ebv'],
self._mlt_dust_lookup[mag_name])
if not isinstance(expmjd, numbers.Number):
dust_factor = numpy.array([dust_factor]*n_time).transpose()
dflux *= dust_factor
if isinstance(expmjd, numbers.Number):
local_base_fluxes = base_fluxes[mag_name][use_this_lc]
local_base_mags = base_mags[mag_name][use_this_lc]
else:
local_base_fluxes = numpy.array([base_fluxes[mag_name][use_this_lc]]*n_time).transpose()
local_base_mags = numpy.array([base_mags[mag_name][use_this_lc]]*n_time).transpose()
dMags[i_mag][use_this_lc] = (ss.magFromFlux(local_base_fluxes + dflux)
- local_base_mags)
return dMags
# galaxies require more calculations (which aren't part of manyMagCalc) and partly because we're using a different
# optimization (bandpass.manyMagCalc instead of sed.manyMagCalc).
# Start 'regular' magnitude calculation.
# Calculate dust extinction a_x and b_x vectors.
a_mw, b_mw = stars[starlist[0]].setupCCMab()
# Set up dictionary + arrays to hold calculated magnitude information.
mags1 = {}
for f in filterlist:
mags1[f] = numpy.zeros(num_star, dtype='float')
# For each star (in num_star's), apply apply MW dust, fluxnorm & calculate mags.
for i in range(num_star):
starname = starlist[star_name[i]]
tmpstar = Sed(wavelen=stars[starname].wavelen, flambda=stars[starname].flambda)
tmpstar.addCCMDust(a_mw, b_mw, ebv=ebv_mw[i])
tmpstar.multiplyFluxNorm(fluxnorm[i])
# Note that the stars have already been matched to the bandpass wavelength grid.
# Just want to be sure that fnu is already calculated.
tmpstar.flambdaTofnu()
for f in filterlist:
mags1[f][i] = tmpstar.calcMag(lsstbp[f])
dt, t = dtime(t)
print "Calculating dust/fluxnorm/%d magnitudes with some smart usage for %d stars took %f s" \
%(len(filterlist), num_star, dt)
# Test Sed.manyMagCalc :
# First: (re) calculate internal a/b on wavelength range required for dust extinction.
a_mw, b_mw = stars[starlist[0]].setupCCMab()
def _calculateGalSimSeds(self):
"""
Apply any physical corrections to the objects' SEDS (redshift them, apply dust, etc.).
Return a list of Sed objects containing the SEDS
"""
sedList = []
actualSEDnames = self.column_by_name('sedFilepath')
redshift = self.column_by_name('redshift')
internalAv = self.column_by_name('internalAv')
internalRv = self.column_by_name('internalRv')
galacticAv = self.column_by_name('galacticAv')
galacticRv = self.column_by_name('galacticRv')
magNorm = self.column_by_name('magNorm')
#for setting magNorm
imsimband = Bandpass()
imsimband.imsimBandpass()
outputNames=[]
for (sedName, zz, iAv, iRv, gAv, gRv, norm) in \
zip(actualSEDnames, redshift, internalAv, internalRv, galacticAv, galacticRv, magNorm):
if is_null(sedName):
sedList.append(None)
else:
if sedName in self.uniqueSeds:
#we have already read in this file; no need to do it again
sed = Sed(wavelen=self.uniqueSeds[sedName].wavelen,
flambda=self.uniqueSeds[sedName].flambda,
fnu=self.uniqueSeds[sedName].fnu,
name=self.uniqueSeds[sedName].name)
else:
#load the SED of the object
sed = Sed()
sedFile = os.path.join(self.sedDir, sedName)
sed.readSED_flambda(sedFile)
flambdaCopy = copy.deepcopy(sed.flambda)
#If the SED is zero inside of the bandpass, GalSim raises an error.
#This sets a minimum flux value of 1.0e-30 so that the SED is never technically
#zero inside of the bandpass.
sed.flambda = numpy.array([ff if ff>1.0e-30 else 1.0e-30 for ff in flambdaCopy])
sed.fnu = None
#copy the unnormalized file to uniqueSeds so we don't have to read it in again
sedCopy = Sed(wavelen=sed.wavelen, flambda=sed.flambda,
fnu=sed.fnu, name=sed.name)
self.uniqueSeds[sedName] = sedCopy
#normalize the SED
#Consulting the file sed.py in GalSim/galsim/ it appears that GalSim expects
#its SEDs to ultimately be in units of ergs/nm so that, when called, they can
#be converted to photons/nm (see the function __call__() and the assignment of
#self._rest_photons in the __init__() of galsim's sed.py file). Thus, we need
#to read in our SEDs, normalize them, and then multiply by the exposure time
#and the effective area to get from ergs/s/cm^2/nm to ergs/nm.
#
#The gain parameter should convert between photons and ADU (so: it is the
#traditional definition of "gain" -- electrons per ADU -- multiplied by the
#quantum efficiency of the detector). Because we fold the quantum efficiency
#of the detector into our total_[u,g,r,i,z,y].dat bandpass files
#(see the readme in the THROUGHPUTS_DIR/baseline/), we only need to multiply
#by the electrons per ADU gain.
#
#We will take these parameters from an instantiation of the PhotometricParameters
#class (which can be reassigned by defining a daughter class of this class)
#
fNorm = sed.calcFluxNorm(norm, imsimband)
sed.multiplyFluxNorm(fNorm)
#apply dust extinction (internal)
if iAv != 0.0 and iRv != 0.0:
a_int, b_int = sed.setupCCMab()
sed.addCCMDust(a_int, b_int, A_v=iAv, R_v=iRv)
#22 June 2015
#apply redshift; there is no need to apply the distance modulus from
#sims/photUtils/CosmologyWrapper; magNorm takes that into account
#however, magNorm does not take into account cosmological dimming
if zz != 0.0:
sed.redshiftSED(zz, dimming=True)
#apply dust extinction (galactic)
a_int, b_int = sed.setupCCMab()
sed.addCCMDust(a_int, b_int, A_v=gAv, R_v=gRv)
sedList.append(sed)
return sedList
# by simply running 'python example_fastgals.py', but on my mac it was about 1.7 times faster optimized, with
# wavelen_step = 0.1 nm. (wavelen_step will have an impact on the speed difference).
# (w/ wavelen_step=0.25, find a 2.5 times faster speedup in the optimized version).
# Start 'regular' magnitude calculation.
# Calculate internal a/b on the wavelength range required for calculating internal dust extinction.
a_int, b_int = gals[gallist[0]].setupCCMab()
# Set up dictionary + arrays to hold calculated magnitude information.
mags1 = {}
for f in filterlist:
mags1[f] = numpy.zeros(num_gal, dtype='float')
# For each galaxy (in num_gal's), apply internal dust, redshift, apply MW dust, fluxnorm & calculate mags.
for i in range(num_gal):
galname = gallist[gal_name[i]]
tmpgal = Sed(wavelen=gals[galname].wavelen, flambda=gals[galname].flambda)
tmpgal.addCCMDust(a_int, b_int, ebv=ebv_int[i])
tmpgal.redshiftSED(redshifts[i])
a_mw, b_mw = tmpgal.setupCCMab()
tmpgal.addCCMDust(a_mw, b_mw, ebv=ebv_mw[i])
tmpgal.multiplyFluxNorm(fluxnorm[i])
# If you comment out the synchronize sed here, then the difference between this method and the optimized
# version increases to a 2.5 times difference. (i.e. this 'synchronizeSED' buys you 1.6x faster, by itself.)
tmpgal.synchronizeSED(wavelen_min=wavelen_min,
wavelen_max=wavelen_max,
wavelen_step = wavelen_step)
for f in filterlist:
mags1[f][i] = tmpgal.calcMag(lsstbp[f])
dt, t = dtime(t)
print "Calculating dust/redshift/dust/fluxnorm/%d magnitudes for %d galaxies took %f s" \
%(len(filterlist), num_gal, dt)
