def testRedshiftName(self): testsed = Sed(self.testsed.wavelen, self.testsed.flambda, name=self.testsed.name) redshift = .2 testsed.redshiftSED(redshift=redshift) newname = testsed.name + '_Z' + '%.2f' % (redshift) testsed.name = newname self.assertEqual(testsed.name, newname)
def get_sed(name, magnorm, redshift, av, rv): if not hasattr(get_sed, '_rest_dict'): get_sed._rest_dict = {} get_sed._imsim_bp = Bandpass() get_sed._imsim_bp.imsimBandpass() get_sed._sed_dir = os.environ['SIMS_SED_LIBRARY_DIR'] get_sed._ccm_w = None tag = '%s_%.2f_%.2f' % (name, av, rv) if tag not in get_sed._rest_dict: ss = Sed() ss.readSED_flambda(os.path.join(get_sed._sed_dir, name)) if get_sed._ccm_w is None or not np.array_equal( ss.wavelen, get_sed._ccm_w): get_sed._ccm_w = np.copy(ss.wavelen) get_sed._ax, get_sed._bx = ss.setupCCM_ab() mn = ss.calcMag(get_sed._imsim_bp) ss.addDust(get_sed._ax, get_sed._bx, A_v=av, R_v=rv) get_sed._rest_dict[tag] = (ss, mn) base_sed = get_sed._rest_dict[tag][0] ss = Sed(wavelen=base_sed.wavelen, flambda=base_sed.flambda) dmag = magnorm - get_sed._rest_dict[tag][1] fnorm = np.power(10.0, -0.4 * dmag) ss.multiplyFluxNorm(fnorm) ss.redshiftSED(redshift, dimming=True) return ss
def _fluxes(sed_name, mag_norm, redshift): """ Find the fluxes for a galaxy component Parameters ---------- sed_name is an SED file name mag_norm is a float redshift is a float Returns ------- array of fluxes in ugrizy order """ if not hasattr(_fluxes, '_bp_dict'): bp_dir = getPackageDir('throughputs') bp_dir = os.path.join(bp_dir, 'imsim', 'goal') _fluxes._bp_dict = BandpassDict.loadTotalBandpassesFromFiles( bandpassDir=bp_dir) _fluxes._sed_dir = getPackageDir('sims_sed_library') spec = Sed() full_sed_name = os.path.join(_fluxes._sed_dir, sed_name) if not os.path.isfile(full_sed_name): full_sed_name = os.path.join(_fluxes._sed_dir, defaultSpecMap[sed_name]) spec.readSED_flambda(full_sed_name) fnorm = getImsimFluxNorm(spec, mag_norm) spec.multiplyFluxNorm(fnorm) spec.redshiftSED(redshift, dimming=True) return _fluxes._bp_dict.fluxListForSed(spec)
def calcMagNorm(self, objectMags, sedObj, bandpassDict, mag_error=None, redshift=None, filtRange=None): """ This will find the magNorm value that gives the closest match to the magnitudes of the object using the matched SED. Uses scipy.optimize.leastsq to find the values of fluxNorm that minimizes the function: ((flux_obs - (fluxNorm*flux_model))/flux_error)**2. @param [in] objectMags are the magnitude values for the object with extinction matching that of the SED object. In the normal case using the selectSED routines above it will be dereddened mags. @param [in] sedObj is an Sed class instance that is set with the wavelength and flux of the matched SED @param [in] bandpassDict is a BandpassDict class instance with the Bandpasses set to those for the magnitudes given for the catalog object @param [in] mag_error are provided error values for magnitudes in objectMags. If none provided then this defaults to 1.0. This should be an array of the same length as objectMags. @param [in] redshift is the redshift of the object if the magnitude is observed @param [in] filtRange is a selected range of filters specified by their indices in the bandpassList to match up against. Used when missing data in some magnitude bands. @param [out] bestMagNorm is the magnitude normalization for the given magnitudes and SED """ import scipy.optimize as opt sedTest = Sed() sedTest.setSED(sedObj.wavelen, flambda=sedObj.flambda) if redshift is not None: sedTest.redshiftSED(redshift) imSimBand = Bandpass() imSimBand.imsimBandpass() zp = -2.5 * np.log10(3631) #Note using default AB zeropoint flux_obs = np.power(10, (objectMags + zp) / (-2.5)) sedTest.resampleSED(wavelen_match=bandpassDict.wavelenMatch) sedTest.flambdaTofnu() flux_model = sedTest.manyFluxCalc(bandpassDict.phiArray, bandpassDict.wavelenStep) if filtRange is not None: flux_obs = flux_obs[filtRange] flux_model = flux_model[filtRange] if mag_error is None: flux_error = np.ones(len(flux_obs)) else: flux_error = np.abs(flux_obs * (np.log(10) / (-2.5)) * mag_error) bestFluxNorm = opt.leastsq( lambda x: ((flux_obs - (x * flux_model)) / flux_error), 1.0)[0][0] sedTest.multiplyFluxNorm(bestFluxNorm) bestMagNorm = sedTest.calcMag(imSimBand) return bestMagNorm
def _parallel_fitting(mag_array, redshift, redshift_true, H0, Om0, wav_min, wav_width, lsst_mag_array, out_dict, tag): pid = os.getpid() (sed_names, mag_norms, av_arr, rv_arr) = sed_from_galacticus_mags(mag_array, redshift, redshift_true, H0, Om0, wav_min, wav_width, lsst_mag_array) tot_bp_dict = BandpassDict.loadTotalBandpassesFromFiles() sed_dir = getPackageDir('sims_sed_library') lsst_fit_fluxes = np.zeros((6, len(sed_names)), dtype=float) t_start = time.time() ccm_w = None restframe_seds = {} imsim_bp = Bandpass() imsim_bp.imsimBandpass() n04_ln10 = -0.4 * np.log(10) for ii in range(len(sed_names)): av_val = av_arr[ii] rv_val = rv_arr[ii] sed_tag = '%s_%.3f_%.3f' % (sed_names[ii], av_val, rv_val) if sed_tag not in restframe_seds: rest_sed = Sed() rest_sed.readSED_flambda(os.path.join(sed_dir, sed_names[ii])) mag = rest_sed.calcMag(imsim_bp) if ccm_w is None or not np.array_equal(rest_sed.wavelen, ccm_w): ccm_w = np.copy(rest_sed.wavelen) ax, bx = rest_sed.setupCCM_ab() rest_sed.addDust(ax, bx, A_v=av_val, R_v=rv_val) restframe_seds[sed_tag] = (rest_sed, mag) for i_bp, bp in enumerate('ugrizy'): m_norm = mag_norms[i_bp][ii] if m_norm > 0.0 and not np.isfinite(m_norm): continue spec = Sed(wavelen=restframe_seds[sed_tag][0].wavelen, flambda=restframe_seds[sed_tag][0].flambda) fnorm = np.exp(n04_ln10 * (m_norm - restframe_seds[sed_tag][1])) try: assert np.isfinite(fnorm) assert fnorm > 0.0 except AssertionError: print('\n\nmagnorm %e\n\n' % (m_norm)) raise spec.multiplyFluxNorm(fnorm) spec.redshiftSED(redshift[ii], dimming=True) ff = spec.calcFlux(tot_bp_dict[bp]) lsst_fit_fluxes[i_bp][ii] = ff out_dict[tag] = (sed_names, mag_norms, av_arr, rv_arr, lsst_fit_fluxes)
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.setupCCM_ab() sed.addDust(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.setupCCM_ab() sed.addDust(a_int, b_int, A_v=galacticAv, R_v=galacticRv) adu = sed.calcADU(bandpass, photParams=PhotometricParameters()) return adu
def calcMagNorm(self, objectMags, sedObj, bandpassDict, mag_error = None, redshift = None, filtRange = None): """ This will find the magNorm value that gives the closest match to the magnitudes of the object using the matched SED. Uses scipy.optimize.leastsq to find the values of fluxNorm that minimizes the function: ((flux_obs - (fluxNorm*flux_model))/flux_error)**2. @param [in] objectMags are the magnitude values for the object with extinction matching that of the SED object. In the normal case using the selectSED routines above it will be dereddened mags. @param [in] sedObj is an Sed class instance that is set with the wavelength and flux of the matched SED @param [in] bandpassDict is a BandpassDict class instance with the Bandpasses set to those for the magnitudes given for the catalog object @param [in] mag_error are provided error values for magnitudes in objectMags. If none provided then this defaults to 1.0. This should be an array of the same length as objectMags. @param [in] redshift is the redshift of the object if the magnitude is observed @param [in] filtRange is a selected range of filters specified by their indices in the bandpassList to match up against. Used when missing data in some magnitude bands. @param [out] bestMagNorm is the magnitude normalization for the given magnitudes and SED """ import scipy.optimize as opt sedTest = Sed() sedTest.setSED(sedObj.wavelen, flambda = sedObj.flambda) if redshift is not None: sedTest.redshiftSED(redshift) imSimBand = Bandpass() imSimBand.imsimBandpass() zp = -2.5*np.log10(3631) #Note using default AB zeropoint flux_obs = np.power(10,(objectMags + zp)/(-2.5)) sedTest.resampleSED(wavelen_match=bandpassDict.wavelenMatch) sedTest.flambdaTofnu() flux_model = sedTest.manyFluxCalc(bandpassDict.phiArray, bandpassDict.wavelenStep) if filtRange is not None: flux_obs = flux_obs[filtRange] flux_model = flux_model[filtRange] if mag_error is None: flux_error = np.ones(len(flux_obs)) else: flux_error = np.abs(flux_obs*(np.log(10)/(-2.5))*mag_error) bestFluxNorm = opt.leastsq(lambda x: ((flux_obs - (x*flux_model))/flux_error), 1.0)[0][0] sedTest.multiplyFluxNorm(bestFluxNorm) bestMagNorm = sedTest.calcMag(imSimBand) return bestMagNorm
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.setupCCM_ab() sed.addDust(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.setupCCM_ab() sed.addDust(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): 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 create_k_corr_grid(redshift): """ (Edited from original because of error) Returns a grid of redshifts and K corrections on the LSST Simulations AGN SED that can be used for K correction interpolation. """ bp_dict = BandpassDict.loadTotalBandpassesFromFiles() bp_i = bp_dict['i'] sed_dir = os.path.join(getPackageDir('sims_sed_library'), 'agnSED') sed_name = os.path.join(sed_dir, 'agn.spec.gz') if not os.path.exists(sed_name): raise RuntimeError('\n\n%s\n\nndoes not exist\n\n' % sed_name) base_sed = Sed() base_sed.readSED_flambda(sed_name) z_grid = np.arange(0.0, redshift.max(), 0.01) k_grid = np.zeros(len(z_grid), dtype=float) for i_z, zz in enumerate(z_grid): ss = Sed(flambda=base_sed.flambda, wavelen=base_sed.wavelen) ss.redshiftSED(zz, dimming=True) k = k_correction(ss, bp_i, zz) k_grid[i_z] = k return z_grid, k_grid
def test_k_correction(self): """ Test that the K correction correctly converts absolute magnitude to observed magnitude. """ bp_dict = BandpassDict.loadTotalBandpassesFromFiles() rng = np.random.RandomState(41321) sed_dir = os.path.join(getPackageDir('sims_sed_library'), 'galaxySED') list_of_sed_files = os.listdir(sed_dir) list_of_sed_files.sort() sed_to_check = rng.choice(list_of_sed_files, size=10) redshift_arr = rng.random_sample(len(sed_to_check)) * 2.0 + 0.1 bp = bp_dict['g'] for sed_name, zz in zip(sed_to_check, redshift_arr): full_name = os.path.join(sed_dir, sed_name) ss = Sed() ss.readSED_flambda(full_name) true_rest_mag = ss.calcMag(bp) ss.redshiftSED(zz, dimming=True) obs_mag = ss.calcMag(bp) k_corr = k_correction(ss, bp, zz) self.assertLess(np.abs(true_rest_mag - obs_mag + k_corr), 0.001)
def read_quasar(): # read quasar spectra and redshift homedir = os.getenv("HOME") quasardir = os.path.join(homedir, "seds/quasar") # read zero redshift quasar base = Sed() base.readSED_flambda(os.path.join(quasardir, "quasar.dat")) # redshift #redshifts = [0, 0.1, 0.2, 0.3, 0.5, 0.8, 1.0, 1.3, 1.6, 1.9, 2.2, 2.5] #redshifts = numpy.array(redshifts) redshifts= numpy.arange(0, 2.8, 0.1) quasars = {} for z in redshifts: wavelen, flambda = base.redshiftSED(z, wavelen=base.wavelen, flambda=base.flambda) quasars[z] = Sed(wavelen=wavelen, flambda=flambda) print "# Generated %d quasars at redshifts between %f and %f" %(len(redshifts), redshifts.min(), redshifts.max()) # resample onto the standard bandpass for Bandpass obj's and calculate fnu to speed later calculations for z in redshifts: quasars[z].synchronizeSED(wavelen_min=WMIN, wavelen_max=WMAX, wavelen_step=WSTEP) return quasars, redshifts
raw_agn_sed.readSED_flambda(sed_file) imsim_bp = Bandpass() imsim_bp.imsimBandpass() bp_dict = BandpassDict.loadTotalBandpassesFromFiles() with open('agn_variability_distribution.txt', 'w') as out_file: out_file.write('# z u g r i z y tau sfu sfg sfr sfi sfz sfy\n') for chunk in data_iter: for line in chunk: agn_sed = Sed(wavelen=raw_agn_sed.wavelen, flambda=raw_agn_sed.flambda) fnorm = agn_sed.calcFluxNorm(line['magNorm'], imsim_bp) agn_sed.multiplyFluxNorm(fnorm) agn_sed.redshiftSED(line['z'], dimming=True) mags = bp_dict.magListForSed(agn_sed) params = json.loads(line['varParamStr']) tau = params['pars']['agn_tau'] sfu = params['pars']['agn_sfu'] sfg = params['pars']['agn_sfg'] sfr = params['pars']['agn_sfr'] sfi = params['pars']['agn_sfi'] sfz = params['pars']['agn_sfz'] sfy = params['pars']['agn_sfy'] out_file.write( '%e %e %e %e %e %e %e %e %e %e %e %e %e %e\n' % (line['z'], mags[0], mags[1], mags[2], mags[3], mags[4], mags[5], tau, sfu, sfg, sfr, sfi, sfz, sfy))
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 matchToObserved(self, sedList, catMags, catRedshifts, catRA = None, catDec = None, mag_error = None, bandpassDict = None, dzAcc = 2, reddening = True, extCoeffs = (4.239, 3.303, 2.285, 1.698, 1.263)): """ This will find the closest match to the magnitudes of a galaxy catalog if those magnitudes are in the observed frame and can correct for reddening from within the milky way as well if needed. In order to make things faster it first calculates colors for all model SEDs at redshifts between the minimum and maximum redshifts of the catalog objects provided with a grid spacing in redshift defined by the parameter dzAcc. Objects without magnitudes in at least two adjacent bandpasses will return as none and print out a message. @param [in] sedList is the set of spectral objects from the models SEDs provided by loadBC03 or other custom loader routine. @param [in] catMags is an array of the magnitudes of catalog objects to be matched with a model SED. It should be organized so that there is one object's magnitudes along each row. @param [in] catRedshifts is an array of the redshifts of each catalog object. @param [in] catRA is an array of the RA positions for each catalog object. @param [in] catDec is an array of the Dec position for each catalog object. @param [in] mag_error are provided error values for magnitudes in objectMags. If none provided then this defaults to 1.0. This should be an array of the same size as catMags. @param [in] bandpassDict is a BandpassDict with which to calculate magnitudes. If left equal to None it will by default load the SDSS [u,g,r,i,z] bandpasses and therefore agree with default extCoeffs. @param [in] dzAcc is the number of decimal places you want to use when building the redshift grid. For example, dzAcc = 2 will create a grid between the minimum and maximum redshifts with colors calculated at every 0.01 change in redshift. @param [in] reddening is a boolean that determines whether to correct catalog magnitudes for dust in the milky way. By default, it is True. If true, this uses calculateEBV from EBV.py to find an EBV value for the object's ra and dec coordinates and then uses the coefficients provided by extCoeffs which should come from Schlafly and Finkbeiner (2011) for the correct filters and in the same order as provided in bandpassDict. If false, this means it will not run the dereddening procedure. @param [in] extCoeffs are the Schlafly and Finkbeiner (2011) (ApJ, 737, 103) coefficients for the given filters from bandpassDict and need to be in the same order as bandpassDict. The default given are the SDSS [u,g,r,i,z] values. @param [out] sedMatches is a list with the name of a model SED that matches most closely to each object in the catalog. @param [out] magNormMatches are the magnitude normalizations for the given magnitudes and matched SED. @param [out] matchErrors contains the Mean Squared Error between the colors of each object and the colors of the matched SED. """ #Set up photometry to calculate model Mags if bandpassDict is None: galPhot = BandpassDict.loadTotalBandpassesFromFiles(['u','g','r','i','z'], bandpassDir = os.path.join(lsst.utils.getPackageDir('throughputs'),'sdss'), bandpassRoot = 'sdss_') else: galPhot = bandpassDict #Calculate ebv from ra, dec coordinates if needed if reddening == True: #Check that catRA and catDec are included if catRA is None or catDec is None: raise RuntimeError("Reddening is True, but catRA and catDec are not included.") calcEBV = ebv() raDec = np.array((catRA,catDec)) #If only matching one object need to reshape for calculateEbv if len(raDec.shape) == 1: raDec = raDec.reshape((2,1)) ebvVals = calcEBV.calculateEbv(equatorialCoordinates = raDec) objMags = self.deReddenMags(ebvVals, catMags, extCoeffs) else: objMags = catMags minRedshift = np.round(np.min(catRedshifts), dzAcc) maxRedshift = np.round(np.max(catRedshifts), dzAcc) dz = np.power(10., (-1*dzAcc)) redshiftRange = np.round(np.arange(minRedshift - dz, maxRedshift + (2*dz), dz), dzAcc) numRedshifted = 0 sedMatches = [None] * len(catRedshifts) magNormMatches = [None] * len(catRedshifts) matchErrors = [None] * len(catRedshifts) redshiftIndex = np.argsort(catRedshifts) numOn = 0 notMatched = 0 lastRedshift = -100 print('Starting Matching. Arranged by redshift value.') for redshift in redshiftRange: if numRedshifted % 10 == 0: print('%i out of %i redshifts gone through' % (numRedshifted, len(redshiftRange))) numRedshifted += 1 colorSet = [] for galSpec in sedList: sedColors = [] fileSED = Sed() fileSED.setSED(wavelen = galSpec.wavelen, flambda = galSpec.flambda) fileSED.redshiftSED(redshift) sedColors = self.calcBasicColors([fileSED], galPhot, makeCopy = True) colorSet.append(sedColors) colorSet = np.transpose(colorSet) for currentIndex in redshiftIndex[numOn:]: matchMags = objMags[currentIndex] if lastRedshift < np.round(catRedshifts[currentIndex],dzAcc) <= redshift: colorRange = np.arange(0, len(galPhot)-1) matchColors = [] for colorNum in colorRange: matchColors.append(matchMags[colorNum] - matchMags[colorNum+1]) #This is done to handle objects with incomplete magnitude data filtNums = np.arange(0, len(galPhot)) if np.isnan(np.amin(matchColors))==True: colorRange = np.where(np.isnan(matchColors)==False)[0] filtNums = np.unique([colorRange, colorRange+1]) #Pick right filters in calcMagNorm if len(colorRange) == 0: print('Could not match object #%i. No magnitudes for two adjacent bandpasses.' \ % (currentIndex)) notMatched += 1 #Don't need to assign 'None' here in result array, b/c 'None' is default value else: distanceArray = [np.zeros(len(sedList))] for colorNum in colorRange: distanceArray += np.power((colorSet[colorNum] - matchColors[colorNum]),2) matchedSEDNum = np.nanargmin(distanceArray) sedMatches[currentIndex] = sedList[matchedSEDNum].name magNormVal = self.calcMagNorm(np.array(matchMags), sedList[matchedSEDNum], galPhot, mag_error = mag_error, redshift = catRedshifts[currentIndex], filtRange = filtNums) magNormMatches[currentIndex] = magNormVal matchErrors[currentIndex] = (distanceArray[0,matchedSEDNum]/len(colorRange)) numOn += 1 else: break lastRedshift = redshift print('Done Matching. Matched %i of %i catalog objects to SEDs' % (len(catMags)-notMatched, len(catMags))) if notMatched > 0: print('%i objects did not get matched.' % (notMatched)) return sedMatches, magNormMatches, matchErrors
sed_name = os.path.join(getPackageDir('sims_sed_library'), 'agnSED', 'agn.spec.gz') assert os.path.exists(sed_name) base_sed = Sed() base_sed.readSED_flambda(sed_name) bp_dict = BandpassDict.loadTotalBandpassesFromFiles() bp = bp_dict['i'] z_grid = np.arange(0.0, 16.0, 0.01) k_grid = np.zeros(len(z_grid), dtype=float) for i_z, zz in enumerate(z_grid): ss = Sed(flambda=base_sed.flambda, wavelen=base_sed.wavelen) ss.redshiftSED(zz, dimming=True) k = k_correction(ss, bp, zz) k_grid[i_z] = k cosmo = CosmologyObject() db = DBObject(database='LSSTCATSIM', host='fatboy.phys.washington.edu', port=1433, driver='mssql+pymssql') query = 'SELECT magnorm_agn, redshift, varParamStr FROM ' query += 'galaxy WHERE varParamStr IS NOT NULL ' query += 'AND dec BETWEEN -2.5 AND 2.5 ' query += 'AND (ra<2.5 OR ra>357.5)'
# 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])
# 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 sed_from_galacticus_mags(galacticus_mags, redshift, redshift_true, H0, Om0, wav_min, wav_width, obs_lsst_mags): """ Fit SEDs from sims_sed_library to Galacticus galaxies based on the magnitudes in tophat filters. Parameters ---------- galacticus_mags is a numpy array such that galacticus_mags[i][j] is the magnitude of the jth star in the ith bandpass, where the bandpasses are ordered in ascending order of minimum wavelength. redshift is an array of redshifts for the galaxies being fit (includes cosmology and proper motion) redshift_true is an array of cosmological redshifts for the galaxies being fit H0 is the Hubbleparameter in units of km/s/Mpc Om0 is the critical density parameter for matter wav_min is a numpy array of the minimum wavelengths of the tophat filters (in nm) wav_grid is a numpy array of the widths of the tophat filters (in nm) ob_lsst_mags is a numpy array of observer frame LSST magnitudes. obs_lsst_mags[0] will contain the u band magnitudes of every object. Returns ------- a numpy array of SED names and a numpy array of magNorms. """ if (not hasattr(sed_from_galacticus_mags, '_color_tree') or not np.allclose(wav_min, sed_from_galacticus_mags._wav_min, atol=1.0e-10, rtol=0.0) or not np.allclose(wav_width, sed_from_galacticus_mags._wav_width, atol=1.0e-10, rtol=0.0)): (sed_names, sed_mag_list, sed_mag_norm, av_grid, rv_grid) = _create_sed_library_mags(wav_min, wav_width) assert rv_grid.min() > 0.0 assert len(np.where(np.logical_not(np.isfinite(rv_grid)))[0]) == 0 sed_colors = sed_mag_list[:, 1:] - sed_mag_list[:, :-1] sed_from_galacticus_mags._sed_names = sed_names sed_from_galacticus_mags._mag_norm = sed_mag_norm # N_sed sed_from_galacticus_mags._av_grid = av_grid sed_from_galacticus_mags._rv_grid = rv_grid sed_from_galacticus_mags._sed_mags = sed_mag_list # N_sed by N_mag sed_from_galacticus_mags._color_tree = scipy_spatial.cKDTree( sed_colors) sed_from_galacticus_mags._wav_min = wav_min sed_from_galacticus_mags._wav_width = wav_width if (not hasattr(sed_from_galacticus_mags, '_cosmo') or np.abs(sed_from_galacticus_mags._cosmo.H() - H0) > 1.0e-6 or np.abs(sed_from_galacticus_mags._cosmo.OmegaMatter() - Om0) > 1.0e-6): sed_from_galacticus_mags._cosmo = CosmologyObject(H0=H0, Om0=Om0) galacticus_mags_t = np.asarray(galacticus_mags).T # N_star by N_mag assert galacticus_mags_t.shape == ( len(redshift), sed_from_galacticus_mags._sed_mags.shape[1]) with np.errstate(invalid='ignore', divide='ignore'): galacticus_colors = galacticus_mags_t[:, 1:] - galacticus_mags_t[:, : -1] # N_star by (N_mag - 1) t_start = time.time() (sed_dist, sed_idx) = sed_from_galacticus_mags._color_tree.query(galacticus_colors, k=1) # cKDTree returns an invalid index (==len(tree_data)) in cases # where the distance is not finite sed_idx = np.where(sed_idx < len(sed_from_galacticus_mags._sed_names), sed_idx, 0) distance_modulus = sed_from_galacticus_mags._cosmo.distanceModulus( redshift=redshift_true) output_names = sed_from_galacticus_mags._sed_names[sed_idx] (lsst_bp_dict, dummy_bp_dict) = BandpassDict.loadBandpassesFromFiles() output_mag_norm = np.zeros((6, len(output_names)), dtype=float) base_norm = sed_from_galacticus_mags._mag_norm[sed_idx] assert len(np.where(np.logical_not(np.isfinite(base_norm)))[0]) == 0 ccm_w = None av_arr = sed_from_galacticus_mags._av_grid[sed_idx] rv_arr = sed_from_galacticus_mags._rv_grid[sed_idx] assert rv_arr.min() > 0.0 assert len(np.where(np.logical_not(np.isfinite(rv_arr)))[0]) == 0 for i_bp in range(6): output_mag_norm[i_bp, :] = base_norm + distance_modulus sed_dir = getPackageDir('sims_sed_library') for i_obj in range(len(output_names)): spec = Sed() spec.readSED_flambda(os.path.join(sed_dir, output_names[i_obj])) if ccm_w is None or not np.array_equal(spec.wavelen, ccm_w): ccm_w = np.copy(spec.wavelen) ax, bx = spec.setupCCM_ab() spec.addDust(ax, bx, A_v=av_arr[i_obj], R_v=rv_arr[i_obj]) spec.redshiftSED(redshift[i_obj], dimming=True) lsst_mags = lsst_bp_dict.magListForSed(spec) d_mag = obs_lsst_mags[:, i_obj] - lsst_mags output_mag_norm[:, i_obj] += d_mag return (output_names, output_mag_norm, av_arr, rv_arr)
def write_sprinkled_lc(out_file_name, total_obs_md, pointing_dir, opsim_db_name, ra_colname='descDitheredRA', dec_colname='descDitheredDec', rottel_colname = 'descDitheredRotTelPos', sql_file_name=None, bp_dict=None): """ Create database of light curves Note: this is still under development. It has not yet been used for a production-level truth catalog Parameters ---------- out_file_name is the name of the sqlite file to be written total_obs_md is an ObservationMetaData covering the whole survey area pointing_dir contains a series of files that are two columns: obshistid, mjd. The files must each have 'visits' in their name. These specify the pointings for which we are assembling data. See: https://github.com/LSSTDESC/DC2_Repo/tree/master/data/Run1.1 for an example. opsim_db_name is the name of the OpSim database to be queried for pointings ra_colname is the column used for RA of the pointing (default: descDitheredRA) dec_colname is the column used for the Dec of the pointing (default: descDitheredDec) rottel_colname is the column used for the rotTelPos of the pointing (default: desckDitheredRotTelPos') sql_file_name is the name of the parameter database produced by write_sprinkled_param_db to be used bp_dict is a BandpassDict of the telescope filters to be used Returns ------- None Writes out a database to out_file_name. The tables of this database and their columns are: light_curves: - uniqueId -- an int unique to all objects - obshistid -- an int unique to all pointings - mag -- the magnitude observed for this object at that pointing obs_metadata: - obshistid -- an int unique to all pointings - mjd -- the date of the pointing - filter -- an int corresponding to the telescope filter (0==u, 1==g..) variables_and_transients: - uniqueId -- an int unique to all objects - galaxy_id -- an int indicating the host galaxy - ra -- in degrees - dec -- in degrees - agn -- ==1 if object is an AGN - sn -- ==1 if object is a supernova """ t0_master = time.time() if not os.path.isfile(sql_file_name): raise RuntimeError('%s does not exist' % sql_file_name) sn_simulator = SneSimulator(bp_dict) sed_dir = os.environ['SIMS_SED_LIBRARY_DIR'] create_sprinkled_sql_file(out_file_name) t_start = time.time() # get data about the pointings being simulated (htmid_dict, mjd_dict, filter_dict, obsmd_dict) = get_pointing_htmid(pointing_dir, opsim_db_name, ra_colname=ra_colname, dec_colname=dec_colname) t_htmid_dict = time.time()-t_start bp_to_int = {'u':0, 'g':1, 'r':2, 'i':3, 'z':4, 'y':5} # put the data about the pointings in the obs_metadata table with sqlite3.connect(out_file_name) as conn: cursor = conn.cursor() values = ((int(obs), mjd_dict[obs], bp_to_int[filter_dict[obs]]) for obs in mjd_dict) cursor.executemany('''INSERT INTO obs_metadata VALUES (?,?,?)''', values) cursor.execute('''CREATE INDEX obs_filter ON obs_metadata (obshistid, filter)''') conn.commit() print('\ngot htmid_dict -- %d in %e seconds' % (len(htmid_dict), t_htmid_dict)) db = DBObject(sql_file_name, driver='sqlite') # get a list of htmid corresponding to trixels in which # variables and transients can be found query = 'SELECT DISTINCT htmid FROM zpoint WHERE is_agn=1 OR is_sn=1' dtype = np.dtype([('htmid', int)]) results = db.execute_arbitrary(query, dtype=dtype) object_htmid = results['htmid'] agn_dtype = np.dtype([('uniqueId', int), ('galaxy_id', int), ('ra', float), ('dec', float), ('redshift', float), ('sed', str, 500), ('magnorm', float), ('varParamStr', str, 500), ('is_sprinkled', int)]) agn_base_query = 'SELECT uniqueId, galaxy_id, ' agn_base_query += 'raJ2000, decJ2000, ' agn_base_query += 'redshift, sedFilepath, ' agn_base_query += 'magNorm, varParamStr, is_sprinkled ' agn_base_query += 'FROM zpoint WHERE is_agn=1 ' sn_dtype = np.dtype([('uniqueId', int), ('galaxy_id', int), ('ra', float), ('dec', float), ('redshift', float), ('sn_truth_params', str, 500), ('is_sprinkled', int)]) sn_base_query = 'SELECT uniqueId, galaxy_id, ' sn_base_query += 'raJ2000, decJ2000, ' sn_base_query += 'redshift, sn_truth_params, is_sprinkled ' sn_base_query += 'FROM zpoint WHERE is_sn=1 ' filter_to_int = {'u':0, 'g':1, 'r':2, 'i':3, 'z':4, 'y':5} n_floats = 0 with sqlite3.connect(out_file_name) as conn: cursor = conn.cursor() t_before_htmid = time.time() # loop over trixels containing variables and transients, simulating # the light curves of those objects for htmid_dex, htmid in enumerate(object_htmid): if htmid_dex>0: htmid_duration = (time.time()-t_before_htmid)/3600.0 htmid_prediction = len(object_htmid)*htmid_duration/htmid_dex print('%d htmid out of %d in %e hours; predict %e hours remaining' % (htmid_dex, len(object_htmid), htmid_duration,htmid_prediction-htmid_duration)) mjd_arr = [] obs_arr = [] filter_arr = [] # Find only those pointings which overlap the current trixel for obshistid in htmid_dict: is_contained = False for bounds in htmid_dict[obshistid]: if htmid<=bounds[1] and htmid>=bounds[0]: is_contained = True break if is_contained: mjd_arr.append(mjd_dict[obshistid]) obs_arr.append(obshistid) filter_arr.append(filter_to_int[filter_dict[obshistid]]) if len(mjd_arr) == 0: continue mjd_arr = np.array(mjd_arr) obs_arr = np.array(obs_arr) filter_arr = np.array(filter_arr) sorted_dex = np.argsort(mjd_arr) mjd_arr = mjd_arr[sorted_dex] obs_arr = obs_arr[sorted_dex] filter_arr = filter_arr[sorted_dex] agn_query = agn_base_query + 'AND htmid=%d' % htmid agn_iter = db.get_arbitrary_chunk_iterator(agn_query, dtype=agn_dtype, chunk_size=10000) # put static data about the AGN (position, etc.) into the # variables_and_transients table for i_chunk, agn_results in enumerate(agn_iter): values = ((int(agn_results['uniqueId'][i_obj]), int(agn_results['galaxy_id'][i_obj]), np.degrees(agn_results['ra'][i_obj]), np.degrees(agn_results['dec'][i_obj]), int(agn_results['is_sprinkled'][i_obj]), 1,0) for i_obj in range(len(agn_results))) cursor.executemany('''INSERT INTO variables_and_transients VALUES (?,?,?,?,?,?,?)''', values) agn_simulator = AgnSimulator(agn_results['redshift']) quiescent_mag = np.zeros((len(agn_results), 6), dtype=float) for i_obj, (sed_name, zz, mm) in enumerate(zip(agn_results['sed'], agn_results['redshift'], agn_results['magnorm'])): spec = Sed() spec.readSED_flambda(os.path.join(sed_dir, sed_name)) fnorm = getImsimFluxNorm(spec, mm) spec.multiplyFluxNorm(fnorm) spec.redshiftSED(zz, dimming=True) mag_list = bp_dict.magListForSed(spec) quiescent_mag[i_obj] = mag_list # simulate AGN variability dmag = agn_simulator.applyVariability(agn_results['varParamStr'], expmjd=mjd_arr) # loop over pointings that overlap the current trixel, writing # out simulated photometry for each AGN observed in that pointing for i_time, obshistid in enumerate(obs_arr): # only include objects that were actually on a detector are_on_chip = _actually_on_chip(np.degrees(agn_results['ra']), np.degrees(agn_results['dec']), obsmd_dict[obshistid]) valid_agn = np.where(are_on_chip) if len(valid_agn[0])==0: continue values = ((int(agn_results['uniqueId'][i_obj]), int(obs_arr[i_time]), quiescent_mag[i_obj][filter_arr[i_time]]+ dmag[filter_arr[i_time]][i_obj][i_time]) for i_obj in valid_agn[0]) cursor.executemany('''INSERT INTO light_curves VALUES (?,?,?)''', values) conn.commit() n_floats += len(dmag.flatten()) sn_query = sn_base_query + 'AND htmid=%d' % htmid sn_iter = db.get_arbitrary_chunk_iterator(sn_query, dtype=sn_dtype, chunk_size=10000) for sn_results in sn_iter: t0_sne = time.time() # write static information about SNe to the # variables_and_transients table values = ((int(sn_results['uniqueId'][i_obj]), int(sn_results['galaxy_id'][i_obj]), np.degrees(sn_results['ra'][i_obj]), np.degrees(sn_results['dec'][i_obj]), int(sn_results['is_sprinkled'][i_obj]), 0,1) for i_obj in range(len(sn_results))) cursor.executemany('''INSERT INTO variables_and_transients VALUES (?,?,?,?,?,?,?)''', values) conn.commit() sn_mags = sn_simulator.calculate_sn_magnitudes(sn_results['sn_truth_params'], mjd_arr, filter_arr) print(' did %d sne in %e seconds' % (len(sn_results), time.time()-t0_sne)) # loop over pointings that overlap the current trixel, writing # out simulated photometry for each SNe observed in that pointing for i_time, obshistid in enumerate(obs_arr): # only include objects that fell on a detector are_on_chip = _actually_on_chip(np.degrees(sn_results['ra']), np.degrees(sn_results['dec']), obsmd_dict[obshistid]) valid_obj = np.where(np.logical_and(np.isfinite(sn_mags[:,i_time]), are_on_chip)) if len(valid_obj[0]) == 0: continue values = ((int(sn_results['uniqueId'][i_obj]), int(obs_arr[i_time]), sn_mags[i_obj][i_time]) for i_obj in valid_obj[0]) cursor.executemany('''INSERT INTO light_curves VALUES (?,?,?)''', values) conn.commit() n_floats += len(valid_obj[0]) cursor.execute('CREATE INDEX unq_obs ON light_curves (uniqueId, obshistid)') conn.commit() print('n_floats %d' % n_floats) print('in %e seconds' % (time.time()-t0_master))
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)
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)
# 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) # For next test: want to also do all the same steps, but in an optimized form. This means
max_offset = -1.0 sed_dir = os.environ['SIMS_SED_LIBRARY_DIR'] tot_bp_dict = BandpassDict.loadTotalBandpassesFromFiles() for ii in dexes_to_validate: disk_name = os.path.join(sed_dir, sed_names[disk_sed_idx[ii]].decode()) bulge_name = os.path.join(sed_dir, sed_names[bulge_sed_idx[ii]].decode()) for i_bp, bp in enumerate('ugrizy'): disk_s = Sed() disk_s.readSED_flambda(disk_name) fnorm = getImsimFluxNorm(disk_s, disk_magnorm[i_bp][ii]) disk_s.multiplyFluxNorm(fnorm) ax, bx = disk_s.setupCCM_ab() disk_s.addDust(ax, bx, A_v=disk_av[ii], R_v=disk_rv[ii]) disk_s.redshiftSED(control_qties['redshift'][ii], dimming=True) disk_f = disk_s.calcFlux(tot_bp_dict[bp]) bulge_s = Sed() bulge_s.readSED_flambda(bulge_name) fnorm = getImsimFluxNorm(bulge_s, bulge_magnorm[i_bp][ii]) bulge_s.multiplyFluxNorm(fnorm) ax, bx = bulge_s.setupCCM_ab() bulge_s.addDust(ax, bx, A_v=bulge_av[ii], R_v=bulge_rv[ii]) bulge_s.redshiftSED(control_qties['redshift'][ii], dimming=True) bulge_f = bulge_s.calcFlux(tot_bp_dict[bp]) tot_f = disk_f + bulge_f f_true = dummy_spec.fluxFromMag( control_qties['mag_true_%s_lsst' % bp][ii])
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 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 sprinkle(self): # Define a list that we can write out to a text file lenslines = [] # For each galaxy in the catsim catalog updated_catalog = self.catalog.copy() # print("Running sprinkler. Catalog Length: ", len(self.catalog)) for rowNum, row in enumerate(self.catalog): # if rowNum == 100 or rowNum % 100000==0: # print("Gone through ", rowNum, " lines of catalog.") if not np.isnan(row[self.defs_dict['galaxyAgn_magNorm']]): candidates = self.find_lens_candidates( row[self.defs_dict['galaxyAgn_redshift']], row[self.defs_dict['galaxyAgn_magNorm']]) #varString = json.loads(row[self.defs_dict['galaxyAgn_varParamStr']]) # varString[self.defs_dict['pars']]['t0_mjd'] = 59300.0 #row[self.defs_dict['galaxyAgn_varParamStr']] = json.dumps(varString) np.random.seed(row[self.defs_dict['galtileid']] % (2 ^ 32 - 1)) pick_value = np.random.uniform() # If there aren't any lensed sources at this redshift from OM10 move on the next object if (((len(candidates) > 0) and (pick_value <= self.density_param) and (self.cached_sprinkling is False)) | ((self.cached_sprinkling is True) and (row[self.defs_dict['galtileid']] in self.agn_cache['galtileid'].values))): # Randomly choose one the lens systems # (can decide with or without replacement) # Sort first to make sure the same choice is made every time if self.cached_sprinkling is True: twinkles_sys_cache = self.agn_cache.query( 'galtileid == %i' % row[self.defs_dict['galtileid']] )['twinkles_system'].values[0] newlens = self.lenscat[np.where( self.lenscat['twinklesId'] == twinkles_sys_cache) [0]][0] else: candidates = candidates[np.argsort( candidates['twinklesId'])] newlens = np.random.choice(candidates) # Append the lens galaxy # For each image, append the lens images for i in range(newlens['NIMG']): lensrow = row.copy() # XIMG and YIMG are in arcseconds # raPhSim and decPhoSim are in radians #Shift all parts of the lensed object, not just its agn part for lensPart in [ 'galaxyBulge', 'galaxyDisk', 'galaxyAgn' ]: lens_ra = lensrow[self.defs_dict[str(lensPart + '_raJ2000')]] lens_dec = lensrow[self.defs_dict[str( lensPart + '_decJ2000')]] delta_ra = np.radians( newlens['XIMG'][i] / 3600.0) / np.cos(lens_dec) delta_dec = np.radians(newlens['YIMG'][i] / 3600.0) lensrow[self.defs_dict[str( lensPart + '_raJ2000')]] = lens_ra + delta_ra lensrow[self.defs_dict[ str(lensPart + '_decJ2000')]] = lens_dec + delta_dec mag_adjust = 2.5 * np.log10(np.abs(newlens['MAG'][i])) lensrow[ self.defs_dict['galaxyAgn_magNorm']] -= mag_adjust varString = json.loads( lensrow[self.defs_dict['galaxyAgn_varParamStr']]) varString[self.defs_dict['pars']]['t0Delay'] = newlens[ 'DELAY'][i] varString[self.defs_dict[ 'varMethodName']] = 'applyAgnTimeDelay' lensrow[self.defs_dict[ 'galaxyAgn_varParamStr']] = json.dumps(varString) lensrow[self.defs_dict['galaxyDisk_majorAxis']] = 0.0 lensrow[self.defs_dict['galaxyDisk_minorAxis']] = 0.0 lensrow[ self.defs_dict['galaxyDisk_positionAngle']] = 0.0 lensrow[self.defs_dict['galaxyDisk_internalAv']] = 0.0 lensrow[self.defs_dict[ 'galaxyDisk_magNorm']] = 999. #np.nan To be fixed post run1.1 lensrow[ self.defs_dict['galaxyDisk_sedFilename']] = None lensrow[self.defs_dict['galaxyBulge_majorAxis']] = 0.0 lensrow[self.defs_dict['galaxyBulge_minorAxis']] = 0.0 lensrow[ self.defs_dict['galaxyBulge_positionAngle']] = 0.0 lensrow[self.defs_dict['galaxyBulge_internalAv']] = 0.0 lensrow[self.defs_dict[ 'galaxyBulge_magNorm']] = 999. #np.nan To be fixed post run1.1 lensrow[ self.defs_dict['galaxyBulge_sedFilename']] = None lensrow[self.defs_dict[ 'galaxyBulge_redshift']] = newlens['ZSRC'] lensrow[self.defs_dict[ 'galaxyDisk_redshift']] = newlens['ZSRC'] lensrow[self.defs_dict[ 'galaxyAgn_redshift']] = newlens['ZSRC'] #To get back twinklesID in lens catalog from phosim catalog id number #just use np.right_shift(phosimID-28, 10). Take the floor of the last #3 numbers to get twinklesID in the twinkles lens catalog and the remainder is #the image number minus 1. lensrow[self.defs_dict['galtileid']] = ( lensrow[self.defs_dict['galtileid']] * 10000 + newlens['twinklesId'] * 4 + i) updated_catalog = np.append(updated_catalog, lensrow) #Now manipulate original entry to be the lens galaxy with desired properties #Start by deleting Disk and AGN properties if not np.isnan(row[self.defs_dict['galaxyDisk_magNorm']]): row[self.defs_dict['galaxyDisk_majorAxis']] = 0.0 row[self.defs_dict['galaxyDisk_minorAxis']] = 0.0 row[self.defs_dict['galaxyDisk_positionAngle']] = 0.0 row[self.defs_dict['galaxyDisk_internalAv']] = 0.0 row[self.defs_dict[ 'galaxyDisk_magNorm']] = 999. #np.nan To be fixed post run1.1 row[self.defs_dict['galaxyDisk_sedFilename']] = None row[self.defs_dict[ 'galaxyAgn_magNorm']] = None #np.nan To be fixed post run1.1 row[self.defs_dict[ 'galaxyDisk_magNorm']] = 999. # To be fixed in run1.1 row[self.defs_dict['galaxyAgn_sedFilename']] = None #Now insert desired Bulge properties row[self.defs_dict['galaxyBulge_sedFilename']] = newlens[ 'lens_sed'] row[self. defs_dict['galaxyBulge_redshift']] = newlens['ZLENS'] row[self. defs_dict['galaxyDisk_redshift']] = newlens['ZLENS'] row[self. defs_dict['galaxyAgn_redshift']] = newlens['ZLENS'] row_lens_sed = Sed() row_lens_sed.readSED_flambda( str(self.galDir + newlens['lens_sed'])) row_lens_sed.redshiftSED(newlens['ZLENS'], dimming=True) row[self.defs_dict['galaxyBulge_magNorm']] = matchBase( ).calcMagNorm( [newlens['APMAG_I']], row_lens_sed, self.bandpassDict) #Changed from i band to imsimband row[self.defs_dict[ 'galaxyBulge_majorAxis']] = radiansFromArcsec( newlens['REFF'] / np.sqrt(1 - newlens['ELLIP'])) row[self.defs_dict[ 'galaxyBulge_minorAxis']] = radiansFromArcsec( newlens['REFF'] * np.sqrt(1 - newlens['ELLIP'])) #Convert orientation angle to west of north from east of north by *-1.0 and convert to radians row[self.defs_dict['galaxyBulge_positionAngle']] = newlens[ 'PHIE'] * (-1.0) * np.pi / 180.0 #Replace original entry with new entry updated_catalog[rowNum] = row else: if self.cached_sprinkling is True: if row[self.defs_dict['galtileid']] in self.sne_cache[ 'galtileid'].values: use_system = self.sne_cache.query( 'galtileid == %i' % row[self.defs_dict['galtileid']] )['twinkles_system'].values use_df = self.sne_catalog.query( 'twinkles_sysno == %i' % use_system) self.used_systems.append(use_system) else: continue else: lens_sne_candidates = self.find_sne_lens_candidates( row[self.defs_dict['galaxyDisk_redshift']]) candidate_sysno = np.unique( lens_sne_candidates['twinkles_sysno']) num_candidates = len(candidate_sysno) if num_candidates == 0: continue used_already = np.array([ sys_num in self.used_systems for sys_num in candidate_sysno ]) unused_sysno = candidate_sysno[~used_already] if len(unused_sysno) == 0: continue np.random.seed(row[self.defs_dict['galtileid']] % (2 ^ 32 - 1)) use_system = np.random.choice(unused_sysno) use_df = self.sne_catalog.query('twinkles_sysno == %i' % use_system) for i in range(len(use_df)): lensrow = row.copy() for lensPart in ['galaxyBulge', 'galaxyDisk', 'galaxyAgn']: lens_ra = lensrow[self.defs_dict[str(lensPart + '_raJ2000')]] lens_dec = lensrow[self.defs_dict[str(lensPart + '_decJ2000')]] delta_ra = np.radians( use_df['x'].iloc[i] / 3600.0) / np.cos(lens_dec) delta_dec = np.radians(use_df['y'].iloc[i] / 3600.0) lensrow[self.defs_dict[str( lensPart + '_raJ2000')]] = lens_ra + delta_ra lensrow[self.defs_dict[str( lensPart + '_decJ2000')]] = lens_dec + delta_dec # varString = json.loads(lensrow[self.defs_dict['galaxyAgn_varParamStr']]) varString = 'None' lensrow[ self.defs_dict['galaxyAgn_varParamStr']] = varString lensrow[self.defs_dict['galaxyDisk_majorAxis']] = 0.0 lensrow[self.defs_dict['galaxyDisk_minorAxis']] = 0.0 lensrow[self.defs_dict['galaxyDisk_positionAngle']] = 0.0 lensrow[self.defs_dict['galaxyDisk_internalAv']] = 0.0 lensrow[self.defs_dict[ 'galaxyDisk_magNorm']] = 999. #np.nan To be fixed post run1.1 lensrow[self.defs_dict['galaxyDisk_sedFilename']] = None lensrow[self.defs_dict['galaxyBulge_majorAxis']] = 0.0 lensrow[self.defs_dict['galaxyBulge_minorAxis']] = 0.0 lensrow[self.defs_dict['galaxyBulge_positionAngle']] = 0.0 lensrow[self.defs_dict['galaxyBulge_internalAv']] = 0.0 lensrow[self.defs_dict[ 'galaxyBulge_magNorm']] = 999. #np.nan To be fixed post run1.1 lensrow[self.defs_dict['galaxyBulge_sedFilename']] = None z_s = use_df['zs'].iloc[i] lensrow[self.defs_dict['galaxyBulge_redshift']] = z_s lensrow[self.defs_dict['galaxyDisk_redshift']] = z_s lensrow[self.defs_dict['galaxyAgn_redshift']] = z_s #To get back twinklesID in lens catalog from phosim catalog id number #just use np.right_shift(phosimID-28, 10). Take the floor of the last #3 numbers to get twinklesID in the twinkles lens catalog and the remainder is #the image number minus 1. lensrow[self.defs_dict['galtileid']] = ( lensrow[self.defs_dict['galtileid']] * 10000 + use_system * 4 + i) add_to_cat, sn_magnorm, sn_fname = self.create_sn_sed( use_df.iloc[i], lensrow[self.defs_dict['galaxyAgn_raJ2000']], lensrow[self.defs_dict['galaxyAgn_decJ2000']], self.visit_mjd) lensrow[self.defs_dict['galaxyAgn_sedFilename']] = sn_fname lensrow[self.defs_dict[ 'galaxyAgn_magNorm']] = sn_magnorm #This will need to be adjusted to proper band mag_adjust = 2.5 * np.log10(np.abs(use_df['mu'].iloc[i])) lensrow[self.defs_dict['galaxyAgn_magNorm']] -= mag_adjust if add_to_cat is True: updated_catalog = np.append(updated_catalog, lensrow) else: continue #Now manipulate original entry to be the lens galaxy with desired properties #Start by deleting Disk and AGN properties if not np.isnan(row[self.defs_dict['galaxyDisk_magNorm']]): row[self.defs_dict['galaxyDisk_majorAxis']] = 0.0 row[self.defs_dict['galaxyDisk_minorAxis']] = 0.0 row[self.defs_dict['galaxyDisk_positionAngle']] = 0.0 row[self.defs_dict['galaxyDisk_internalAv']] = 0.0 row[self.defs_dict[ 'galaxyDisk_magNorm']] = 999. #np.nan To be fixed post run1.1 row[self.defs_dict['galaxyDisk_sedFilename']] = None row[self.defs_dict[ 'galaxyAgn_magNorm']] = None #np.nan To be fixed post run1.1 row[self.defs_dict[ 'galaxyDisk_magNorm']] = 999. #To be fixed post run1.1 row[self.defs_dict['galaxyAgn_sedFilename']] = None #Now insert desired Bulge properties row[self.defs_dict['galaxyBulge_sedFilename']] = use_df[ 'lens_sed'].iloc[0] row[self. defs_dict['galaxyBulge_redshift']] = use_df['zl'].iloc[0] row[self. defs_dict['galaxyDisk_redshift']] = use_df['zl'].iloc[0] row[self. defs_dict['galaxyAgn_redshift']] = use_df['zl'].iloc[0] row[self.defs_dict['galaxyBulge_magNorm']] = use_df[ 'bulge_magnorm'].iloc[0] # row[self.defs_dict['galaxyBulge_magNorm']] = matchBase().calcMagNorm([newlens['APMAG_I']], self.LRG, self.bandpassDict) #Changed from i band to imsimband row[self. defs_dict['galaxyBulge_majorAxis']] = radiansFromArcsec( use_df['r_eff'].iloc[0] / np.sqrt(1 - use_df['e'].iloc[0])) row[self. defs_dict['galaxyBulge_minorAxis']] = radiansFromArcsec( use_df['r_eff'].iloc[0] * np.sqrt(1 - use_df['e'].iloc[0])) #Convert orientation angle to west of north from east of north by *-1.0 and convert to radians row[self.defs_dict['galaxyBulge_positionAngle']] = use_df[ 'theta_e'].iloc[0] * (-1.0) * np.pi / 180.0 #Replace original entry with new entry updated_catalog[rowNum] = row return updated_catalog
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 "" # There is more functionality in the class. Please see the code.
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 applyIGM(self, redshift, sedobj): """ Apply IGM extinction to already redshifted sed with redshift between zMin and zMax defined by range of lookup tables @param [in] redshift is the redshift of the incoming SED object @param [in] sedobj is the SED object to which IGM extinction will be applied. This object will be modified as a result of this. """ if self.IGMisInitialized == False: self.initializeIGM() #First make sure redshift is in range of lookup tables. if (redshift < self.zMin) or (redshift > self.zMax): warnings.warn(str("IGM Lookup tables only applicable for " + str(self.zMin) + " < z < " + str(self.zMax) + ". No action taken")) return #Now read in closest two lookup tables for given redshift lowerSed = Sed() upperSed = Sed() for lower, upper in zip(self.zRange[:-1], self.zRange[1:]): if lower <= redshift <= upper: lowerSed.setSED(self.meanLookups['%.1f' % lower][:,0], flambda = self.meanLookups['%.1f' % lower][:,1]) upperSed.setSED(self.meanLookups['%.1f' % upper][:,0], flambda = self.meanLookups['%.1f' % lower][:,1]) break #Redshift lookup tables to redshift of source, i.e. if source redshift is 1.78 shift lookup #table for 1.7 and lookup table for 1.8 to up and down to 1.78, respectively zLowerShift = ((1.0 + redshift)/(1.0 + lower)) - 1.0 zUpperShift = ((1.0 + redshift)/(1.0 + upper)) - 1.0 lowerSed.redshiftSED(zLowerShift) upperSed.redshiftSED(zUpperShift) #Resample lower and upper transmission data onto same wavelength grid. minWavelen = 300. #All lookup tables are usable above 300nm maxWavelen = np.amin([lowerSed.wavelen[-1], upperSed.wavelen[-1]]) - 0.01 lowerSed.resampleSED(wavelen_min = minWavelen, wavelen_max = maxWavelen, wavelen_step = 0.01) upperSed.resampleSED(wavelen_match = lowerSed.wavelen) #Now insert this into a transmission array of 1.0 beyond the limits of current application #So that we can get an sed back that extends to the longest wavelengths of the incoming sed finalWavelen = np.arange(300., sedobj.wavelen[-1]+0.01, 0.01) finalFlambdaExtended = np.ones(len(finalWavelen)) #Weighted Average of Transmission from each lookup table to get final transmission #table at desired redshift dzGrid = self.zDelta #Step in redshift between transmission lookup table files finalSed = Sed() finalFlambda = (lowerSed.flambda*(1.0 - ((redshift - lower)/dzGrid)) + upperSed.flambda*(1.0 - ((upper - redshift)/dzGrid))) finalFlambdaExtended[0:len(finalFlambda)] = finalFlambda finalSed.setSED(wavelen = finalWavelen, flambda = finalFlambdaExtended) #Resample incoming sed to new grid so that we don't get warnings from multiplySED #about matching wavelength grids sedobj.resampleSED(wavelen_match=finalSed.wavelen) #Now multiply transmission curve by input SED to get final result and make it the new flambda #data in the original sed which also is now on a new grid starting at 300 nm test = sedobj.multiplySED(finalSed) sedobj.flambda = test.flambda
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, fileDir=self.sedDir, 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.setupCCM_ab() sedControl.addDust(a_coeff, b_coeff, A_v=iav) sedControl.redshiftSED(zz, dimming=True) sedControl.resampleSED(wavelen_match=wavelen_match) a_coeff, b_coeff = sedControl.setupCCM_ab() sedControl.addDust(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.setupCCM_ab() sedControl.addDust(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.setupCCM_ab() sedControl.addDust(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)
from lsst.sims.photUtils import PhotometricParameters, Bandpass phot_params = PhotometricParameters(nexp=1, exptime=30.0, gain=1) imsim = Bandpass() imsim.imsimBandpass() target=20000.0 for name in galaxy_sed_list: magnorm_interp[name] = {} magnorm_interp[name]['z'] = np.arange(0.0, 2.4, 0.2) magnorm_interp[name]['mag'] = np.zeros(len(magnorm_interp[name]['z']), dtype=float) for i_zz, zz in enumerate(magnorm_interp[name]['z']): ss = Sed() ss.readSED_flambda(os.path.join(galaxy_dir, name)) mag = ss.calcMag(imsim) ss.redshiftSED(zz, dimming=True) cts = ss.calcADU(bp_dict['r'], photParams=phot_params) magnorm = mag -2.5*np.log10(target/cts) ss = Sed() ss.readSED_flambda(os.path.join(galaxy_dir, name)) fnorm = ss.calcFluxNorm(magnorm, imsim) ss.multiplyFluxNorm(fnorm) ss.redshiftSED(zz, dimming=True) new_cts = ss.calcADU(bp_dict['r'], photParams=phot_params) d_ct = np.abs(new_cts-target) magnorm_interp[name]['mag'][i_zz] = magnorm if d_ct>500.0: raise RuntimeWarning('d_ct %e' % d_ct)
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, fileDir=self.sedDir, 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.setupCCM_ab() sedControl.addDust(a_coeff, b_coeff, A_v=iav) sedControl.redshiftSED(zz, dimming=True) sedControl.resampleSED(wavelen_match=wavelen_match) a_coeff, b_coeff = sedControl.setupCCM_ab() sedControl.addDust(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.setupCCM_ab() sedControl.addDust(a_coeff, b_coeff, A_v=iav) sedControl.redshiftSED(zz, dimming=True) sedControl.resampleSED(wavelen_match=wavelen_match) a_coeff, b_coeff = sedControl.setupCCM_ab() sedControl.addDust(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 __init__(self, catsim_cat, visit_mjd, specFileMap, sed_path, om10_cat='twinkles_lenses_v2.fits', sne_cat='dc2_sne_cat.csv', density_param=1., cached_sprinkling=False, agn_cache_file=None, sne_cache_file=None, defs_file=None): """ Parameters ---------- catsim_cat: catsim catalog The results array from an instance catalog. visit_mjd: float The mjd of the visit specFileMap: This will tell the instance catalog where to write the files om10_cat: optional, defaults to 'twinkles_lenses_v2.fits fits file with OM10 catalog sne_cat: optional, defaults to 'dc2_sne_cat.csv' density_param: `np.float`, optioanl, defaults to 1.0 the fraction of eligible agn objects that become lensed and should be between 0.0 and 1.0. cached_sprinkling: boolean If true then pick from a preselected list of galtileids agn_cache_file: str sne_cache_file: str defs_file: str Returns ------- updated_catalog: A new results array with lens systems added. """ twinklesDir = getPackageDir('Twinkles') om10_cat = os.path.join(twinklesDir, 'data', om10_cat) self.catalog = catsim_cat # ****** THIS ASSUMES THAT THE ENVIRONMENT VARIABLE OM10_DIR IS SET ******* lensdb = om10.DB(catalog=om10_cat, vb=False) self.lenscat = lensdb.lenses.copy() self.density_param = density_param self.bandpassDict = BandpassDict.loadTotalBandpassesFromFiles( bandpassNames=['i']) self.sne_catalog = pd.read_csv( os.path.join(twinklesDir, 'data', sne_cat)) #self.sne_catalog = self.sne_catalog.iloc[:101] ### Remove this after testing self.used_systems = [] self.visit_mjd = visit_mjd self.sn_obj = SNObject(0., 0.) self.write_dir = specFileMap.subdir_map['(^specFileGLSN)'] self.sed_path = sed_path self.cached_sprinkling = cached_sprinkling if self.cached_sprinkling is True: if ((agn_cache_file is None) | (sne_cache_file is None)): raise AttributeError( 'Must specify cache files if using cached_sprinkling.') #agn_cache_file = os.path.join(twinklesDir, 'data', 'test_agn_galtile_cache.csv') self.agn_cache = pd.read_csv(agn_cache_file) #sne_cache_file = os.path.join(twinklesDir, 'data', 'test_sne_galtile_cache.csv') self.sne_cache = pd.read_csv(sne_cache_file) else: self.agn_cache = None self.sne_cache = None if defs_file is None: self.defs_file = os.path.join(twinklesDir, 'data', 'catsim_defs.csv') else: self.defs_file = defs_file specFileStart = 'Burst' for key, val in sorted(iteritems(SpecMap.subdir_map)): if re.match(key, specFileStart): galSpecDir = str(val) self.galDir = str( getPackageDir('sims_sed_library') + '/' + galSpecDir + '/') self.imSimBand = Bandpass() self.imSimBand.imsimBandpass() #self.LRG_name = 'Burst.25E09.1Z.spec' #self.LRG = Sed() #self.LRG.readSED_flambda(str(galDir + self.LRG_name)) #return #Calculate imsimband magnitudes of source galaxies for matching agn_fname = str( getPackageDir('sims_sed_library') + '/agnSED/agn.spec.gz') src_iband = self.lenscat['MAGI_IN'] src_z = self.lenscat['ZSRC'] self.src_mag_norm = [] for src, s_z in zip(src_iband, src_z): agn_sed = Sed() agn_sed.readSED_flambda(agn_fname) agn_sed.redshiftSED(s_z, dimming=True) self.src_mag_norm.append(matchBase().calcMagNorm( [src], agn_sed, self.bandpassDict)) #self.src_mag_norm = matchBase().calcMagNorm(src_iband, # [agn_sed]*len(src_iband), # # self.bandpassDict) self.defs_dict = {} with open(self.defs_file, 'r') as f: for line in f: line_defs = line.split(',') if len(line_defs) > 1: self.defs_dict[line_defs[0]] = line_defs[1].split('\n')[0]
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 applyIGM(self, redshift, sedobj): """ Apply IGM extinction to already redshifted sed with redshift between zMin and zMax defined by range of lookup tables @param [in] redshift is the redshift of the incoming SED object @param [in] sedobj is the SED object to which IGM extinction will be applied. This object will be modified as a result of this. """ if self.IGMisInitialized == False: self.initializeIGM() #First make sure redshift is in range of lookup tables. if (redshift < self.zMin) or (redshift > self.zMax): warnings.warn( str("IGM Lookup tables only applicable for " + str(self.zMin) + " < z < " + str(self.zMax) + ". No action taken")) return #Now read in closest two lookup tables for given redshift lowerSed = Sed() upperSed = Sed() for lower, upper in zip(self.zRange[:-1], self.zRange[1:]): if lower <= redshift <= upper: lowerSed.setSED(self.meanLookups['%.1f' % lower][:, 0], flambda=self.meanLookups['%.1f' % lower][:, 1]) upperSed.setSED(self.meanLookups['%.1f' % upper][:, 0], flambda=self.meanLookups['%.1f' % lower][:, 1]) break #Redshift lookup tables to redshift of source, i.e. if source redshift is 1.78 shift lookup #table for 1.7 and lookup table for 1.8 to up and down to 1.78, respectively zLowerShift = ((1.0 + redshift) / (1.0 + lower)) - 1.0 zUpperShift = ((1.0 + redshift) / (1.0 + upper)) - 1.0 lowerSed.redshiftSED(zLowerShift) upperSed.redshiftSED(zUpperShift) #Resample lower and upper transmission data onto same wavelength grid. minWavelen = 300. #All lookup tables are usable above 300nm maxWavelen = np.amin([lowerSed.wavelen[-1], upperSed.wavelen[-1] ]) - 0.01 lowerSed.resampleSED(wavelen_min=minWavelen, wavelen_max=maxWavelen, wavelen_step=0.01) upperSed.resampleSED(wavelen_match=lowerSed.wavelen) #Now insert this into a transmission array of 1.0 beyond the limits of current application #So that we can get an sed back that extends to the longest wavelengths of the incoming sed finalWavelen = np.arange(300., sedobj.wavelen[-1] + 0.01, 0.01) finalFlambdaExtended = np.ones(len(finalWavelen)) #Weighted Average of Transmission from each lookup table to get final transmission #table at desired redshift dzGrid = self.zDelta #Step in redshift between transmission lookup table files finalSed = Sed() finalFlambda = (lowerSed.flambda * (1.0 - ((redshift - lower) / dzGrid)) + upperSed.flambda * (1.0 - ((upper - redshift) / dzGrid))) finalFlambdaExtended[0:len(finalFlambda)] = finalFlambda finalSed.setSED(wavelen=finalWavelen, flambda=finalFlambdaExtended) #Resample incoming sed to new grid so that we don't get warnings from multiplySED #about matching wavelength grids sedobj.resampleSED(wavelen_match=finalSed.wavelen) #Now multiply transmission curve by input SED to get final result and make it the new flambda #data in the original sed which also is now on a new grid starting at 300 nm test = sedobj.multiplySED(finalSed) sedobj.flambda = test.flambda
def run_lsst_baker(redshift_grid): """ Accepts a redshift grid (a numpy array). Reads in all of the SEDs from ../data/sed/ and the calculates their colors in all of the lsst bands, given those redshifts Returns a structured numpy array containing sedname redshift ug gr ri iz zy time (the time spent calculating the magnitudes) """ bandpass_dir = os.path.join('..', 'data', 'bandpass') bandpass_list = [] for bp_name in ('total_u.dat', 'total_g.dat', 'total_r.dat', 'total_i.dat', 'total_z.dat', 'total_y.dat'): bp = Bandpass() bp.readThroughput(os.path.join(bandpass_dir, bp_name)) bandpass_list.append(bp) sed_dir = os.path.join('..', 'data', 'sed') list_of_sed_names = sorted([nn for nn in os.listdir(sed_dir) if 'spec' in nn and 'ang' not in nn]) n_rows = len(list_of_sed_names)*len(redshift_grid) dtype = np.dtype([('sedname', str, 300), ('redshift', np.float), ('ug', np.float), ('gr', np.float), ('ri', np.float), ('iz', np.float), ('zy', np.float), ('time', np.float)]) dummy = ('aaaa', 1.0, 1, 1, 1, 1, 1, 1.0) output_array = np.array([dummy]*n_rows, dtype=dtype) i_row = 0 for redshift in redshift_grid: for sed_name in list_of_sed_names: ss = Sed() # t_start = time.clock() t_start = time.time() ss.readSED_flambda(os.path.join(sed_dir, sed_name)) ss.redshiftSED(redshift) local_list = [] for bp in bandpass_list: mm = ss.calcMag(bp) local_list.append(mm) #print local_list[0], local_list[1], local_list[0]-local_list[1] # time_spent = time.clock()-t_start time_spent = time.time()-t_start output_array[i_row][0] = sed_name output_array[i_row][1] = redshift output_array[i_row][2] = local_list[0]-local_list[1] output_array[i_row][3] = local_list[1]-local_list[2] output_array[i_row][4] = local_list[2]-local_list[3] output_array[i_row][5] = local_list[3]-local_list[4] output_array[i_row][6] = local_list[4]-local_list[5] output_array[i_row][7] = time_spent i_row += 1 return output_array
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
def process_instance_catalog(catalog_name, centroid_dir, bp_dict): sed_dir = getPackageDir('sims_sed_library') i_filter = -1 obshistid = -1 with open(catalog_name, 'r') as in_file: for line in in_file: params = line.strip().split() if params[0] == 'filter': i_filter = int(params[1]) if params[0] == 'obshistid': obshistid = int(params[1]) if i_filter >= 0 and obshistid >= 0: break filter_name = 'ugrizy'[i_filter] bp = bp_dict[filter_name] objid_arr = [] flux_arr = [] redshift_arr = [] magnorm_arr = [] phot_params = PhotometricParameters(nexp=1, exptime=30.0, gain=1.0) with open(catalog_name, 'r') as in_file: for line in in_file: params = line.strip().split() if params[0] != 'object': continue sed_name = params[5] obj_id = int(params[1]) magnorm = float(params[4]) redshift = float(params[6]) spec = Sed() spec.readSED_flambda(os.path.join(sed_dir, sed_name)) fnorm = getImsimFluxNorm(spec, magnorm) spec.multiplyFluxNorm(fnorm) spec.redshiftSED(redshift, dimming=True) adu = spec.calcADU(bp, photParams=phot_params) objid_arr.append(obj_id) flux_arr.append(adu) redshift_arr.append(redshift) magnorm_arr.append(magnorm) centroid_files = os.listdir(centroid_dir) phosim_objid_arr = [] phosim_flux_arr = [] x_arr = [] y_arr = [] chip_name_arr = [] dtype = np.dtype([('id', int), ('phot', float), ('x', float), ('y', float)]) for file_name in centroid_files: if 'e_%d' % obshistid not in file_name or 'f%d' % i_filter not in file_name: continue name_params = file_name.split('_') raft = name_params[5] sensor = name_params[6] chip_name = '%s:%s,%s %s:%s,%s' % (raft[0], raft[1], raft[2], sensor[0], sensor[1], sensor[2]) full_name = os.path.join(centroid_dir, file_name) data = np.genfromtxt(full_name, dtype=dtype, skip_header=1) for line in data: phosim_objid_arr.append(line['id']) phosim_flux_arr.append(line['phot']) x_arr.append(line['x']) y_arr.append(line['y']) chip_name_arr.append(chip_name) objid_arr = np.array(objid_arr) flux_arr = np.array(flux_arr) redshift_arr = np.array(redshift_arr) magnorm_arr = np.array(magnorm_arr) phosim_objid_arr = np.array(phosim_objid_arr) phosim_flux_arr = np.array(phosim_flux_arr) x_arr = np.array(x_arr) y_arr = np.array(y_arr) chip_name_arr = np.array(chip_name_arr) sorted_dex = np.argsort(objid_arr) objid_arr = objid_arr[sorted_dex] flux_arr = flux_arr[sorted_dex] redshift_arr = redshift_arr[sorted_dex] magnorm_arr = magnorm_arr[sorted_dex] sorted_dex = np.argsort(phosim_objid_arr) phosim_objid_arr = phosim_objid_arr[sorted_dex] phosim_flux_arr = phosim_flux_arr[sorted_dex] x_arr = x_arr[sorted_dex] y_arr = y_arr[sorted_dex] chip_name_arr = chip_name_arr[sorted_dex] np.testing.assert_array_equal(phosim_objid_arr, objid_arr) return (objid_arr, flux_arr, phosim_flux_arr, redshift_arr, magnorm_arr, x_arr, y_arr, chip_name_arr, filter_name)
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, fileDir=self.sedDir, 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, fileDir=self.sedDir, 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.setupCCM_ab() sedControl.addDust(a_coeff, b_coeff, A_v=iav) sedControl.redshiftSED(zz, dimming=True) sedControl.resampleSED(wavelen_match=wavelen_match) a_coeff, b_coeff = sedControl.setupCCM_ab() sedControl.addDust(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.setupCCM_ab() sedControl.addDust(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.setupCCM_ab() sedControl.addDust(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)
out_name = os.path.join( out_dir, 'instcat_galaxy_grid_%.1f_%d.txt' % (redshift, i_filter)) with open(out_name, 'w') as instcat_handle: phosim_header['obshistid'] = i_filter * 100 + int( redshift / 0.1) + 1 write_phoSim_header(obs, instcat_handle, phosim_header) for ii, (rr, dd) in enumerate(zip(ra, dec)): unqid = ii + 1 instcat_handle.write('object %d ' % unqid) instcat_handle.write('%.17f %.17f %.6f ' % (rr, dd, magnorm)) instcat_handle.write('galaxySED/%s ' % sed_names[ii]) instcat_handle.write( '%1.f 0 0 0 0 0 point none none\n' % redshift) if i_filter == 0: ss = Sed() ss.readSED_flambda( os.path.join(galaxy_dir, sed_names[ii])) fnorm = ss.calcFluxNorm(magnorm, imsim) ss.multiplyFluxNorm(fnorm) ss.redshiftSED(redshift, dimming=True) ref_handle.write('%d %.17f %.17f ' % (unqid, rr, dd)) for bp in bp_dict: adu = ss.calcADU(bp_dict[bp], photParams=phot_params) ref_handle.write('%e ' % adu) ref_handle.write('\n')
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, fileDir=self.sedDir, 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.setupCCM_ab() sedControl.addDust(a_coeff, b_coeff, A_v=iav) sedControl.redshiftSED(zz, dimming=True) sedControl.resampleSED(wavelen_match=wavelen_match) a_coeff, b_coeff = sedControl.setupCCM_ab() sedControl.addDust(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.setupCCM_ab() sedControl.addDust(a_coeff, b_coeff, A_v=iav) sedControl.redshiftSED(zz, dimming=True) sedControl.resampleSED(wavelen_match=wavelen_match) a_coeff, b_coeff = sedControl.setupCCM_ab() sedControl.addDust(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 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 = self.rng.random_sample(nSed)*5.0 + 15.0 testList = SedList(sedNameList, magNormList, fileDir=self.sedDir) 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, fileDir=self.sedDir, 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.setupCCM_ab() sedControl.addDust(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, fileDir=self.sedDir, 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.setupCCM_ab() sedControl.addDust(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, fileDir=self.sedDir, 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.setupCCM_ab() sedControl.addDust(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, fileDir=self.sedDir, 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.setupCCM_ab() sedControl.addDust(a_coeff, b_coeff, A_v=av) sedControl.redshiftSED(zz, dimming=True) a_coeff, b_coeff = sedControl.setupCCM_ab() sedControl.addDust(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, fileDir=self.sedDir, 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.setupCCM_ab() sedControl.addDust(a_coeff, b_coeff, A_v=av) sedControl.redshiftSED(zz, dimming=True) sedControl.resampleSED(wavelen_match=wavelen_match) a_coeff, b_coeff = sedControl.setupCCM_ab() sedControl.addDust(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)
# 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) # For next test: want to also do all the same steps, but in an optimized form. This means