def setup_class(self): # Create a TimeSeriesSource with a flat spectrum at all times. phase = np.linspace(0., 100., 10) wave = np.linspace(1000., 10000., 100) flux = np.ones((len(phase), len(wave)), dtype=np.float) source = sncosmo.TimeSeriesSource(phase, wave, flux) self.model = sncosmo.Model(source=source)
def __init__( self, sedw, rv, ebv, # "True parameter values." z, mwebv, # "True parameter values." dust_type=sncosmo.OD94Dust, template=hsiao): self.template = template p = self.template._phase l = self.template._wave flux = self.template.flux(p, l) try: sedw.__call__ except AttributeError: wflux = sedw * flux else: self.wsurf = np.asarray([[sedw(pp, ll) for ll in l] for pp in p]) wflux = self.wsurf * flux self.source = sncosmo.TimeSeriesSource(p, l, wflux) self.rv = rv self.ebv = ebv self.z = z self.dust_type = dust_type self.mwebv = mwebv
def flatsource(): """Create and return a TimeSeriesSource with a flat spectrum == 1.0 at all times.""" phase = np.linspace(0., 100., 10) wave = np.linspace(800., 20000., 100) flux = np.ones((len(phase), len(wave)), dtype=np.float) return sncosmo.TimeSeriesSource(phase, wave, flux)
def to_sn_model(self): try: source = sncosmo.TimeSeriesSource(self.warped_phase,self.warped_wave,self.warped_flux) except: print("Could not create sncosmo model, have you created warped data yet?") self.sn_model = sncosmo.Model(source) return(self.sn_model)
def _param_to_source(source, wave, color_curve=None, band1=None, band2=None, ref_color=False): band = None for b in np.unique(source.lc['band']): temp = sncosmo.get_bandpass(b) if temp.minwave() <= min(wave) and temp.maxwave() >= max(wave): band = sncosmo.get_bandpass(b) if band is None: raise RuntimeError( "Hmm, your data do not contain the band you want to fit.") finalPhase = source._phase if color_curve is not None and not ref_color: zp1 = source.lc['zp'][source.lc['band'] == band1][0] zp2 = source.lc['zp'][source.lc['band'] == band2][0] flux1 = sncosmo.Model(source._ts_sources[band1]).bandflux( band1, source._phase, zp1, source.lc['zpsys'][source.lc['band'] == band1][0]) temp_flux = flux1 / 10**(-.4 * (color_curve(source._phase) - (zp1 - zp2))) else: temp_flux = np.ones(len(finalPhase)) try: zpnorm = 10.**( 0.4 * source.lc['zp'][source.lc['band'] == band.name.lower()][0]) band.name = band.name.lower() except: zpnorm = 10.**( 0.4 * source.lc['zp'][source.lc['band'] == band.name.upper()][0]) band.name = band.name.upper() wave, dwave = integration_grid(band.minwave(), band.maxwave(), MODEL_BANDFLUX_SPACING) ms = sncosmo.get_magsystem(source.lc['zpsys'][0]) zpnorm = zpnorm / ms.zpbandflux(band) flux = temp_flux * HC_ERG_AA / (dwave * np.sum(wave * band(wave)) * zpnorm) finalWave = np.arange(wave[0] - dwave * 10, wave[-1] + dwave * 10, dwave) finalFlux = np.zeros((len(finalPhase), len(finalWave))) for i in range(len(finalPhase)): #if finalPhase[i]>= np.min(timeArr) and finalPhase[i] <= np.max(timeArr): for j in range(len(finalWave)): if finalWave[j] >= wave[0] and finalWave[j] <= wave[-1]: finalFlux[i][j] = flux[i] #offset=np.zeros(len(finalPhase)) out = sncosmo.TimeSeriesSource(np.array(finalPhase), np.array(finalWave), np.array(finalFlux), zero_before=False) return (out)
def test_register_source(): phase = np.linspace(0., 100., 10) wave = np.linspace(800., 20000., 100) flux = np.ones((len(phase), len(wave)), dtype=float) source = sncosmo.TimeSeriesSource(phase, wave, flux, name='test_source') sncosmo.register(source) # Retrieving a source makes a copy, so just check that the names are the # same. assert sncosmo.get_source('test_source').name == 'test_source'
def model_(phase=0, wave=0, cos_theta=0, flux=0, viewingangle_dependece=True): '''phase, wave, cos_theta and flux are 1D arrays with the same length''' if viewingangle_dependece: source = AngularTimeSeriesSource(phase, wave, cos_theta, flux) else: source = sncosmo.TimeSeriesSource(phase, wave, flux) dust = sncosmo.CCM89Dust() return sncosmo.Model(source=source, effects=[dust, dust], effect_names=['host', 'MW'], effect_frames=['rest', 'obs'])
def getMagSncosmo(filename,band,model,theta=0.0,redshift=0.0): #u = np.genfromtxt(opts.name) D_cm = 10*3.0857e16*100 # 10 pc in cm with open(filename) as f: content = f.readlines() for ii in range(3): if ii == 0: Nobs=int(content[0]) elif ii == 1: Nwave=int(content[1]) elif ii == 2: Ntime=int(content[2].split()[0]) ti = float(content[2].split()[1]) tf = float(content[2].split()[2]) dlogt = (np.log(tf)-np.log(ti)) / float(Ntime) tt = [] for i in range(Ntime): tt.append(np.exp(np.log(ti) + i * dlogt)) tt = np.array(tt) a = np.genfromtxt(filename, skip_header=3) dMpc = 10e-6 mall = [] costhetas = np.linspace(0,1,Nobs) thetas = np.rad2deg(np.arccos(costhetas)) j = np.argmin(np.abs(thetas-theta)) w = a[Nwave*j:Nwave*(j+1),0] fl = np.ones((Ntime,len(w))) Lbol = np.ones(Ntime) for i in range(0,Ntime): I = a[Nwave*j:Nwave*(j+1),1+i*3] * (1./dMpc)**2 fl[i] = I Lbol[i] = np.trapz(I*(4*np.pi*D_cm**2),x=w) source = sncosmo.TimeSeriesSource(tt,w,fl) bp = sncosmo.Bandpass(band[:,0], band[:,1]) m = source.bandmag(bp,"ab",tt) mag_d = m - 5. * np.log10(dMpc*1e6/10.) ii = np.where(~np.isnan(mag_d) & np.isfinite(mag_d))[0] f1 = interp.interp1d(tt[ii], mag_d[ii]) f = extrap1d(f1,4) mag_d = f(tt) return tt, mag_d, Lbol
def createSNSED(filename,rescale=False): """ Creates an sncosmo.Source object from a timeseries source (flux in photons/s/cm^2 as in sncosmo,assumes the file is in ergs though) :param filename: Name of file containing the timerseries source :type filename: str :param rescale: If you want to rescale the flux so that it is in photons at the end instead of ergs (divides by ergs/AA :type rescale: Boolean, optional :returns: ncosmo.Source object """ phase,wave,flux=sncosmo.read_griddata_ascii(filename) if rescale: for i in range( len(phase) ) : flux[i]=flux[i]/sncosmo.constants.HC_ERG_AA return(sncosmo.TimeSeriesSource(phase,wave,flux,zero_before=True,name=os.path.basename(filename))) #return(snSource(phase,wave,flux,name=os.path.basename(filename)))
def sncosmo_source(source_path): """ create a sncosmo.TimeSeriesSource from a file :param source_path: str, path to the file :return: sncosmo.TimeSeriesSource """ # read the file sed = Table(np.loadtxt(source_path), names=['phase', 'wl', 'flux']) # extract phase, wavelength and flux phase = np.unique(sed['phase']) disp = np.unique(sed['wl']) flux = sed['flux'].reshape(len(phase), len(disp)) # create the TimeSeriesSource snc_source = sncosmo.TimeSeriesSource(phase, disp, flux, zero_before=True) return snc_source
# phase0 wls2 flux # .... # phaseN wlsN-1 flux # phaseN wlsN flux ## We need to adapt the format to build the sncosmo class TimeSeriesSource for tmpl in tmpl_host_extinction_corrected[:]: tmpl_name = tmpl.replace('.SED', '') phase_raw, wls_raw, flux_raw = np.genfromtxt( pycoco_dir + 'Templates_HostCorrected/' + tmpl, unpack=True) wls = np.unique(wls_raw) phase = phase_raw[::len(wls)] flux_reshaped = flux_raw.reshape(len(phase), len(wls)) source = sncosmo.TimeSeriesSource(phase, wls, flux_reshaped, zero_before=True, name=tmpl_name) sncosmo.register(source, name=tmpl_name) print( tmpl_name, '(type %s) registered!' % name2type[tmpl_name.replace('pycoco_', '')]) for tmpl in tmpl_host_extinction_NOTcorrected[:]: tmpl_name = tmpl.replace('.SED', '') phase_raw, wls_raw, flux_raw = np.genfromtxt( pycoco_dir + 'Templates_noHostCorr/' + tmpl, unpack=True) wls = np.unique(wls_raw) phase = phase_raw[::len(wls)] flux_reshaped = flux_raw.reshape(len(phase), len(wls)) source = sncosmo.TimeSeriesSource(phase,
def kaepora_to_sed(data_folder, perturber_keys, base_sed='hsiao', minWave=0, maxWave=np.inf, minPhase=-np.inf, maxPhase=np.inf, waveStep=10, scale_band='bessellb'): waves = {} trans = {} dwaves = {} for b in ['bessellb', 'bessellv', 'bessellr']: band = sncosmo.get_bandpass(b) wave, dwave = integration_grid(band.minwave(), band.maxwave(), MODEL_BANDFLUX_SPACING) waves[b] = wave dwaves[b] = dwave trans[b] = band(wave) if isinstance(base_sed, str): base_sed = sncosmo.Model(base_sed) base_sed_wave = base_sed._source._wave filelists = [] for k in perturber_keys: filelists.append(glob.glob(os.path.join(data_folder, '*%s*' % k))) seds = {} phase_pairs = {} phase_lists = {} scale_factors = {} for i in range(len(filelists)): filelist = filelists[i] temp_key = perturber_keys[i] temp_phase = [] j = 0 for f in filelist: dat = ascii.read(f) phase = f[f.find('phase=') + 6:f.find('phase=') + 6 + (f[f.find('phase=') + 6:]).find('_')] phase = -1 * float(phase[1:]) if phase[0] == 'm' else float( phase[1:]) temp_phase.append(phase) dat = dat[dat['Wavelength'] >= minWave] dat = dat[dat['Wavelength'] <= maxWave] if i == 0: key_phase = np.round(phase, 2) phase_pairs[key_phase] = [{ 'wave': dat['Wavelength'], 'flux': dat['Flux'], 'interp': interp1d(dat['Wavelength'], dat['Flux'], kind='cubic') }] else: pair_list = np.array(list(phase_pairs.keys())) match = pair_list[np.abs(pair_list - phase).argmin()] key_phase = np.round(match, 2) phase_pairs[key_phase].append({ 'wave': dat['Wavelength'], 'flux': dat['Flux'], 'interp': interp1d(dat['Wavelength'], dat['Flux'], kind='cubic') }) if np.min(np.abs(dat['Flux'] - 10)) < .001: scale_factors[key_phase] = _get_kaepora_scale( phase_pairs[key_phase][i]['interp'], base_sed, waves, trans, dwaves, key_phase) if len(np.unique(temp_phase)) != len(temp_phase): print('You have more than one file for at least one phase.') sys.exit(1) phase_lists[temp_key] = temp_phase final_wavelength = np.arange(base_sed_wave[0], base_sed_wave[-1] + waveStep / 10, waveStep) to_save = {} for j in range(len(perturber_keys)): temp_phase = np.array(phase_lists[perturber_keys[j]]) bound_inds = np.where( np.logical_and(temp_phase >= minPhase, temp_phase <= maxPhase))[0] final_phase = np.sort(temp_phase[bound_inds]) pair_list = np.array(list(phase_pairs.keys())) match = np.round( np.array([ pair_list[np.abs(pair_list - phase).argmin()] for phase in final_phase ]), 2) final_flux = [] for i in range(len(match)): scaled_flux = interp1d(phase_pairs[match[i]][j]['wave'], phase_pairs[match[i]][j]['flux'] * scale_factors[match[i]], kind='cubic') to_save[final_phase[i]] = scale_factors[match[i]] temp = np.zeros(len(final_wavelength)) for w in range(len(final_wavelength)): if final_wavelength[w] < np.min(phase_pairs[ match[i]][j]['wave']) or final_wavelength[w] > np.max( phase_pairs[match[i]][j]['wave']): temp[w] = base_sed._source._flux(final_phase[i], final_wavelength[w]) else: temp[w] = scaled_flux(final_wavelength[w]) final_flux.append(temp) seds[perturber_keys[j]] = [ np.sort(final_phase), final_wavelength, sncosmo.TimeSeriesSource(final_phase, final_wavelength, np.array(final_flux)) ] return (seds)
def getMagSpec(filename,band,model,theta=0.0,redshift=0.0): #u = np.genfromtxt(opts.name) if "bulla" in filename and "hdf5" in filename: with h5py.File(os.path.join(filename), "r") as f: data = f['spectra'] stokes = np.array(data['stokes']) t_d = np.array(data['time']) / (60*60*24) # get time in days wave = np.array(data['wave']) # wavelength spec w/ redshift dMpc = 1e-5 Dcm = 10*3.0857e16*100 I = stokes[:,:,:,0] * (1./dMpc)**2 # get I stokes parameter Nobs = stokes.shape[0] # num observing angles cos = np.linspace(0,1,Nobs) thetas = np.rad2deg(np.arccos(cos)) idx = np.argmin(np.abs(thetas-theta)) fl = I[idx] source = sncosmo.TimeSeriesSource(t_d,wave,fl) bp = sncosmo.Bandpass(band[:,0], band[:,1]) mag_d = source.bandmag(bp,"ab",t_d) L_d = np.trapz(fl*(4*np.pi*D_cm**2),x=wave) ii = np.where(~np.isnan(mag_d))[0] if len(ii) > 1: f = interp.interp1d(t_d[ii], mag_d[ii], fill_value='extrapolate') mag_d = f(t_d) ii = np.where(np.isfinite(np.log10(L_d)))[0] f = interp.interp1d(t_d[ii], np.log10(L_d[ii]), fill_value='extrapolate') L_d = 10**f(t_d) mag_d = savgol_filter(mag_d,window_length=17,polyorder=3,mode='mirror') L_d = savgol_filter(L_d,window_length=17,polyorder=3,mode='mirror') return t_d, mag_d, L_d if "bulla" in filename: u2 = np.loadtxt(filename,skiprows=3) lines = [line.rstrip('\n') for line in open(filename)] lineSplit = lines[2].split(" ") nt, t0, tf = int(lineSplit[0]), float(lineSplit[1]), float(lineSplit[2]) dlogt = (np.log(tf)-np.log(t0)) / float(nt) tt = [] for i in range(nt): tt.append(np.exp(np.log(t0) + i * dlogt)) tt = np.array(tt) ntheta, nwave = int(lines[0]), int(lines[1]) if not np.isnan(theta) and ntheta > 1: costhetas = np.linspace(0,1,ntheta) thetas = np.rad2deg(np.arccos(costhetas)) idx = np.argmin(np.abs(thetas-theta)) istart, iend = int(idx*nwave), int((idx+1)*nwave) u = [] for ii, t in enumerate(tt): if model in ["bulla_blue_cone","bulla_red_ellipse"]: if (t > 6) or (t<1): continue for row in u2[istart:iend]: u.append([t,row[0],row[int(ii+1)]]) u = np.array(u) else: u = [] for ii, t in enumerate(tt): for row in u2: u.append([t,row[0],row[int(ii+1)]]) u = np.array(u) else: u = np.loadtxt(filename,skiprows=1) if model == "kilonova_wind_spectra": u = u[u[:,2]==0.05] D_cm = 10*3.0857e16*100 # 10 pc in cm if model == "kilonova_wind_spectra": u[:,3] /= (4*np.pi*D_cm**2) # F_lam (erg/s/cm2/A at 10pc) u[:,0] /= (24*3600) # time in days else: u[:,2] /= (4*np.pi*D_cm**2) # F_lam (erg/s/cm2/A at 10pc) u[:,0] /= (24*3600) # time in days t = u[0,0] w=[] L=[] #print(band[:,0]) S = 0.1089/band[:,0]**2 S1 = S*band[:,1] ZP = np.trapz(S1,x=band[:,0]) t_d = [] mag_d = [] L_d = [] for enum,i in enumerate(u): if i[0]==t: if model == "kilonova_wind_spectra": w.append(i[1]) L.append(i[3]) else: w.append(i[1]) L.append(i[2]) else: w = np.array(w) L = np.array(L) if not np.isnan(redshift): w = w*(1+redshift) spec = np.array(list(zip(w,L))) spec1 = easyint(spec[:,0],spec[:,1],band[:,0]) conv = spec1*band[:,1] flux = np.trapz(conv,x=band[:,0]) mag = -2.5*np.log10(flux/ZP) Lbol = np.trapz(spec[:,1]*(4*np.pi*D_cm**2),x=spec[:,0]) if not np.isfinite(mag): mag = np.nan w=[] L=[] t=i[0] t_d.append(t) mag_d.append(mag) L_d.append(Lbol) t_d = np.array(t_d) mag_d = np.array(mag_d) L_d = np.array(L_d) # if model in ["bulla_1D","bulla_2D","bulla_2Component_lfree","bulla_2Component_lrich","bulla_2Component_lmid","macronovae-rosswog","bulla_2Component_lnsbh","bulla_blue_cone","bulla_red_ellipse","bulla_opacity","bulla_reprocess","KasenLike_2D","RosswogLike_2D"]: # #print(mag_d) # ii = np.where(~np.isnan(mag_d))[0] # f1 = interp.interp1d(t_d[ii], mag_d[ii]) # f = extrap1d(f1,4) # mag_d = f(t_d) # #print(mag_d) # L_d = np.log10(L_d) # ii = np.where((L_d > 0) & (t_d < 10))[0] # #print(L_d,ii) # f1 = interp.interp1d(t_d[ii], L_d[ii], fill_value='extrapolate') # L_d = 10**f1(t_d) # #print(L_d) # ii = np.where((mag_d > 0.0) & (t_d > 2))[0] # if len(ii) > 0: # dm_dt = (mag_d[ii[0]] - mag_d[ii[0]-5])/(t_d[ii[0]] - t_d[ii[0]-5]) # mag_d[ii[0]:] = mag_d[ii[0]] + (t_d[ii[0]:] - t_d[ii[0]])*dm_dt # # mag_d_medfilt = scipy.signal.medfilt(mag_d) # L_d_medfilt = scipy.signal.medfilt(np.log10(L_d)) # mag_d = mag_d_medfilt # L_d = 10**L_d_medfilt ii = np.where(~np.isnan(mag_d))[0] if len(ii) > 1: f = interp.interp1d(t_d[ii], mag_d[ii], fill_value='extrapolate') mag_d = f(t_d) ii = np.where(np.isfinite(np.log10(L_d)))[0] f = interp.interp1d(t_d[ii], np.log10(L_d[ii]), fill_value='extrapolate') L_d = 10**f(t_d) mag_d = savgol_filter(mag_d,window_length=17,polyorder=3,mode='mirror') L_d = savgol_filter(L_d,window_length=17,polyorder=3,mode='mirror') return t_d, mag_d, L_d
synbands.append(sncosmo.Bandpass(lams, [1., 1.], name='tophat' + name)) names168 = [line.split()[0] for line in open('table.txt')] dic_meta = cPickle.load(open("CABALLOv2/META.pkl")) ans = [] for sn in names168: meta = dic_meta[sn] for nm in meta['spectra']: spec = meta['spectra'][nm] if abs(spec['salt2.phase']) < 2.5: name = "CABALLOv2/" + spec['idr.spec_merged'] spectra = read_fits.read_fits_spectrum1d( name, dispersion_unit='angstrom') model0 = sncosmo.TimeSeriesSource(numpy.array([0.,1,2]), spectra.dispersion.value/(1+meta['salt2.Redshift']), \ numpy.tile(spectra.flux.value,(3,1))) dust = sncosmo.F99Dust(r_v=2.5) dust.set(ebv=0.01) model = sncosmo.Model(source=model0, effects=[dust], effect_names=['host'], effect_frames=['rest']) try: A = -2.5 * numpy.log10( model.bandflux(synbands, 0.) / model0.bandflux(synbands, 0.)) ans.append(A[1] / (A[0] - A[1])) except: pass
# Redshift SEDs w *= (1 + z) ph = [] fl = np.ones((Ntime, len(w))) for itime in range(0, Ntime): time = ti + step_time * (itime + 0.5 ) #+ ph_data[0] + tshift I = a[0:Nwave, 1 + itime * 3] * (1. / dMpc)**2 ph.append(time) fl[itime] = I source = sncosmo.TimeSeriesSource(ph, w, fl) m = source.bandmag(filters[ifilt], "ab", ph) fmodel = 10**(-m / 2.5) # Compare model to data phdata = ph_data_all[ifilt] mdata = data_all[ifilt] mdataerr = dataerr_all[ifilt] fdata = 10**(-mdata / 2.5) fdataerr = log(10) * fdata * mdataerr for idata in range(0, len(phdata)): #if (phdata[idata] < ep_max): diff = fabs(np.array(ph) - phdata[idata]) ind = np.where(diff == min(diff))[0][0]
# Light Curves #-------------------------------------------------------------------------------------------------------------- # ************************ # * Premier filtre choisi* # ************************ filter_1 = f'sdss::{f1}' m_1 = np.zeros((nb_obs, Nstep), dtype=list) for l in range(nb_obs): fluxes_l = np.zeros((Nstep, nb_bins), dtype=list) for i in index: fluxes_l[i] = (intensity[l, i]) source_l = sn.TimeSeriesSource(ph, wave, fluxes_l) m_1[l, :] = list(source_l.bandmag(filter_1, "ab", ph)) m_direct_1 = np.zeros((nb_obs, Nstep), dtype=list) for l in range(nb_obs): fluxes_l_direct = np.zeros((Nstep, nb_bins), dtype=list) for i in index: fluxes_l_direct[i] = (intensity_direct[l, i]) source_l_direct = sn.TimeSeriesSource(ph, wave, fluxes_l_direct) m_direct_1[l, :] = list(source_l_direct.bandmag(filter_1, "ab", ph)) m_other_1 = np.zeros((nb_obs, Nstep), dtype=list) for l in range(nb_obs): fluxes_l_other = np.zeros((Nstep, nb_bins), dtype=list) for i in index:
errimport numpy as np import scipy as sp import matplotlib.pyplot as plt from scipy.interpolate import interp1d from scipy import stats import pandas as pd from pylab import * import time import os import sncosmo import matplotlib.cm as cm import pandas as pd import matplotlib.gridspec as gridspec import numpy.ma as ma import extinction import myfunc as mf plt.rcdefaults() plt.rc('lines', linewidth=1.5) plt.rc('axes', labelsize=19) plt.rc('xtick', labelsize=19) plt.rc('ytick', labelsize=19) plt.rc('text', usetex=True) plt.rc('font',family='serif') plt.rc('font', serif='Times') plt.rc("legend", fontsize=10.5) home = "/Users/linaissa/documents/ARPE/my_work/opacities_I/simulations/outputs/" directory = "outputs_nph5/"
disp = np.linspace(1000., 9000., wavelength_points) # Below, the flux array is made and manipulated across different times and wavelengths. These can be changed, or # inputted manually, changing the final plots. x = np.arange(wavelength_points) flux = [] for i in range(1, time_points + 1): flux.append(x * i) flux = np.array(flux) for i in range(wavelength_points): for z in flux: z[i] += i # Set the created arrays as model model = sncosmo.TimeSeriesSource(phase, disp, flux) # Plot the graph of observed luminosity through different filters over time timearray = np.arange(2455454.88645 - 120., 2455454.88645 + 120, 0.01) # Registering ptf48r filter import os import sys sys.path.append(os.path.abspath('..')) import Bandpass # Plotting relative flux against time filters = ['ptf48r', 'bessellr', 'bessellv', 'bessellb'] colors = ['black', 'red', 'green', 'blue'] for i in range(len(filters)): plt.scatter(timearray,
def extendCC(colorTable,colorCurveDict,snType,outFileLoc='.',bandDict=_filters,colorExtreme='median',colors=None,zpsys='AB', sedlist=None,showplots=None,verbose=True,UVoverwrite=False,IRoverwrite=True,specList=None,specName=None): """ Function used at top level to extend a core-collapse SED. :param colorTable: Colortable made by colorCalc.curveToColor :type colorTable: astropy.Table :param colorCurveDict: Dictionary of color curves, such as made by fitColorCurve :type colorCurveDict: dict :param snType: SN classification for SED(s) :type snType: str :param outFileLoc: Place you want the new SED to be saved, default current directory :type outFileLoc: str,optional :param bandDict: sncosmo bandpass for each band used in the fitting/table generation :type bandDict: dict,optional :param colorExtreme: 'blue,'median','red' describes which curve extreme to use :type colorExtreme: str,optional :param colors: Colors you would like to use for extrapolation :type colors: list or None,optional :param zpsys: Magnitude system :type zpsys: str,optional :param sedlist: list of SEDs to extrapolate, if None then uses all SEDs in SNDATA_ROOT :type sedlist: list or None,optional :param showplots: If you would like to see plots as they're extrapolated :type showplots: Boolean,optional :param verbose: Printing on? :type verbose: Boolean, optional :param UVoverwrite: Whether you would like to overwrite existing UV data :type UVoverwrite: Boolean,options :param IRoverwrite: Whether you would like to overwrite existing IR data :type IRoverwrite: Boolean,optional :param specList: A list of spectra to use in an average :type specList: list, optional :param specName: The name of a spectrum to use. :type specName: str, optional :returns: Saves extrapolated SED to outFileLoc, and returns an sncosmo.Source SED from the extrapolated timeseries. """ colorTable=_standardize(colorTable) if not isinstance(colorTable,Table): raise RuntimeError('Colors argument must be an astropy table.') for band in bandDict: if not isinstance(bandDict[band],sncosmo.Bandpass): bandDict=_bandCheck(bandDict,band) if not colors: print("No extrapolation colors defined, assuming: ",colorCurveDict.keys()) colors=[x for x in colorCurveDict.keys() if 'U-' in x]+[x for x in colorCurveDict.keys() if '-J' in x]+[x for x in colorCurveDict.keys() if '-H' in x]+[x for x in colorCurveDict.keys() if '-K' in x] else: tempColors=[x for x in colors if 'U-' in x]+[x for x in colors if '-J' in x]+[x for x in colors if '-H' in x]+[x for x in colors if '-K' in x] if len(tempColors)>4: raise RuntimeError("Only can do 4 colors!") bands=append([col[0] for col in colors],[col[-1] for col in colors]) for band in _filters.keys(): if band not in bandDict.keys() and band in bands: bandDict[band]=sncosmo.get_bandpass(_filters[band]) if not sedlist: sedlist = glob.glob(os.path.join(sndataroot,"snsed","NON1A","*.SED")) else: sedlist=[sedlist] if not isinstance(sedlist,(tuple,list)) else sedlist sedlist=[os.path.join(sndataroot,"snsed","NON1A",sed) for sed in sedlist] returnList=[] for sedfile in sedlist: phase,wave,flux=sncosmo.read_griddata_ascii(sedfile) #bbWave,blackbody=getBB(phase,wave,flux) #blackbody=sncosmo.Model(source=sncosmo.TimeSeriesSource(phase,bbWave,blackbody)) origWave=_getWave(sedfile,bandDict,colors) #phase,wave,flux=sncosmo.read_griddata_ascii(sedfile) bbWave,blackbody=getBB(phase,wave,flux,os.path.basename(sedfile)[:-4]) blackbody=sncosmo.Model(source=sncosmo.TimeSeriesSource(phase,bbWave,blackbody)) newsedfile=os.path.join(outFileLoc,os.path.basename(sedfile)) if verbose: print("EXTRAPOLATING %s"%os.path.basename(newsedfile)) once=False boundUV=False boundIR=False bandsDone=[] for color in colors: if verbose: print(' Running %s extrapolation.'%color) if color[0] not in bandDict.keys(): raise RuntimeError('Band "%s" defined in color "%s", but band is not defined.') if color[-1] not in bandDict.keys(): raise RuntimeError('Band "%s" defined in color "%s", but band is not defined.') extremeColors=dict([]) extremeColors['blue'],extremeColors['median'],extremeColors['red']=_getExtremes(colorCurveDict[color]['time'],colorCurveDict[color][color],colorTable,color) if sncosmo.get_bandpass(_filters[color[0]]).wave_eff>_UVrightBound: shiftedCurve=_shiftCurve(colorCurveDict[color]['time'],extremeColors,blackbody,color,zpsys) else: shiftedCurve=extremeColors tempMask=colorTable[color].mask colorTable[color].mask=tempMask if once: sedfile=newsedfile tempTable=colorTable[~colorTable[color].mask] UV,IR=_extrapolatesed(sedfile,newsedfile,color,tempTable,colorCurveDict[color]['time'],shiftedCurve[colorExtreme], bandDict,zpsys,bandsDone,UVoverwrite,IRoverwrite,niter=50) if UV: boundUV=True bandsDone.append(color[0]) if IR: boundIR=True bandsDone.append(color[-1]) once=True #_addCCSpec(snType,newsedfile,origWave,specList,specName) #phase,wave,flux=sncosmo.read_griddata_ascii(newsedfile) #temp=sncosmo.Model(sncosmo.TimeSeriesSource(phase,wave,flux)) #for col in [('sdss::r','paritel::j'),('sdss::r','paritel::h'),('sdss::r','paritel::ks')]: # print(temp.color(col[0],col[1],'vega',0),blackbody.color(col[0],col[1],'vega',0)) if showplots: plotSED(newsedfile,day=showplots) plt.show() plt.close() if boundUV: _boundUVsed(newsedfile) if boundIR: _boundIRsed(newsedfile) if verbose: print(" Done with %s.\a\a\a"%os.path.basename(sedfile)) returnList.append(createSNSED(newsedfile)) if len(returnList)>1: return returnList return returnList[0]
for i in index: intensity_ref.append(list(np.genfromtxt(fname=file_ref, skip_header=3, max_rows=nb_bins, dtype='float', usecols= (1+ i*3))/(16*100))) # factor of scale at 40 Mpc #-------------------------------------------------------------------------------------------------------------- # Light Curves #-------------------------------------------------------------------------------------------------------------- filter = ['sdss::g','sdss::r', 'sdss::i','swope2::h'] #filter = ['sdss::g'] m_ref = [] for (f, band) in enumerate(filter): fluxes_ref = np.zeros((Nstep, nb_bins),dtype=list) for i in index: fluxes_ref[i,:] = intensity_ref[i] # list des intensités I_lambda pour un temps donné source_ref = sn.TimeSeriesSource(ph,wave,fluxes_ref) m_ref_f = list(source_ref.bandmag(band,"ab",ph)) m_ref.append(m_ref_f) SimulationsData = [] #for kappaLF in KappaLF: for gammaLF in GammaLF: for kappaLR in KappaLR: for gammaLR in GammaLR: file_sim = data_fold2 /f'nph1.0e+05_kappaLF{kappaLF}_gammaLF{gammaLF}_kappaLR{kappaLR}_gammaLR{gammaLR}_spec.txt' intensity_sim = [] for i in index: intensity_sim.append(list(np.genfromtxt(fname=file_sim, skip_header=3, max_rows=nb_bins, dtype='float', usecols= (1+ i*3))/(16*100))) # factor of scale at 40 Mpc m_sim = []
import numpy as np import sncosmo as sn import matplotlib.pyplot as plt import glob import itertools #******************************************** filenames = sorted(glob.glob('flux_spectra_*.txt')) # ask nb_bins nb_bins = 50 fluxes = [] wavelength = np.loadtxt(fname='flux_spectra_1day.txt', skiprows=1)[:, 2] ph = np.array([1, 2, 4, 7]) filter = 'sdss::g' for f in filenames: data = np.loadtxt(fname=f, skiprows=1) intensity = list(data[:, 1]) fluxes.append(intensity) source = sn.TimeSeriesSource(ph, wavelength, np.array(fluxes)) m = source.bandmag(filter, "ab", ph) print(list(m))
filter = ['sdss::g', 'sdss::r', 'sdss::i', 'swope2::h'] #filter = ['sdss::g'] m_old = [] m_new = [] for (f, band) in enumerate(filter): m_old_f = np.zeros((nb_obs, Nstep), dtype=list) m_new_f = np.zeros((nb_obs, Nstep), dtype=list) for l in range(nb_obs): fluxes_old_l = np.zeros((Nstep, nb_bins), dtype=list) fluxes_new_l = np.zeros((Nstep, nb_bins), dtype=list) for i in index: fluxes_old_l[i] = (intensity_old[l, i]) source_old_l = sn.TimeSeriesSource(ph, wave, fluxes_old_l) fluxes_new_l[i] = (intensity_new[l, i]) source_new_l = sn.TimeSeriesSource(ph, wave, fluxes_new_l) m_old_f[l, :] = list(source_old_l.bandmag(band, "ab", ph)) m_new_f[l, :] = list(source_new_l.bandmag(band, "ab", ph)) m_old.append(m_old_f) m_new.append(m_new_f) #--------------------------------------------------------------------------------------------------------------- # PLOT #-------------------------------------------------------------------------------------------------------------- fig = plt.figure() plt.subplots_adjust( wspace=0.15, hspace=0.2) #wspace = écartement horizontal, #vspace=vertical ?
usecols=(1 + i * 3)) / (16 * 100)) # factor of scale at 40 Mpc #-------------------------------------------------------------------------------------------------------------- # Light Curves #-------------------------------------------------------------------------------------------------------------- filter = 'sdss::u' #source = np.zeros((nb_obs,Nstep)) m = np.zeros((nb_obs, Nstep), dtype=list) for l in range(nb_obs): fluxes_l = np.zeros((Nstep, nb_bins), dtype=list) for i in index: fluxes_l[i] = (intensity[l, i]) # print(f'observers number {l}', fluxes_l) source_l = sn.TimeSeriesSource(ph, wave, fluxes_l) m[l, :] = list(source_l.bandmag(filter, "ab", ph)) # génère une ndarray #--------------------------------------------------------------------------------------------------------------- # PLOT #-------------------------------------------------------------------------------------------------------------- plt.rcParams['figure.figsize'] = [11, 11] #[largeur, hauteur] f = plt.figure() plt.subplots_adjust( wspace=0.05, hspace=0.05) #wspace = écartement horizontal, #vspace=vertical ? X = [list(ph)] * a dataX = list(np.copy(X)) dataX.append(X)
filter = ['sdss::g', 'sdss::r', 'sdss::i', 'swope2::h'] #filter = ['sdss::g'] m_ref = [] m_sin = [] for (f, band) in enumerate(filter): m_ref_f = np.zeros((nb_obs, Nstep), dtype=list) m_sin_f = np.zeros((nb_obs, Nstep), dtype=list) for l in range(nb_obs): fluxes_ref_l = np.zeros((Nstep, nb_bins), dtype=list) fluxes_sin_l = np.zeros((Nstep, nb_bins), dtype=list) for i in index: fluxes_ref_l[i] = (intensity_ref[l, i]) source_ref_l = sn.TimeSeriesSource(ph, wave, fluxes_ref_l) fluxes_sin_l[i] = (intensity_sin[l, i]) source_sin_l = sn.TimeSeriesSource(ph, wave, fluxes_sin_l) m_ref_f[l, :] = list(source_ref_l.bandmag(band, "ab", ph)) m_sin_f[l, :] = list(source_sin_l.bandmag(band, "ab", ph)) m_ref.append(m_ref_f) m_sin.append(m_sin_f) #--------------------------------------------------------------------------------------------------------------- # PLOT #-------------------------------------------------------------------------------------------------------------- fig = plt.figure() plt.subplots_adjust( wspace=0.15, hspace=0.2) #wspace = écartement horizontal, #vspace=vertical ?
#-------------------------------------------------------------------------------------------------------------- filter = ['sdss::g','sdss::r', 'sdss::i','swope2::h'] #filter = ['sdss::g'] m_old = [] m_new = [] for (f, band) in enumerate(filter): m_old_f = np.zeros((nb_obs_old, Nstep_old), dtype=list) m_new_f = np.zeros((nb_obs_new, Nstep_new), dtype=list) for l in range(nb_obs_old): fluxes_old_l = np.zeros((Nstep_old, nb_bins_old),dtype=list) for i in index_old: fluxes_old_l[i] = (intensity_old[l,i]) source_old_l = sn.TimeSeriesSource(ph_old,wave_old,fluxes_old_l) m_old_f[l,:] = list(source_old_l.bandmag(band,"ab",ph_old)) for l in range(nb_obs_new): fluxes_new_l = np.zeros((Nstep_new, nb_bins_new),dtype=list) for i in index_new: fluxes_new_l[i] = (intensity_new[l,i]) source_new_l = sn.TimeSeriesSource(ph_new,wave_new,fluxes_new_l) m_new_f[l,:] = list(source_new_l.bandmag(band,"ab",ph_new)) m_old.append(m_old_f) m_new.append(m_new_f)