def calc_dict(reddenings):
EBmV_dict = {} # { 0.0 : [u-g, g-r, r-i], ... }
for EBmV in reddenings:
spectrum = S.ArraySpectrum(np.array(wl), np.array(flx), 'angstrom',
'flam')
spectrum = spectrum * S.Extinction(EBmV, 'mwavg')
#calculate colours
obs_u = S.Observation(spectrum, u_bp)
obs_g = S.Observation(spectrum, g_bp)
obs_r = S.Observation(spectrum, r_bp)
obs_i = S.Observation(spectrum, i_bp)
u_min_g = obs_u.effstim(magsystem) - obs_g.effstim(magsystem)
g_min_r = obs_g.effstim(magsystem) - obs_r.effstim(magsystem)
r_min_i = obs_r.effstim(magsystem) - obs_i.effstim(magsystem)
#Add EBmV and colours to the dictionary
colours = [u_min_g, g_min_r, r_min_i]
EBmV_dict[EBmV] = colours
return EBmV_dict
def chi2(self, bands, mags, magerrs, fit='flux'):
"""
Calculate the total chi-square for self.spec given a list of bands
(pysynphot SpectralElement instances) and magnitudes and errors.
"""
if fit == 'mag':
mags = np.array(mags)
magerrs = np.array(magerrs)
mags_spec = [
S.Observation(self.rspec, b).effstim('abmag') for b in bands
]
mags_spec = np.array(mags_spec)
# chi2 = ((mags_spec - mags)**2 / mags_spec)
chi2 = (((mags_spec - mags) / magerrs)**2).sum()
if self.verbose:
print mags_spec, self.beta, self.A, chi2
elif fit == 'flux':
fluxes = np.array([pu.ABmag2uJy(m)
for m in mags]) # in micro-Jansky
sn = [pu.magerr2sn(m) for m in magerrs]
fluxerrs = fluxes / sn # to get flux errors from S/N
# Now sample the reference spectrum at the central wavelengths
self.rspec.convert('muJy') # convert to micro-Jansky
# flux_spec = [self.rspec.sample(b.pivot()) for b in bands]
flux_spec = [
S.Observation(self.rspec, b).effstim('muJy') for b in bands
]
flux_spec = np.array(flux_spec) # convert to micro-Jansky
chi2 = (((flux_spec - fluxes) / fluxerrs)**2).sum()
self.rspec.convert('flam') # go back to flam
return chi2
def get_magnitudes(Teff, FeH=0.0, logg=4.5, Vmag=10, magScale='vegamag'):
# Load the Filters
bp_j = S.ObsBandpass('j')
bp_h = S.ObsBandpass('h')
bp_k = S.ObsBandpass('k')
bp_v = S.ObsBandpass('johnson,v')
# Stellar spectrum normalized to V=10 mags (default Phoenix models)
sp = S.Icat(
'phoenix', Teff, FeH,
logg) #pynrc.stellar_spectrum(stellarType, Vmag, 'vegamag', bp_v)
sp_norm = sp.renorm(Vmag, magScale, bp_v)
sp_norm.name = sp.name
sp = sp_norm
# Observe in J, H, and K
obs_j = S.Observation(sp, bp_j, binset=sp.wave)
obs_h = S.Observation(sp, bp_h, binset=sp.wave)
obs_k = S.Observation(sp, bp_k, binset=sp.wave)
# Magnitudes in each filter
mag_j = obs_j.effstim(magScale)
mag_h = obs_h.effstim(magScale)
mag_k = obs_k.effstim(magScale)
return mag_j, mag_h, mag_k
def synphotSNR(filtname,
mag,
etime=1200,
nexp=4,
aperture=0.4,
pixscale=0.128):
import pysynphot as syn
from numpy import pi, sqrt
bandpass = syn.ObsBandpass('wfc3,ir,%s,aper#%.1f' % (filtname, aperture))
sn1a = syn.FileSpectrum('sn1a_flux_max.dat').redshift(1.5).renorm(
mag, 'abmag', bandpass)
sourcecps = syn.Observation(sn1a, bandpass).countrate()
srccounts = sourcecps * etime
skybandpass = syn.ObsBandpass('wfc3,ir,%s' % filtname)
earthshine = syn.FileSpectrum('earthshine_average.dat')
earthcps_arcsec2 = syn.Observation(earthshine, skybandpass,
force='extrap').countrate()
V = syn.ObsBandpass('landolt,V')
zodiacal = syn.FileSpectrum('zodiacal_high.dat').renorm(22.7, 'vegamag', V)
zodcps_arcsec2 = syn.Observation(zodiacal, skybandpass,
force='extrap').countrate()
aparea_arcsec2 = pi * aperture**2
aparea_pix = aparea_arcsec2 / pixscale**2
npix = (aparea_arcsec2 / pixscale**2)
sharpness = 3.3 / npix
skycounts = (earthcps_arcsec2 + zodcps_arcsec2) * aparea_arcsec2 * etime
skycounts_pix = skycounts / npix
# TODO : get thermal noise, dark current and readnoise from SYNPHOT
darkcps_arcsec2 = 3.05
darkcounts = darkcps_arcsec2 * aparea_arcsec2 * etime
darkcounts_pix = darkcounts / npix
thermcps_arcsec2 = 8.15
thermcounts = thermcps_arcsec2 * aparea_arcsec2 * etime
thermcounts_pix = thermcounts / npix
rdnoise_pix = 12.5 # read noise per pixel (per exposure)
rdnoiseTot = rdnoise_pix * aparea_pix # 161.61
bgcounts_pix = skycounts_pix + darkcounts_pix + thermcounts_pix
noise = sqrt(srccounts + npix * bgcounts_pix +
npix * nexp * rdnoise_pix**2)
SNR = srccounts / noise
onoise = sqrt(srccounts + (bgcounts_pix + rdnoise_pix**2) / sharpness)
oSNR = srccounts / onoise
return SNR, oSNR
def get_synthetic_mag_file(filename, filt_out, system_out, filt_in=None, mag_in=None, system_in=None, ebv=0, force=None):
'''
Scales the input spectrum (read from the filename file) to the magnitude
provided in the filter_in band, and obtains the synthetic photometry in the filter_out band.
If no scaling magnitude is provided, the original spectrum is used to compute the synthetic mangitude.
Parameters
----------
filename : string
The name of the file which contains the spectrum.
filt_out : string
The name of the filter the system will compute the output of.
system_out : string
The system in which the output magntiudes are measured. "abmag" or "vegamag" or "stmag"
filt_in : string
The name of the filter we want to scale the spectrum.
mag_in : float
The mangtude of the object in the filter_in band.
system_in : string
The system in which the input magntiude is measured. "abmag" or "vegamag" or "stmag"
ebv : float, default: 0
The reddening to be applied to the model spectrum.
force : string, default: None
Whether the magnitude should be extrapolated in case the filter and the spectrum wavelengths do not
completely overlap. You may use force=[extrap|taper] to force this Observation anyway.
Returns
-------
mag_out : float
The synthetic photometry magnitude of the input spectrum once
scaled to its mag_in value in filter_out band.
'''
sp = ps.FileSpectrum(filename)
sp_ext = sp * ps.Extinction(ebv, 'mwavg')
if not( filt_in is None or mag_in is None or system_in is None):
sp_norm = sp_ext.renorm(mag_in, system_in, ps.ObsBandpass(filt_in))
else:
sp_norm = sp_ext
try:
obs = ps.Observation(sp_norm, ps.ObsBandpass(filt_out), binset=sp_norm.wave, force=force)
except ValueError:
bp = ps.FileBandpass(banddic[filt_out])
obs = ps.Observation(sp_norm, bp, binset=sp.wave)
mag_out = obs.effstim(system_out)
return mag_out
def get_adu_per_sec(self, vegamag, BandPass):
"""
Get the photon count in phot/s for a star with a Vega magnitude of *vegamag* in a given pysynphot.BandPass
These are the total photon counts the telescope/imager will see.
INPUT:
vegamag - Vega magnitude in a given bandpass
BandPass - pysynphot.BandPass class
OUTPUT:
photons per second
NOTES:
Accounts for QE
"""
# Convolve QE, BandPass, and Throughput
CombinedBP = self.QE * self.Throughput * BandPass
# Use Vega magnitudes
VegaSpectrum = S.Vega.renorm(vegamag, 'vegamag', CombinedBP)
# Define observation
obs = S.Observation(VegaSpectrum,
CombinedBP,
binset=VegaSpectrum.GetWaveSet())
# pysynphot is automatically set up to calculate for Hubble, we just need to scale the area
hubble_area = S.refs.PRIMARY_AREA
electrons_per_sec = (
obs.countrate() / hubble_area
) * self.area # electrons per second, as we are using QE information
# convert to adu_per_sec
adu_per_sec = electrons_per_sec / self.gain
return adu_per_sec
def test_johnson_v_tabular_spectra():
bp = pysyn.FileBandpass("data/test_bp_johnson_v.fits",
thrucol="THROUGHPUT")
sp = pysyn.FileSpectrum("data/test_sp_vega.fits")
obs = pysyn.Observation(sp, bp)
obs *= 1e20
result(obs, 411896149580, 0, 8893)
def test_hst_analytic_binset():
bp = pysyn.FileBandpass("data/test_bp_acs_hrc_f555w.fits",
thrucol="THROUGHPUT")
spec = FlatSpectrum(10000, fluxunits='flam')
binset = np.asarray([1000, 2000, 5000, 11000])
obs = pysyn.Observation(spec, bp, binset=binset)
result(obs, 2439, 0, 17023)
def compute_zodi(ra, dec, jd, FILTER='F140W', verbose=False):
"""
Get the predicted Zodiacal surface brightness and then fold it through the Synphot WFC3 filters
"""
import pysynphot as S
thermal = {
'F160W': 0.134,
'F140W': 0.069,
'F105W': 0.051,
'F110W': 0.05,
'F125W': 0.052,
'F128N': 0.051,
'F130N': 0.051,
'F132N': 0.051,
'F164N': 0.0651,
'G141': 0.1,
'G102': 0.04,
'F098M': 0.05
}
lat, lng = helio_lat_lng(ra, dec, jd)
SB = get_zodi_SB(lat, lng)
if verbose:
print 'Lat, Lng: %f, %f, SB=%.2f' % (lat, lng,
SB + 2.5 * np.log10(0.128254**2))
zod = S.FileSpectrum('%s/zodiacal_model_001.fits' % (datapath()))
nz = zod.renorm(SB, S.units.VegaMag, S.ObsBandpass("V"))
bp = S.ObsBandpass('wfc3,ir,%s' % (FILTER.lower()))
obs = S.Observation(nz, bp)
return obs.countrate() + thermal[FILTER]
def fit_UVslope(filternames,
mags,
magerrs,
z,
beta0=-2.0,
normband=filters['f850lp'],
normmag=25.0,
verbose=False,
fit='flux'):
"""
Fit a UV slope (beta) to the observed rest-frame UV magnitudes.
bands - a list of strings as filter names (e.g., f160w)
mags, magerrs - lists of magnitude and magnitude errors
"""
x = UVSlope(1500., beta0, z)
mag = S.Observation(x.rspec, normband).effstim('abmag')
A0 = 10.**(normmag - mag)
bands = [filters[b] for b in filternames]
def func((beta, A)):
y = UVSlope(1500., beta, z, A, verbose=verbose)
return y.chi2(bands, mags, magerrs, fit=fit)
# print beta0, A0, func((beta0, A0))
output = scipy.optimize.fmin(func, np.array([beta0, A0]), maxiter=1000)
return output
def test_hst_tabular_spectra():
bp = pysyn.FileBandpass("data/test_bp_acs_hrc_f555w.fits",
thrucol="THROUGHPUT")
sp = pysyn.FileSpectrum("data/test_sp_vega.fits")
obs = pysyn.Observation(sp, bp)
obs *= 1e20
result(obs, 112231834769, 0, 15866)
def apply_filter(stars, colour):
"""
Generates a binary filter based on the colour selected and passes the stars
spectrum through this filter, being normalised to its actual magnitude as observed
outputs an oberservation from this spectrum for use in other programs
"""
nwavels = 3501
wavels = np.linspace(3500, 7000, nwavels)
if colour == "red":
throughput = custom_bandpass(wavels, [5750, 6500]) # 750nm range
elif colour == "green":
throughput = custom_bandpass(wavels, [4750, 6000]) # 1250nm range
elif colour == "blue":
throughput = custom_bandpass(wavels, [4000, 5250]) # 1250nm range
band_bin = S.ArrayBandpass(wavels, throughput)
for star in stars:
star_obj = star[0]
mag = star[3]
filtered_spec = star_obj.renorm(mag, 'vegamag', band_bin)
observation = S.Observation(filtered_spec, band_bin, binset=wavels)
star.append(filtered_spec)
star.append(observation)
return stars
def compute_photometry(catalog, photmode):
""" Compute magnitudes for sources from catalog based on observations photmode
Parameters
-----------
catalog : object
Astropy Table with 'source_sum' column for the measured flux for each source
photmode : String
Specification of the observation filter configuration used for the exposure
as reported by the 'PHOTMODE' keyword from the PRIMARY header.
Returns
--------
phot_cat : object
Astropy Table object of input source catalog with added column for
VEGAMAG photometry (in magnitudes).
"""
# Determine VEGAMAG zero-point using pysynphot for this photmode
photmode = photmode.replace(' ', ',')
vega = S.FileSpectrum(VEGASPEC)
bp = S.ObsBandpass(photmode)
vegauvis = S.Observation(vega, bp)
vegazpt = 2.5 * np.log10(vegauvis.countrate())
# Use zero-point to convert flux values from catalog into magnitudes
source_phot = vegazpt - 2.5 * np.log10(catalog['source_sum'])
source_phot.name = 'vegamag'
# Now add this new column to the catalog table
catalog.add_column(source_phot)
return catalog
def show_uvslope_fit(filternames, mags, magerrs, z, beta, A):
x = UVSlope(1500., beta, z, A=A)
plt.figure()
bands = [filters[b] for b in filternames]
waves = np.array([b.pivot() for b in bands])
plt.errorbar(waves,
mags,
yerr=magerrs,
ls='none',
fmt='x',
mew=2,
ms=12,
capsize=10,
elinewidth=2)
x.rspec.convert('fnu') # in erg cm^-2 s^-1 Hz^-1
rspec = x.rspec * (1. / 1.e-29) # in micro-Jansky
plt.plot(rspec.wave,
23.9 - 2.5 * np.log10(rspec.flux),
lw=1.5,
label=r'$\beta=%.2f$' % beta)
plt.scatter(waves,
[S.Observation(x.rspec, b).effstim('abmag') for b in bands],
marker='s',
facecolor='none',
edgecolor='red',
linewidths=2,
s=30**2)
plt.xscale('log')
plt.xlim(0.9 * waves.min(), 1.1 * waves.max())
plt.ylim(np.min(mags) - 1.0, np.max(mags) + 1.0)
plt.xticks(waves, filternames)
plt.legend(loc=0)
plt.gca().invert_yaxis()
plt.show()
def calcphot(log, wavelengthArray, fluxArray, obsmode):
"""
*Run calcphot on single spectrum and filter.*
**Key Arguments:**
- ``log`` -- logger
- ``wavelengthArray`` -- the array containing the wavelength range of the spectrum
- ``fluxArray`` -- the array contain the respective spectrum flux (as function of wavelength)
- ``obsmode`` -- the observation mode (generally a filter system and filter type, e.g. "sdss,g")
**Return:**
- None
"""
################ > IMPORTS ################
## STANDARD LIB ##
## THIRD PARTY ##
import pysynphot as syn
## LOCAL APPLICATION ##
################ > VARIABLE SETTINGS ######
# Read in a spectrum from a file
sp = syn.ArraySpectrum(
wave=wavelengthArray, flux=fluxArray, waveunits='angstrom', fluxunits='flam')
bp = syn.ObsBandpass(obsmode)
obs = syn.Observation(sp, bp)
abMag = obs.effstim('abmag')
return abMag
def photflam(self):
ps.setref(**self.REFS)
sp = ps.FlatSpectrum(0, fluxunits='stmag')
sp.convert('angstroms')
bp = self.bandpass
obs = ps.Observation(sp, bp, binset=sp.wave)
return obs.effstim('flam') / obs.countrate()
def testextrap(self):
self.obs = S.Observation(self.sp, self.bp, force='extrap')
idx = N.where(self.obs.wave == self.refwave)
test = self.obs.flux.item(idx[0])
self.assertAlmostEqual(test,
self.refval,
msg='Expected %f, got %f' % (self.refval, test))
def test_observation_binset():
bp = S.ObsBandpass('acs,hrc,f555w')
spec = S.FlatSpectrum(1)
obs = S.Observation(spec, bp)
assert (bp.binset == obs.binwave).all()
def get_pb_zpt(pb, reference='AB', model_mag=None):
"""
Determines a passband zeropoint for synthetic photometry, given a reference
standard and its model magnitude in the passband
Parameters
----------
pb : :py:class:`pysynphot.ArrayBandpass` or :py:class:`pysynphot.obsbandpass.ObsModeBandpass`
The passband data.
Must have ``dtype=[('wave', '<f8'), ('throughput', '<f8')]``
reference : str, optional
The name of the reference spectrophotometric standard to use to determine the passband zeropoint.
'AB' or 'Vega' (default: 'AB')
model_mag : float, optional
The magnitude of the reference spectrophotometric standard in the passband.
default = None
Returns
-------
pbzp : float
passband AB zeropoint
Raises
------
RuntimeError
If the passband and reference standard do not overlap
ValueError
If the reference model_mag is invalid
See Also
--------
:py:func:`source_synphot.passband.synflux`
:py:func:`source_synphot.passband.synphot`
"""
# setup the photometric system by defining the standard and corresponding magnitude system
if reference.lower() not in ('vega', 'ab'):
message = 'Do not understand mag system reference standard {}. Must be AB or Vega'.format(
reference)
raise RuntimeError(message)
if reference.lower() == 'ab':
refspec = S.FlatSpectrum(3631, fluxunits='jy')
mag_type = 'abmag'
else:
refspec = S.Vega
mag_type = 'vegamag'
refspec.convert('flam')
if model_mag is None:
ob = S.Observation(refspec, pb)
model_mag = ob.effstim(mag_type)
synphot_mag = synphot(refspec, pb, zp=0.)
#print(synphot_mag)
#print(model_mag)
outzp = model_mag - synphot_mag
return outzp
def counts_syn_no_norm(x, m, b, A, wave):
spec = spec_norm(m, b, A, wave)
sp = S.ArraySpectrum(wave, spec, waveunits='angstrom', fluxunits='photlam', name='MySource', keepneg=True)
counts2 = np.zeros((4))
for i in range((4)):
obs = S.Observation(sp, S.ObsBandpass('acs,sbc,%s' % (filter_name[i])))
counts2[i] = obs.countrate() # effstim('counts')
return counts2
def test_hst_tabular_spectra_binset():
bp = pysyn.FileBandpass("data/test_bp_acs_hrc_f555w.fits",
thrucol="THROUGHPUT")
sp = pysyn.FileSpectrum("data/test_sp_vega.fits")
binset = np.asarray([1000, 2000, 5000, 11000])
obs = pysyn.Observation(sp, bp, binset=binset)
obs *= 1e20
result(obs, 112231834769, 0, 15866)
def normalize_abmag(self, normmag, normband):
if type(normband) in [type(0), type(0.0)]:
# abmag = self.copy.ABmag_lambda(normband)
filt = S.Box(normband, 100.)
# obs = S.Observation(self.copy, filt)
obs = S.Observation(self.sp, filt)
abmag = obs.effstim('abmag')
else:
# abmag = self.copy.ABmag(normband)
# obs = S.Observation(self.copy, normband)
obs = S.Observation(self.sp, normband)
abmag = obs.effstim('abmag')
dmag = normmag - abmag
# self.copy._fluxtable = self.copy._fluxtable * 10.**(-0.4 * dmag)
self.copy = self.sp * 10.**(-0.4 * dmag)
self.normband = normband
self.normmag = normmag
# self.sp = self.sp * 10.**(-0.4 * dmag) * area_tenpc
# multiply the flux by 10 pic
return 10.**(-0.4 * dmag)
def compute_zpts(instrument, detector, band, mjd):
bandpass = pyS.ObsBandpass('{:s},{:s},{:s},mjd#{:d}'.format(
instrument, detector, band, mjd))
spec_bb = pyS.BlackBody(50000)
spec_bb_norm = spec_bb.renorm(1, 'counts', bandpass)
obs = pyS.Observation(spec_bb_norm, bandpass)
zps = {}
zps['vega'] = obs.effstim('vegamag')
zps['st'] = obs.effstim('stmag')
zps['ab'] = obs.effstim('abmag')
return zps
def setUp(self):
self.sp = S.BlackBody(4400)
#Note that this bandpass has a simple 1A-spacing binwave
self.bp = S.ObsBandpass('acs,hrc,f555w')
self.refwave = 5500 #Angstroms
self.obs = S.Observation(self.sp, self.bp)
self.obs.convert('counts')
self.tda = dict(thresh=0.001)
self.tra = dict()
self.tda['spectrum'] = str(self.sp)
self.tra['bandpass'] = str(self.bp)
def zeropoint(self):
ps.setref(**self.REFS)
standard_star_file = GetStipsData(
os.path.join("standards", "alpha_lyr_stis_008.fits"))
sp = ps.FileSpectrum(standard_star_file)
sp.convert('angstroms')
bp = self.bandpass
sp = sp.renorm(0.0, "VEGAMAG", bp)
obs = ps.Observation(sp, bp, binset=sp.wave)
zeropoint = obs.effstim("OBMAG")
return zeropoint
def setUp(self):
#Use a defined comptab here: we're examining native arrays
self.oldref = S.refs.getref()
S.setref(comptable='$PYSYN_CDBS/mtab/u4c18498m_tmc.fits')
self.sp = S.BlackBody(4400)
self.bp = S.ObsBandpass('stis,fuvmama,g140m,c1470,s52x01')
self.obs = S.Observation(self.sp, self.bp)
self.refwave = 1450
self.tda = dict(thresh=0.001)
self.tra = dict()
self.tda['spectrum'] = str(self.sp)
self.tra['bandpass'] = str(self.bp)
def setup_class(self):
"""Subclass needs to define ``obsmode`` and ``spectrum``
class variables for this to work.
"""
if not HAS_PYSYNPHOT:
raise ImportError(
'ASTROLIB PYSYNPHOT must be installed to run these tests')
# Make sure both software use the same graph and component tables.
conf.graphtable = self.tables['graphtable']
conf.comptable = self.tables['comptable']
conf.thermtable = self.tables['thermtable']
S.setref(graphtable=self.tables['graphtable'],
comptable=self.tables['comptable'],
thermtable=self.tables['thermtable'])
# Construct spectra for both software.
self.sp = parse_spec(self.spectrum)
self.bp = band(self.obsmode)
# Astropy version has no prior knowledge of instrument-specific
# binset, so it has to be set explicitly.
if hasattr(self.bp, 'binset'):
self.obs = Observation(self.sp,
self.bp,
force=self.force,
binset=self.bp.binset)
else:
self.obs = Observation(self.sp, self.bp, force=self.force)
# Astropy version does not assume a default waveset
# (you either have it or you don't). If there is no
# waveset, no point comparing obs waveset against ASTROLIB.
if self.sp.waveset is None or self.bp.waveset is None:
self._has_obswave = False
else:
self._has_obswave = True
self.spref = old_parse_spec(self.spectrum)
self.bpref = S.ObsBandpass(self.obsmode)
self.obsref = S.Observation(self.spref, self.bpref, force=self.force)
# Ensure we are comparing in the same units
self.bpref.convert(self.bp._internal_wave_unit.name)
self.spref.convert(self.sp._internal_wave_unit.name)
self.spref.convert(self.sp._internal_flux_unit.name)
self.obsref.convert(self.obs._internal_wave_unit.name)
self.obsref.convert(self.obs._internal_flux_unit.name)
def converter(path1,path2,path3,input_filter,input_spectral,input_magnitude,input_photometric,output_filter,output_photometric):
final_output = None
os.environ["PYNRC_PATH"] =str(path1)
os.environ["PYSYN_CDBS"] =str(path2)
os.environ["WEBBPSF_PATH"] = str(path3)
import pysynphot as S
import pynrc
bp_K = S.ObsBandpass(input_filter)
bg = pynrc.nrc_utils.stellar_spectrum(input_spectral,input_magnitude,input_photometric,bp_K)
bp_ncfilter = pynrc.nrc_utils.read_filter(output_filter)
obs = S.Observation(bg,bp_ncfilter,binset=bg.wave)
final_output = obs.effstim(output_photometric)
return final_output
def findCountRate(instr, filt, Teff=5800., z=0.0, logg=4.44, radius=1., distance=10., vega=False, webbpsf=False, **kwargs):
if instr=='NIRCam': filt=filt[:5] # Strip the mask string off, e.g. F210M-MASK210R
# CREATE SPECTRUM OBJECT:
spec=Spectrum(instr, filt)
# CREATE FILTER BANDPASS FOR FILTER NAME:
bandpass=spec.getBandpass()
# CREATE SPECTRUM BASED ON Teff, Z, and LOGG:
star=spec.getSpectrum(Teff=Teff, z=z, logg=logg, vega=vega) # Returns Angstroms, Flam
# SCALE FOR DISTANCE & CONVERT UNITS TO: photons s^-1 cm^-2 A^-1
if vega==False: star*=(radius*2.254e-8/distance)**2 #Distance in units of parsec
star.convert("photlam")
# CREATE OBSERVATION (STAR times BANDPASS):
obs=S.Observation(star,bandpass, binset=star.wave)
#print 'units: ',obs.waveunits, obs.fluxunits
# ADD QE/GERMANIUM/OTE TRANSMISSION TO OBSERVATION:
if webbpsf:
print "Using images created by WebbPSF"
if instr == 'MIRI':
bp_QE = spec.getMIRI_QE()
obs = S.Observation(obs,bp_QE)
bp_Germ = spec.getMIRI_Germanium()
obs = S.Observation(obs,bp_Germ)
bp_OTE = spec.getMIRI_OTE_transmission()
obs = S.Observation(obs,bp_OTE)
else: pass # FOR NIRCam, QE/OTE PROFILES ARE INCLUDED IN FILTER TRANSMISSION CURVES
else: pass # FOR IMAGES CREATED WITH MATHEMATICA, QE/GERMANIUM/OTE ARE ALREADY INCLUDED
# INTEGRATE TOTAL NUMBER OF PHOTONS OVER BANDPASS:
ncounts=np.trapz(obs.flux,obs.wave)*DefaultSettings.JWSTREFS['area'] #multiply by collecting area
return ncounts, spec
def makeobservation(self, observer, outUnit='ABMag'):
'''Makes an observation of the spectrum through the years.'''
# Check
if not (isinstance(observer, psp.spectrum.SpectralElement)
or hasattr(observer, 'throughput')):
raise TypeError('observer must be a pysynphot observer')
outUnit = outUnit.lower()
# Make Observation measurments
meas = []
for spec, _ in self:
meas.append(psp.Observation(spec, observer).effstim(outUnit))
return np.array(meas)
