currxi[k, 0]), currxi[k, 2], currxi[k, 0] index += 1 col1_p = fits.Column(name='BIN1', format='K', array=XI_PLUS[:, 0]) col2_p = fits.Column(name='BIN2', format='K', array=XI_PLUS[:, 1]) col3_p = fits.Column(name='ANGBIN', format='K', array=XI_PLUS[:, 2]) col4_p = fits.Column(name='VALUE', format='D', array=XI_PLUS[:, 3]) col5_p = fits.Column(name='ANG', format='D', array=XI_PLUS[:, 4]) col1_m = fits.Column(name='BIN1', format='K', array=XI_MINUS[:, 0]) col2_m = fits.Column(name='BIN2', format='K', array=XI_MINUS[:, 1]) col3_m = fits.Column(name='ANGBIN', format='K', array=XI_MINUS[:, 2]) col4_m = fits.Column(name='VALUE', format='D', array=XI_MINUS[:, 3]) col5_m = fits.Column(name='ANG', format='D', array=XI_MINUS[:, 4]) cols_p = fits.ColDefs([col1_p, col2_p, col3_p, col4_p, col5_p]) cols_m = fits.ColDefs([col1_m, col2_m, col3_m, col4_m, col5_m]) hdu_xi_plus = fits.BinTableHDU.from_columns(cols_p) hdu_xi_minus = fits.BinTableHDU.from_columns(cols_m) hdu_xi_plus.header['2PTDATA'] = True hdu_xi_plus.header['EXTNAME'] = 'xi_plus' hdu_xi_plus.header['QUANT1'] = 'G+R' hdu_xi_plus.header['QUANT2'] = 'G+R' hdu_xi_plus.header['KERNEL_1'] = 'NZ_SAMPLE' hdu_xi_plus.header['KERNEL_2'] = 'NZ_SAMPLE' hdu_xi_plus.header['WINDOWS'] = 'SAMPLE' hdu_xi_plus.header['N_ZBIN1'] = 4 hdu_xi_plus.header['N_ZBIN2'] = 4 hdu_xi_plus.header['N_ANG'] = 9
c_sn = np.array(c_sn, dtype='float') c_area = np.array(c_area, dtype='float') c_size = np.array(c_size, dtype='float') c_id2 = np.array(c_id2) c_ngal2 = np.array(c_ngal2, dtype='float') g_id = np.array(g_id) g_ra = np.array(g_ra, dtype='float') g_dec = np.array(g_dec, dtype='float') g_z = np.array(g_z, dtype='float') from astropy.io import fits tbhdu1 = fits.new_table( fits.ColDefs([ fits.Column(name='c_id', format='8A', array=c_id), fits.Column(name='c_ra', format='D', array=c_ra), fits.Column(name='c_dec', format='D', array=c_dec), fits.Column(name='c_z', format='D', array=c_z), fits.Column(name='c_ngal', format='D', array=c_ngal), fits.Column(name='c_sn', format='D', array=c_sn), fits.Column(name='c_area', format='D', array=c_area), fits.Column(name='c_size', format='D', array=c_size) ])) tbhdu2 = fits.new_table( fits.ColDefs([ fits.Column(name='c_id', format='8A', array=c_id2), fits.Column(name='c_ngal', format='D', array=c_ngal2), fits.Column(name='g_id', format='8A', array=g_id), fits.Column(name='g_ra', format='D', array=g_ra), fits.Column(name='g_dec', format='D', array=g_dec), fits.Column(name='g_z', format='D', array=g_z) ])) n = np.arange(100.0) hdu = fits.PrimaryHDU(n)
temp_evt_file, outfile) runner.run(cmd_line) # Add the GTI extension start_column = pyfits.Column(name='START', format='D', unit='s', array=[tstart]) stop_column = pyfits.Column(name='STOP', format='D', unit='s', array=[tstop]) gti_ext = pyfits.BinTableHDU.from_columns( pyfits.ColDefs([start_column, stop_column])) gti_ext.name = "GTI" keywords = { 'TSTART': tstart, 'TSTOP': tstop, 'MISSION': 'AXAF ', 'TELESCOP': 'CHANDRA ', 'INSTRUME': 'ACIS ', 'TIMESYS': 'TT ', 'TIMEUNIT': 's ' } for key in keywords: gti_ext.header[key] = keywords[key]
def generate_fake_fits_observation(event_list=None, filename=None, instr='FPMA', gti=None, tstart=None, tstop=None, mission='NUSTAR', mjdref=55197.00076601852, livetime=None, additional_columns={}): """Generate fake NuSTAR data. Takes an event list (as a list of floats) All inputs are None by default, and can be set during the call. Parameters ---------- event_list : list-like :class:`stingray.events.Eventlist` object. If left None, 1000 random events will be generated, for a total length of 1025 s or the difference between tstop and tstart. filename : str Output file name Returns ------- hdulist : FITS hdu list FITS hdu list of the output file Other Parameters ---------------- mjdref : float Reference MJD. Default is 55197.00076601852 (NuSTAR) pi : list-like The PI channel of each event tstart : float Start of the observation (s from mjdref) tstop : float End of the observation (s from mjdref) instr : str Name of the instrument. Default is 'FPMA' livetime : float Total livetime. Default is tstop - tstart """ from astropy.io import fits import numpy.random as ra if event_list is None: tstart = assign_value_if_none(tstart, 8e+7) tstop = assign_value_if_none(tstop, tstart + 1025) ev_list = sorted(ra.uniform(tstart, tstop, 1000)) else: ev_list = event_list.time if hasattr(event_list, 'pi'): pi = event_list.pi else: pi = ra.randint(0, 1024, len(ev_list)) tstart = assign_value_if_none(tstart, np.floor(ev_list[0])) tstop = assign_value_if_none(tstop, np.ceil(ev_list[-1])) gti = assign_value_if_none(gti, np.array([[tstart, tstop]])) filename = assign_value_if_none(filename, 'events.evt') livetime = assign_value_if_none(livetime, tstop - tstart) if livetime > tstop - tstart: raise ValueError('Livetime must be equal or smaller than ' 'tstop - tstart') # Create primary header prihdr = fits.Header() prihdr['OBSERVER'] = 'Edwige Bubble' prihdr['TELESCOP'] = (mission, 'Telescope (mission) name') prihdr['INSTRUME'] = (instr, 'Instrument name') prihdu = fits.PrimaryHDU(header=prihdr) # Write events to table col1 = fits.Column(name='TIME', format='1D', array=ev_list) col2 = fits.Column(name='PI', format='1J', array=pi) allcols = [col1, col2] if mission.lower().strip() == 'xmm': ccdnr = np.zeros(len(ev_list)) + 1 ccdnr[1] = 2 # Make it less trivial ccdnr[10] = 7 allcols.append(fits.Column(name='CCDNR', format='1J', array=ccdnr)) for c in additional_columns.keys(): col = fits.Column(name=c, array=additional_columns[c]["data"], format=additional_columns[c]["format"]) allcols.append(col) cols = fits.ColDefs(allcols) tbhdu = fits.BinTableHDU.from_columns(cols) tbhdu.name = 'EVENTS' # ---- Fake lots of information ---- tbheader = tbhdu.header tbheader['OBSERVER'] = 'Edwige Bubble' tbheader['COMMENT'] = ("FITS (Flexible Image Transport System) format is" " defined in 'Astronomy and Astrophysics', volume" " 376, page 359; bibcode: 2001A&A...376..359H") tbheader['TELESCOP'] = (mission, 'Telescope (mission) name') tbheader['INSTRUME'] = (instr, 'Instrument name') tbheader['OBS_ID'] = ('00000000001', 'Observation ID') tbheader['TARG_ID'] = (0, 'Target ID') tbheader['OBJECT'] = ('Fake X-1', 'Name of observed object') tbheader['RA_OBJ'] = (0.0, '[deg] R.A. Object') tbheader['DEC_OBJ'] = (0.0, '[deg] Dec Object') tbheader['RA_NOM'] = (0.0, 'Right Ascension used for barycenter corrections') tbheader['DEC_NOM'] = (0.0, 'Declination used for barycenter corrections') tbheader['RA_PNT'] = (0.0, '[deg] RA pointing') tbheader['DEC_PNT'] = (0.0, '[deg] Dec pointing') tbheader['PA_PNT'] = (0.0, '[deg] Position angle (roll)') tbheader['EQUINOX'] = (2.000E+03, 'Equinox of celestial coord system') tbheader['RADECSYS'] = ('FK5', 'Coordinate Reference System') tbheader['TASSIGN'] = ('SATELLITE', 'Time assigned by onboard clock') tbheader['TIMESYS'] = ('TDB', 'All times in this file are TDB') tbheader['MJDREFI'] = (int(mjdref), 'TDB time reference; Modified Julian Day (int)') tbheader['MJDREFF'] = (mjdref - int(mjdref), 'TDB time reference; Modified Julian Day (frac)') tbheader['TIMEREF'] = ('SOLARSYSTEM', 'Times are pathlength-corrected to barycenter') tbheader['CLOCKAPP'] = (False, 'TRUE if timestamps corrected by gnd sware') tbheader['COMMENT'] = ("MJDREFI+MJDREFF = epoch of Jan 1, 2010, in TT " "time system.") tbheader['TIMEUNIT'] = ('s', 'unit for time keywords') tbheader['TSTART'] = (tstart, 'Elapsed seconds since MJDREF at start of file') tbheader['TSTOP'] = (tstop, 'Elapsed seconds since MJDREF at end of file') tbheader['LIVETIME'] = (livetime, 'On-source time') tbheader['TIMEZERO'] = (0.000000E+00, 'Time Zero') tbheader['COMMENT'] = ("Generated with HENDRICS by {0}".format( os.getenv('USER'))) # ---- END Fake lots of information ---- # Fake GTIs start = gti[:, 0] stop = gti[:, 1] col1 = fits.Column(name='START', format='1D', array=start) col2 = fits.Column(name='STOP', format='1D', array=stop) allcols = [col1, col2] cols = fits.ColDefs(allcols) gtinames = ['GTI'] if mission.lower().strip() == 'xmm': gtinames = ['STDGTI01', 'STDGTI02', 'STDGTI07'] all_new_hdus = [prihdu, tbhdu] for name in gtinames: gtihdu = fits.BinTableHDU.from_columns(cols) gtihdu.name = name all_new_hdus.append(gtihdu) thdulist = fits.HDUList(all_new_hdus) thdulist.writeto(filename, clobber=True) return thdulist
def add_all_broadband_flux(hdu_index=12, filter_index=11, params_index=3, bb_index=1, iq_index=5, aux_index=2, dirname='SCI_IMAGES', mod=10, startz=0.0, endz=12.0, has_aux=True, default=True): if not os.path.exists(dirname): os.makedirs(dirname) if has_aux == True: print "Note: Requires AUX HDU!!" if (has_aux == False) and (default == True): iq_index = iq_index - 1 hdu_index = hdu_index - 1 filter_index = filter_index - 1 params_index = params_index - 1 print iq_index nums = np.asarray([ '0055', '0056', '0057', '0059', '0060', '0061', '0062', '0063', '0064', '0065' ]) #nums=np.asarray(['0016','0017','0018','0019','0020']) bbfiles = np.sort(np.array(glob.glob('broadband*.fits'))) #[0:10] imind = hdu_index hdus = pyfits.open(bbfiles[0]) cambase = ((hdus)[imind]).data print cambase.shape singleslice = np.zeros_like(cambase[0, :, :]) #print singleslice.shape totalflux = np.zeros_like(cambase) fluxunit = hdus[imind].header.get('IMUNIT') print fluxunit pixscale = hdus[imind].header.get('CD1_1') partialflux = np.zeros_like(cambase) totalflux_dandanxu = np.zeros_like(cambase) block_dandanxu = np.zeros_like(cambase) totalflux_gfs = np.zeros_like(cambase) block_gfs = np.zeros_like(cambase) zweightslice = np.zeros_like(cambase) partialzweight = np.zeros_like(cambase) cambasezeros = np.zeros_like(cambase) totalsm = np.zeros_like(singleslice) partialsm = np.zeros_like(singleslice) totalsfr = np.zeros_like(singleslice) partialsfr = np.zeros_like(singleslice) totalstellarmetals = np.zeros_like(singleslice) partialstellarmetals = np.zeros_like(singleslice) smdata = np.zeros_like(singleslice) filter_hdu = hdus[filter_index] params_hdu = hdus[params_index] iq_hdu = hdus[iq_index] stellarmassunit = 'Msun' metalsunit = 'Msun' if has_aux == True: aux_hdu = hdus[aux_index] stellarmassunit = aux_hdu.header.get('MS_UNIT')[ 0:4] #+'(kpc^2)', we're gonna multiply by the pixel area metalsunit = aux_hdu.header.get('MMS_UNIT')[0:4] #+'(kpc^2)' Nfiles = (bbfiles.shape)[0] Nlambda = (iq_hdu.data.field('lambda')).shape[0] Nfilters = (filter_hdu.data.field('filter')).shape[0] z_array = np.ndarray(shape=(Nfiles)) pix_array = np.ndarray(shape=(Nfiles)) camD_array = np.ndarray(shape=(Nfiles)) fov_array = np.ndarray(shape=(Nfiles)) sm_array = np.ndarray(shape=(Nfiles)) mets_array = np.ndarray(shape=(Nfiles)) total_fov = params_hdu.header.get('FOV') # in radians pixel_fov_arcsec = (total_fov * 3600.0 * 180.0 / math.pi) / (1.0 * singleslice.shape[0]) L_lambda = np.ndarray(shape=(Nfiles, Nlambda)) L_lambda_unit = iq_hdu.header.get('TUNIT3') L_lambda_ns = np.ndarray(shape=(Nfiles, Nlambda)) L_lambda_ns_unit = iq_hdu.header.get('TUNIT5') L_lambda_out = np.ndarray(shape=(Nfiles, Nlambda)) L_lambda_out_unit = iq_hdu.header.get('TUNIT6') L_lambda_abs = np.ndarray(shape=(Nfiles, Nlambda)) L_lambda_abs_unit = iq_hdu.header.get('TUNIT4') lambda_eff = np.ndarray(shape=(Nfiles, Nfilters)) lambda_eff_unit = filter_hdu.header.get('TUNIT2') ewidth_lambda = np.ndarray(shape=(Nfiles, Nfilters)) ewidth_lambda_unit = filter_hdu.header.get('TUNIT3') ewidth_nu = np.ndarray(shape=(Nfiles, Nfilters)) ewidth_nu_unit = filter_hdu.header.get('TUNIT4') L_lambda_eff = np.ndarray(shape=(Nfiles, Nfilters)) L_lambda_eff_unit = filter_hdu.header.get('TUNIT5') AB_mag = np.ndarray(shape=(Nfiles, Nfilters)) L_lambda_eff_ns = np.ndarray(shape=(Nfiles, Nfilters)) L_lambda_eff_ns_unit = filter_hdu.header.get('TUNIT7') AB_mag_ns = np.ndarray(shape=(Nfiles, Nfilters)) intSB = np.ndarray(shape=(Nfiles, Nfilters)) intSB_unit = fluxunit cumSB = np.ndarray(shape=(Nfiles, Nfilters)) cumSB_unit = fluxunit filter_array = filter_hdu.data.field('filter') col = pyfits.Column(name='filter', format='A30', array=filter_array) filcols = pyfits.ColDefs([col]) filname_hdu = pyfits.new_table(filcols) filname_hdu.update_ext_name('FilterNames') lam_array = iq_hdu.data.field('lambda') lamunit = iq_hdu.header.get('TUNIT1') col = pyfits.Column(name='lambda', format='D', unit=lamunit, array=lam_array) lamcols = pyfits.ColDefs([col]) lamhdu = pyfits.new_table(lamcols) lamhdu.update_ext_name('Lambda') #lamhdu = pyfits.BinTableHDU(lamtab) extdata = asciitable.read( '/Users/gsnyder/Documents/Projects/Sunrise/sps_models/lmcave_ext_noheader.dat', Reader=asciitable.NoHeader) extlaminv = extdata['col1'] ext_AlamAV = extdata['col2'] #print extlaminv #print ext_AlamAV extlam_microns = 1.0 / extlaminv #return #dust params #b = -0.5 s = 0.35 #0.35 #0.35 #s = 1.35 b = -0.5 galscale_kpc = 20.0 Nfilters = (filter_array.shape)[0] Npixels = (1.0 * singleslice.shape[0])**2 i = 0 count = 0 slicecount = 0 initz = 0.0 # for ns in nums: # fn = 'broadband_'+ns+'.fits' for fn in bbfiles: count = count + 1 hdulist = pyfits.open(fn) #why? -- oh, to skip the addition if the run is still proceeding if len(hdulist) < imind + 1: continue camdata = ((hdulist)[imind]).data filhdu = hdulist[filter_index] bbhdu = hdulist[bb_index] iqhdu = hdulist[iq_index] camparhdu = hdulist[params_index] camhdu = hdulist[imind] auxhdu = hdulist[aux_index] redshift = bbhdu.header.get('redshift') if count % mod == 1: initz = redshift if redshift < startz: continue #if redshift > endz: # continue lambda_eff[i, :] = filhdu.data.field( 'lambda_eff') #; print filhdu.data.field('L_lambda_eff0').shape ewidth_lambda[i, :] = filhdu.data.field('ewidth_lambda') ewidth_nu[i, :] = filhdu.data.field('ewidth_nu') L_lambda_eff[i, :] = filhdu.data.field('L_lambda_eff0') AB_mag[i, :] = filhdu.data.field('AB_mag0') L_lambda_eff_ns[i, :] = filhdu.data.field('L_lambda_eff_nonscatter0') AB_mag_ns[i, :] = filhdu.data.field('AB_mag_nonscatter0') z_array[i] = redshift pix_array[i] = camhdu.header.get('CD1_1') camD_array[i] = camparhdu.header.get('cameradist') fov_array[i] = camparhdu.header.get('linear_fov') L_lambda[i, :] = iqhdu.data.field('L_lambda') L_lambda_ns[i, :] = iqhdu.data.field('L_lambda_nonscatter0') L_lambda_out[i, :] = iqhdu.data.field('L_lambda_out0') L_lambda_abs[i, :] = iqhdu.data.field('L_lambda_absorbed') nzindices = np.where( camdata[6, :, :] > 0.0 ) #nonzero indices -- this is checking the H-band WFC3 I assume? numnz = 1.0 * (nzindices[0].shape)[0] nzfrac = numnz / Npixels nz_kpcsq = nzfrac * pix_array[i]**2 print fn, redshift #, Npixels**0.5, numnz, nz_kpcsq, nzfrac, np.min(zweightslice), np.max(zweightslice) totalflux = totalflux + camdata partialflux = partialflux + camdata #is this part uber slow?? zweightslice = np.where( totalflux > 0.0, (((totalflux - camdata) * zweightslice + camdata * redshift) / totalflux), cambasezeros) partialzweight = np.where( partialflux > 0.0, (((partialflux - camdata) * partialzweight + camdata * redshift) / partialflux), cambasezeros) if has_aux == True: auxdata = auxhdu.data smdata = (auxdata)[4, :, :] smetalsdata = (auxdata)[5, :, :] # I THINK sfrdata = (auxdata)[2, :, :] gasmass = (auxdata)[0, :, :] metalmass = (auxdata)[1, :, :] sfrimage = (auxdata)[2, :, :] gastemp = (auxdata)[3, :, :] restframe_lambda_eff = ((1.0e6) * lambda_eff[i, :] / (1.0 + redshift)) restframe_invlambda_eff = 1.0 / restframe_lambda_eff Alambda_eff = np.interp(restframe_invlambda_eff.flatten(), extlaminv, ext_AlamAV) tau_f = np.zeros_like(gasmass) block_dandanxu = np.zeros_like(camdata) block_gfs = np.zeros_like(camdata) constantblock = np.zeros_like(gasmass) nonzero_gasmass_ind = np.where( gasmass > 0.0)[0] #; print nonzero_gasmass_ind.shape finite_gasmass_ind = np.isfinite(gasmass) sigma_pixels = (galscale_kpc / pix_array[i]) / (1.0 + redshift) print 'sigma in pixels ', sigma_pixels t = scipy.signal.gaussian(101, sigma_pixels) kernel = t.reshape(101, 1) * t.reshape(1, 101) kernel /= kernel.sum() gasmass_convolved = gasmass #scipy.ndimage.filters.gaussian_filter( gasmass, sigma_pixels) metalmass_convolved = metalmass #scipy.ndimage.filters.gaussian_filter( metalmass, sigma_pixels) logtemp = np.log10(gastemp) covering_factor = 1.0 #0.33 #0.1 + 0.9*(logtemp - 2.5)/(6.1-2.5) 'MOD5' metallicity_zsolar = (metalmass_convolved / gasmass_convolved) / 0.02 constantblock = covering_factor * ((1.0 + redshift)**b) * ( (metallicity_zsolar)** s) * (metalmass_convolved / 0.02) * 4.28e-8 for f in range(Nfilters): if (nonzero_gasmass_ind.shape)[0] < Npixels: continue Alam = Alambda_eff[f] tau_f = (Alam) * constantblock block_dandanxu[f, :, :] = (camdata[f, :, :] / tau_f) * ( 1.0 - np.exp(-1.0 * tau_f)) block_gfs[f, :, :] = camdata[f, :, :] * np.exp(-1.0 * tau_f) if f == 6 or f == 2: print Alam, np.max(logtemp), np.min(logtemp), np.max( covering_factor), np.min(covering_factor), np.mean( tau_f), np.max(tau_f), np.max(metallicity_zsolar) totalflux_dandanxu = totalflux_dandanxu + block_dandanxu totalflux_gfs = totalflux_gfs + block_gfs #print np.sum(totalflux), np.sum(totalflux_dandanxu) intSB[i, :] = np.sum(np.sum(camdata, axis=1), axis=1) cumSB[i, :] = np.sum(np.sum(totalflux, axis=1), axis=1) if has_aux == True: totalsm = totalsm + smdata * (pix_array[i]**2) #want per pixel^2 partialsm = partialsm + smdata * (pix_array[i]**2) totalsfr = totalsfr + sfrdata * (pix_array[i]**2 ) #want per pixel^2 partialsfr = partialsfr + sfrdata * (pix_array[i]**2) totalstellarmetals = totalstellarmetals + smetalsdata * ( pix_array[i]**2) #want per pixel^2 partialstellarmetals = partialstellarmetals + smetalsdata * ( pix_array[i]**2) sm_array[i] = np.sum(np.sum(smdata * (pix_array[i]**2), axis=0), axis=0) mets_array[i] = np.sum(np.sum(smetalsdata * (pix_array[i]**2), axis=0), axis=0) if (count % mod == 0) or (fn == bbfiles[-1]): #write partial flux slicecount = slicecount + 1 imagefile = os.path.join( dirname, 'bbslice_{:04d}'.format(slicecount) + '.fits') primhdu = pyfits.PrimaryHDU(partialflux) primhdu.header.update('zmin', initz) primhdu.header.update('zmax', redshift) primhdu.update_ext_name('sci') primhdu.header.update('IMUNIT', fluxunit) #sechdu = pyfits.ImageHDU(totalflux) #sechdu.update_ext_name('sci_cumulative') sechdu = pyfits.ImageHDU(partialsm) sechdu.update_ext_name('STELLAR_MASS') sechdu.header.update('IMUNIT', stellarmassunit) terhdu = pyfits.ImageHDU(partialstellarmetals) terhdu.update_ext_name('STELLAR_METALS_MASS') terhdu.header.update('IMUNIT', metalsunit) sfrhdu = pyfits.ImageHDU(partialsfr) sfrhdu.update_ext_name('SFR') sechdu.header.update('IMUNIT', stellarmassunit + '/yr') tempzhdu = pyfits.ImageHDU(partialzweight) tempzhdu.update_ext_name('ZWEIGHTSLICE') newlist = pyfits.HDUList( [primhdu, filhdu, sechdu, terhdu, tempzhdu, sfrhdu]) newlist.writeto(imagefile, clobber=True) partialflux = np.zeros_like(cambase) partialsm = np.zeros_like(singleslice) partialstellarmetals = np.zeros_like(singleslice) partialzweight = np.zeros_like(cambase) i = i + 1 hdulist.close() primhdu = pyfits.PrimaryHDU(totalflux) primhdu.header.update('IMUNIT', fluxunit) primhdu.header.update('PIXSCALE', pixel_fov_arcsec) sfrhdu = pyfits.ImageHDU(totalsfr) sfrhdu.update_ext_name('SFR') sfrhdu.header.update('IMUNIT', stellarmassunit + '/yr') sechdu = pyfits.ImageHDU(totalsm) sechdu.update_ext_name('STELLAR_MASS') sechdu.header.update('IMUNIT', stellarmassunit) terhdu = pyfits.ImageHDU(totalstellarmetals) terhdu.update_ext_name('STELLAR_METALS_MASS') terhdu.header.update('IMUNIT', metalsunit) dusthdu = pyfits.ImageHDU(totalflux_dandanxu) dusthdu.header.update('IMUNIT', fluxunit) dusthdu.update_ext_name('SEMIANALYTIC_DUST') gfshdu = pyfits.ImageHDU(totalflux_gfs) gfshdu.header.update('IMUNIT', fluxunit) gfshdu.update_ext_name('GFS_SCREEN_DUST') #zweightvalues = np.where(totalflux > 0.0, zweightslice/totalflux, cambasezeros - 1.0) zhdu = pyfits.ImageHDU(zweightslice) zhdu.update_ext_name('WEIGHTED_Z') L_lambda_hdu = pyfits.ImageHDU(L_lambda) L_lambda_hdu.update_ext_name('L_lambda') L_lambda_hdu.header.update('UNIT', L_lambda_unit) L_lambda_ns_hdu = pyfits.ImageHDU(L_lambda_ns) L_lambda_ns_hdu.update_ext_name('L_lambda_nonscatter') L_lambda_ns_hdu.header.update('UNIT', L_lambda_ns_unit) L_lambda_out_hdu = pyfits.ImageHDU(L_lambda_out) L_lambda_out_hdu.update_ext_name('L_lambda_out') L_lambda_out_hdu.header.update('UNIT', L_lambda_out_unit) L_lambda_abs_hdu = pyfits.ImageHDU(L_lambda_abs) L_lambda_abs_hdu.update_ext_name('L_lambda_absorption') L_lambda_abs_hdu.header.update('UNIT', L_lambda_abs_unit) filhdu1 = pyfits.ImageHDU(lambda_eff) filhdu1.update_ext_name('lambda_eff') filhdu1.header.update('UNIT', lambda_eff_unit) filhdu2 = pyfits.ImageHDU(ewidth_lambda) filhdu2.update_ext_name('ewidth_lambda') filhdu2.header.update('UNIT', ewidth_lambda_unit) filhdu3 = pyfits.ImageHDU(ewidth_nu) filhdu3.update_ext_name('ewidth_nu') filhdu3.header.update('UNIT', ewidth_nu_unit) filhdu4 = pyfits.ImageHDU(L_lambda_eff) filhdu4.update_ext_name('L_lambda_eff') filhdu4.header.update('UNIT', L_lambda_eff_unit) filhdu5 = pyfits.ImageHDU(AB_mag) filhdu5.update_ext_name('AB_mag') filhdu6 = pyfits.ImageHDU(L_lambda_eff_ns) filhdu6.update_ext_name('L_lambda_eff_nonscatter') filhdu6.header.update('UNIT', L_lambda_eff_ns_unit) filhdu7 = pyfits.ImageHDU(AB_mag_ns) filhdu7.update_ext_name('AB_mag_nonscatter') filhdu8 = pyfits.ImageHDU(intSB) filhdu8.update_ext_name('total_SB') filhdu8.header.update('UNIT', intSB_unit) filhdu9 = pyfits.ImageHDU(cumSB) filhdu9.update_ext_name('cumulative_SB') filhdu9.header.update('UNIT', cumSB_unit) col1 = pyfits.Column(name='redshift', format='D', array=z_array) col2 = pyfits.Column(name='pixelscale', format='D', unit='kpc', array=pix_array) col3 = pyfits.Column(name='cameradistance', format='D', unit='kpc', array=camD_array) col4 = pyfits.Column(name='linearfov', format='D', unit='kpc', array=fov_array) col5 = pyfits.Column(name='stellarmass', format='D', unit=stellarmassunit, array=sm_array) col6 = pyfits.Column(name='stellarmetalsmass', format='D', unit=metalsunit, array=mets_array) cols = pyfits.ColDefs([col1, col2, col3, col4, col5, col6]) geometryhdu = pyfits.new_table(cols) geometryhdu.update_ext_name('GEOMETRY') newlist = pyfits.HDUList([ primhdu, dusthdu, gfshdu, sechdu, terhdu, sfrhdu, zhdu, geometryhdu, lamhdu, L_lambda_hdu, L_lambda_ns_hdu, L_lambda_out_hdu, L_lambda_abs_hdu, filname_hdu, filhdu1, filhdu2, filhdu3, filhdu4, filhdu5, filhdu6, filhdu7, filhdu8, filhdu9 ]) newlist.writeto(os.path.join(dirname, 'bbdata.fits'), clobber=True) result = write_filtered_images(totalflux, filter_hdu, dirname=dirname, imunit=fluxunit) subprocess.call(['cp', 'sfrhist_base.stub', dirname]) subprocess.call(['cp', 'mcrx_base.stub', dirname]) subprocess.call(['cp', 'broadband_base.stub', dirname]) subprocess.call(['cp', 'simpar', dirname]) return totalflux
def make_savefile(simname, haloname, simdir, DD, ds, ad): DDname = 'DD%.4i' % DD mss = ad['stars', 'particle_mass'].in_units('Msun') msd = ad['darkmatter', 'particle_mass'].in_units('Msun') ags = ad['stars', 'age'].in_units('Gyr') agd = ad['darkmatter', 'age'].in_units('Gyr') xs_box = ad['stars', 'particle_position_x'].in_units('kpc') ys_box = ad['stars', 'particle_position_y'].in_units('kpc') zs_box = ad['stars', 'particle_position_z'].in_units('kpc') vxs_box = ad['stars', 'particle_velocity_x'].in_units('km/s') vys_box = ad['stars', 'particle_velocity_y'].in_units('km/s') vzs_box = ad['stars', 'particle_velocity_z'].in_units('km/s') xd_box = ad['darkmatter', 'particle_position_x'].in_units('kpc') yd_box = ad['darkmatter', 'particle_position_y'].in_units('kpc') zd_box = ad['darkmatter', 'particle_position_z'].in_units('kpc') vxd_box = ad['darkmatter', 'particle_velocity_x'].in_units('km/s') vyd_box = ad['darkmatter', 'particle_velocity_y'].in_units('km/s') vzd_box = ad['darkmatter', 'particle_velocity_z'].in_units('km/s') ids = ad['stars', 'particle_index'] idd = ad['darkmatter', 'particle_index'] hdus = [] prim_hdu = fits.PrimaryHDU() hdus.append(prim_hdu) colss = fits.ColDefs([ fits.Column(name='id', array=ids, format='D'), fits.Column(name='mass', array=mss, format='D'), fits.Column(name='x_box ', array=xs_box, format='D'), fits.Column(name='y_box ', array=ys_box, format='D'), fits.Column(name='z_box ', array=zs_box, format='D'), fits.Column(name='vx_box ', array=vxs_box, format='D'), fits.Column(name='vy_box ', array=vys_box, format='D'), fits.Column(name='vz_box ', array=vzs_box, format='D'), fits.Column(name='age', array=ags, format='D'), ]) colsd = fits.ColDefs([ fits.Column(name='id', array=idd, format='D'), fits.Column(name='mass', array=msd, format='D'), fits.Column(name='x_box ', array=xd_box, format='D'), fits.Column(name='y_box ', array=yd_box, format='D'), fits.Column(name='z_box ', array=zd_box, format='D'), fits.Column(name='vx_box ', array=vxd_box, format='D'), fits.Column(name='vy_box ', array=vyd_box, format='D'), fits.Column(name='vz_box ', array=vzd_box, format='D'), fits.Column(name='age', array=agd, format='D'), ]) hdus.append(fits.BinTableHDU.from_columns(colss, name='stars')) hdus.append(fits.BinTableHDU.from_columns(colsd, name='dark')) hdus_fits = fits.HDUList(hdus) hdus_fits.writeto( '/nobackupp2/rcsimons/foggie_momentum/particles/%s/%s/%s_DD%.4i_particles.fits' % (haloname, simname, simname, DD), overwrite=True)
col6 = fits.Column(name='star name (TYC)', format='20A', array=np.array(six)) col7 = fits.Column(name='field id', format='20A', array=np.array(seven)) col8 = fits.Column(name='image url', format='55A', array=np.array(eight)) col9 = fits.Column(name='r (pix)', format='E', array=np.array(nine)) col10 = fits.Column(name='r (arcsec)', format='E', array=np.array(ten)) col11 = fits.Column(name='no Vmag data', format='5A', array=np.array(eleven)) cols = fits.ColDefs([ col1, col2, col7, col6, col3, col4, col5, col8, col9, col10, col11 ]) tbhdu = fits.BinTableHDU.from_columns(cols) tbhdu.writeto('HEARTStars' + str(magMin) + '-' + str(magMax) + '_PART.fits', clobber=True) save = save + 1000 j += 1 #When all stars and images are tested, all cases where a star #falls on or near an image are stored to a fits table. col1 = fits.Column(name='run', format='20A', array=np.array(one)) col2 = fits.Column(name='ccd', format='20A', array=np.array(two)) col3 = fits.Column(name='star mag', format='20A', array=np.array(three)) col4 = fits.Column(name='star ra', format='E', array=np.array(four))
def desi_qso_templates(z_wind=0.2, zmnx=(0.4,4.), outfil=None, N_perz=500, boss_pca_fil=None, wvmnx=(3500., 10000.), rebin_wave=None, rstate=None, sdss_pca_fil=None, no_write=False, redshift=None, seed=None, old_read=False, ipad=40, cosmo=None): """ Generate QSO templates for DESI Rebins to input wavelength array (or log10 in wvmnx) Parameters ---------- z_wind : float, optional Window for sampling PCAs zmnx : tuple, optional Min/max for generation N_perz : int, optional Number of draws per redshift window old_read : bool, optional Read the files the old way seed : int, optional Seed for the random number state rebin_wave : ndarray, optional Input wavelengths for rebinning wvmnx : tuple, optional Wavelength limits for rebinning (not used with rebin_wave) redshift : ndarray, optional Redshifts desired for the templates ipad : int, optional Padding for enabling enough models cosmo: astropy.cosmology.core, optional Cosmology inistantiation from astropy.cosmology.code Returns ------- wave : ndarray Wavelengths that the spectra were rebinned to flux : ndarray (2D; flux vs. model) z : ndarray Redshifts """ # Cosmology if cosmo is None: from astropy import cosmology cosmo = cosmology.core.FlatLambdaCDM(70., 0.3) if old_read: # PCA values if boss_pca_fil is None: boss_pca_fil = 'BOSS_DR10Lya_PCA_values_nocut.fits.gz' hdu = fits.open(boss_pca_fil) boss_pca_coeff = hdu[1].data if sdss_pca_fil is None: sdss_pca_fil = 'SDSS_DR7Lya_PCA_values_nocut.fits.gz' hdu2 = fits.open(sdss_pca_fil) sdss_pca_coeff = hdu2[1].data # Open the BOSS catalog file boss_cat_fil = os.environ.get('BOSSPATH')+'/DR10/BOSSLyaDR10_cat_v2.1.fits.gz' bcat_hdu = fits.open(boss_cat_fil) t_boss = bcat_hdu[1].data boss_zQSO = t_boss['z_pipe'] # Open the SDSS catalog file sdss_cat_fil = os.environ.get('SDSSPATH')+'/DR7_QSO/dr7_qso.fits.gz' scat_hdu = fits.open(sdss_cat_fil) t_sdss = scat_hdu[1].data sdss_zQSO = t_sdss['z'] if len(sdss_pca_coeff) != len(sdss_zQSO): print('Need to finish running the SDSS models!') sdss_zQSO = sdss_zQSO[0:len(sdss_pca_coeff)] # Eigenvectors eigen, eigen_wave = fbq.read_qso_eigen() else: infile = desisim.io.find_basis_template('qso') with fits.open(infile) as hdus: hdu_names = [hdus[ii].name for ii in range(len(hdus))] boss_pca_coeff = hdus[hdu_names.index('BOSS_PCA')].data sdss_pca_coeff = hdus[hdu_names.index('SDSS_PCA')].data boss_zQSO = hdus[hdu_names.index('BOSS_Z')].data sdss_zQSO = hdus[hdu_names.index('SDSS_Z')].data eigen = hdus[hdu_names.index('SDSS_EIGEN')].data eigen_wave = hdus[hdu_names.index('SDSS_EIGEN_WAVE')].data # Fiddle with the eigen-vectors npix = len(eigen_wave) chkpix = np.where((eigen_wave > 900.) & (eigen_wave < 5000.) )[0] lambda_912 = 911.76 pix912 = np.argmin( np.abs(eigen_wave-lambda_912) ) # Loop on redshift. If the if redshift is None: z0 = np.arange(zmnx[0],zmnx[1],z_wind) z1 = z0 + z_wind else: if np.isscalar(redshift): z0 = np.array([redshift]) else: z0 = redshift.copy() z1 = z0.copy() #+ z_wind pca_list = ['PCA0', 'PCA1', 'PCA2', 'PCA3'] PCA_mean = np.zeros(4) PCA_sig = np.zeros(4) PCA_rand = np.zeros((4,N_perz*ipad)) final_spec = np.zeros((npix, N_perz * len(z0))) final_wave = np.zeros((npix, N_perz * len(z0))) final_z = np.zeros(N_perz * len(z0)) # Random state if rstate is None: rstate = np.random.RandomState(seed) for ii in range(len(z0)): # BOSS or SDSS? if z0[ii] > 2.15: zQSO = boss_zQSO pca_coeff = boss_pca_coeff else: zQSO = sdss_zQSO pca_coeff = sdss_pca_coeff # Random z values and wavelengths zrand = rstate.uniform( z0[ii], z1[ii], N_perz*ipad) wave = np.outer(eigen_wave, 1+zrand) # MFP (Worseck+14) mfp = 37. * ( (1+zrand)/5. )**(-5.4) # Physical Mpc # Grab PCA mean + sigma if redshift is None: idx = np.where( (zQSO >= z0[ii]) & (zQSO < z1[ii]) )[0] else: # Hack by @moustakas: add a little jitter to get the set of QSOs # that are *nearest* in redshift to the desired output redshift. idx = np.where( (zQSO >= z0[ii]-0.01) & (zQSO < z1[ii]+0.01) )[0] if len(idx) == 0: idx = np.array([(np.abs(zQSO-zrand[0])).argmin()]) #pdb.set_trace() log.debug('Making z=({:g},{:g}) with {:d} input quasars'.format(z0[ii],z1[ii],len(idx))) # Get PCA stats and random values for jj,ipca in enumerate(pca_list): if jj == 0: # Use bounds for PCA0 [avoids negative values] xmnx = perc(pca_coeff[ipca][idx], per=95) PCA_rand[jj, :] = rstate.uniform(xmnx[0], xmnx[1], N_perz*ipad) else: PCA_mean[jj] = np.mean(pca_coeff[ipca][idx]) PCA_sig[jj] = np.std(pca_coeff[ipca][idx]) # Draws PCA_rand[jj, :] = rstate.uniform( PCA_mean[jj] - 2*PCA_sig[jj], PCA_mean[jj] + 2*PCA_sig[jj], N_perz*ipad) # Generate the templates (ipad*N_perz) spec = np.dot(eigen.T, PCA_rand) # Take first good N_perz # Truncate, MFP, Fill ngd = 0 nbad = 0 for kk in range(ipad*N_perz): # Any zero values? mn = np.min(spec[chkpix, kk]) if mn < 0.: nbad += 1 continue # MFP if z0[ii] > 2.39: z912 = wave[0:pix912,kk]/lambda_912 - 1. phys_dist = np.fabs( cosmo.lookback_distance(z912) - cosmo.lookback_distance(zrand[kk]) ) # Mpc spec[0:pix912, kk] = spec[0:pix912,kk] * np.exp(-phys_dist.value/mfp[kk]) # Write final_spec[:, ii*N_perz+ngd] = spec[:,kk] final_wave[:, ii*N_perz+ngd] = wave[:,kk] final_z[ii*N_perz+ngd] = zrand[kk] ngd += 1 if ngd == N_perz: break if ngd != N_perz: print('Did not make enough!') #pdb.set_trace() log.warning('Did not make enough qso templates. ngd = {}, N_perz = {}'.format(ngd,N_perz)) # Rebin if rebin_wave is None: light = C_LIGHT # [km/s] velpixsize = 10. # [km/s] pixsize = velpixsize/light/np.log(10) # [pixel size in log-10 A] minwave = np.log10(wvmnx[0]) # minimum wavelength [log10-A] maxwave = np.log10(wvmnx[1]) # maximum wavelength [log10-A] r_npix = np.round((maxwave-minwave)/pixsize+1) log_wave = minwave+np.arange(r_npix)*pixsize # constant log-10 spacing else: log_wave = np.log10(rebin_wave) r_npix = len(log_wave) totN = N_perz * len(z0) rebin_spec = np.zeros((r_npix, totN)) for ii in range(totN): # Interpolate (in log space) rebin_spec[:, ii] = resample_flux(log_wave, np.log10(final_wave[:, ii]), final_spec[:, ii]) #f1d = interp1d(np.log10(final_wave[:,ii]), final_spec[:,ii]) #rebin_spec[:,ii] = f1d(log_wave) if outfil is None: return 10.**log_wave, rebin_spec, final_z # Transpose for consistency out_spec = np.array(rebin_spec.T, dtype='float32') # Write hdu = fits.PrimaryHDU(out_spec) hdu.header.set('PROJECT', 'DESI QSO TEMPLATES') hdu.header.set('VERSION', '1.1') hdu.header.set('OBJTYPE', 'QSO') hdu.header.set('DISPAXIS', 1, 'dispersion axis') hdu.header.set('CRPIX1', 1, 'reference pixel number') hdu.header.set('CRVAL1', minwave, 'reference log10(Ang)') hdu.header.set('CDELT1', pixsize, 'delta log10(Ang)') hdu.header.set('LOGLAM', 1, 'log10 spaced wavelengths?') hdu.header.set('AIRORVAC', 'vac', ' wavelengths in vacuum (vac) or air') hdu.header.set('VELSCALE', velpixsize, ' pixel size in km/s') hdu.header.set('WAVEUNIT', 'Angstrom', ' wavelength units') hdu.header.set('BUNIT', '1e-17 erg/s/cm2/A', ' flux unit') idval = list(range(totN)) col0 = fits.Column(name=str('TEMPLATEID'),format=str('J'), array=idval) col1 = fits.Column(name=str('Z'),format=str('E'),array=final_z) cols = fits.ColDefs([col0, col1]) tbhdu = fits.BinTableHDU.from_columns(cols) tbhdu.header.set('EXTNAME','METADATA') hdulist = fits.HDUList([hdu, tbhdu]) hdulist.writeto(outfil, overwrite=True) return final_wave, final_spec, final_z
def write_fits_spec(filename, wavelengths, fluxes, pri_header={}, ext_header={}, overwrite=False, trim_zero=True, pad_zero_ends=True, precision=None, epsilon=0.00032, wave_col='WAVELENGTH', flux_col='FLUX', wave_unit=u.AA, flux_unit=units.FLAM): """Write FITS spectrum. .. warning:: If data is being written out as single-precision but wavelengths are in double-precision, some rows may be omitted. Parameters ---------- filename : str Output spectrum filename. wavelengths, fluxes : array-like or `~astropy.units.quantity.Quantity` Wavelength and flux of the spectrum. pri_header, ext_header : dict Metadata to be added to primary and given extension FITS header, respectively. Do *not* use this to define column names and units. overwrite : bool Overwrite existing file. Defaults to `False`. trim_zero : bool Remove rows with zero-flux. Default is `True`. pad_zero_ends : bool Pad each end of the spectrum with a row of zero flux like :func:`synphot.spectrum.BaseSpectrum.taper`. This is unnecessary if input is already tapered. precision : {`None`, 'single', 'double'} Precision of values in output file. Use native flux precision by default. epsilon : float Single-precision :math:`\\epsilon` value, taken from IRAF SYNPHOT FAQ. This is the minimum separation in wavelengths necessary for SYNPHOT to read the entries as distinct single-precision numbers. This is *only* used if ``precision='single'`` but data are in double-precision. Default from the FAQ is 0.00032. wave_col, flux_col : str Wavelength and flux column names (case-insensitive). wave_unit, flux_unit : str or `~astropy.units.core.Unit` Wavelength and flux units, which default to Angstrom and FLAM, respectively. These are *only* used if wavelengths and fluxes are not in astropy quantities. Raises ------ synphot.exceptions.SynphotError Wavelengths and fluxes have difference shapes or value precision is not supported. """ if isinstance(wavelengths, u.Quantity): wave_unit = wavelengths.unit wave_value = wavelengths.value else: wave_value = wavelengths if isinstance(fluxes, u.Quantity): flux_unit = fluxes.unit flux_value = fluxes.value else: flux_value = fluxes wave_unit = units.validate_unit(wave_unit).to_string().upper() flux_unit = units.validate_unit(flux_unit).to_string().upper() if wave_value.shape != flux_value.shape: raise exceptions.SynphotError( 'Wavelengths have shape {0} but fluxes have shape {1}'.format( wave_value.shape, flux_value.shape)) # Remove rows with zero flux. Putting this before precision logic to avoid # keeping duplicate wavelengths with zero flux. if trim_zero: idx = np.where(flux_value != 0) wave_value = wave_value[idx] flux_value = flux_value[idx] n_thrown = wave_value.size - len(idx[0]) if n_thrown != 0: log.info('{0} zero-flux rows are thrown out'.format(n_thrown)) # Only these Numpy types are supported # 'f' np.float32 # 'd' np.float64 pcodes = {'d': 'D', 'f': 'E'} # Numpy to FITS conversion # Use native flux precision if precision is None: precision = flux_value.dtype.char if precision not in pcodes: raise exceptions.SynphotError('flux is not float32 or float64') # Use user specified precision else: precision = precision.lower() if precision == 'single': precision = 'f' elif precision == 'double': precision = 'd' else: raise exceptions.SynphotError('precision must be single or double') # Now check wavelength precision wave_precision = wave_value.dtype.char if wave_precision not in pcodes: raise exceptions.SynphotError('wavelength is not float32 or float64') # If wavelength is double-precision but data is written out as # single-precision, wavelength values have to be recalculated # so that they will still be sorted with no duplicates. if wave_precision == 'd' and precision == 'f': orig_size = wave_value.size idx = np.where(np.abs(wave_value[1:] - wave_value[:-1]) > epsilon) wave_value = np.append(wave_value[idx], wave_value[-1]) flux_value = np.append(flux_value[idx], flux_value[-1]) n_thrown = orig_size - wave_value.size if n_thrown != 0: warnings.warn( '{0} rows are thrown out in converting wavelengths from ' 'double- to single-precision'.format(n_thrown), AstropyUserWarning) # Keep one zero at each end if pad_zero_ends: w1 = wave_value[0]**2 / wave_value[1] w2 = wave_value[-1]**2 / wave_value[-2] wave_value = np.insert(wave_value, [0, wave_value.size], [w1, w2]) flux_value = np.insert(flux_value, [0, flux_value.size], [0.0, 0.0]) # Construct the columns cw = fits.Column(name=wave_col, array=wave_value, unit=wave_unit, format=pcodes[precision]) cf = fits.Column(name=flux_col, array=flux_value, unit=flux_unit, format=pcodes[precision]) # These are written to the primary header: # 1. Filename # 2. Origin # 3. User dictionary (can overwrite defaults) hdr_hdu = fits.PrimaryHDU() hdr_hdu.header['filename'] = (os.path.basename(filename), 'name of file') hdr_hdu.header['origin'] = ('synphot', 'Version {0}'.format(__version__)) for key, val in pri_header.items(): hdr_hdu.header[key] = val # Make the extension HDU and include user dictionary in extension header. tab_hdu = fits.BinTableHDU.from_columns(fits.ColDefs([cw, cf])) for key, val in ext_header.items(): tab_hdu.header[key] = val # Write to file hdulist = fits.HDUList([hdr_hdu]) hdulist.append(tab_hdu) hdulist.writeto(filename, overwrite=overwrite)
def kepextract(infile, outfile, maskfile='ALL', bkg=False, psfcentroid=False, overwrite=False, verbose=False, logfile='kepextract.log'): """ kepextract -- create a light curve from a target pixel file by summing user-selected pixels kepextract calculates simple aperture photometry, from a target pixel file, for a user-supplied set of pixels. The Kepler pipeline sums a specific set of pixels to produce the standard light curves delivered to users. Termed the optimal aperture, the default pixel set is designed to maximize the signal-to-noise ratio of the resulting light curve, optimizing for transit detection. This tool provides users with a straightforward capability to alter the summed pixel set. Applications include: * Use of all pixels in the aperture * The pipeline does not produce a light curve for sources observed with custom or dedicated pixel masks. The user can create a light curve for these sources using kepextract. * Construction of pixel light curves, in which the time series for a single pixel can be examined. Light curves for extended sources which may be poorly sampled by the optimal aperture. Parameters ---------- infile : str Filename for the target pixel file. outfile : str Filename for the output light curve. This product will be written to the same FITS format as archived light curves. maskfile : str This string can be one of three options:: * 'ALL' tells the task to calculate principal components from all pixels within the pixel mask stored in the input file. * 'APER' tells the task to calculate principal components from only the pixels within the photometric aperture stored in the input file (e.g. only those pixels summed by the Kepler pipeline to produce the light curve archived at MAST. * A filename describing the desired photometric aperture. Such a file can be constructed using the kepmask or kepffi tools, or can be created manually using the format described in the documentation for those tools. bkg : bool Option to subtract an estimate of the background. Background is calculated by identifying the median pixel value for each exposure. This method requires an adequate number of pixels in within the target mask that contain background and negligible source flux. Note that background has already been subtracted from calibrated Kepler Target Pixel Files, but not early campaign data from the K2 mission. psfcentroid : bool Measure the star's position by fitting a 2D Gaussian PSF to the pixels in the mask. This will populate values for PSF_CENTR1 (column position) and PSF_CENTR2 (row position) in the output file. overwrite : bool Overwrite the output file? verbose : bool Option for verbose mode, in which informative messages and warnings to the shell and a logfile. logfile : str Name of the logfile containing error and warning messages. Examples -------- .. code-block:: bash $ kepextract kplr008256049-2010174085026_lpd-targ.fits outlc.fits --maskfile ALL One further can plot the resulted light curve by doing .. code-block:: python import matplotlib.pyplot as plt from astropy.io import fits f = fits.open('outlc.fits') plt.plot(f[1].data['TIME'], f[1].data['SAP_FLUX']) or .. code-block:: bash $ kepdraw outlc.fits .. image:: ../_static/images/api/kepextract.png :align: center """ # log the call hashline = '--------------------------------------------------------------' kepmsg.log(logfile, hashline, verbose) call = ('KEPEXTRACT -- ' + ' infile={}'.format(infile) + ' maskfile={}'.format(maskfile) + ' outfile={}'.format(outfile) + ' background={}'.format(bkg) + ' psfcentroid={}'.format(psfcentroid) + ' overwrite={}'.format(overwrite) + ' verbose={}'.format(verbose) + ' logfile={}'.format(logfile)) kepmsg.log(logfile, call + '\n', verbose) # start time kepmsg.clock('KEPEXTRACT started at', logfile, verbose) # overwrite output file if overwrite: kepio.overwrite(outfile, logfile, verbose) if kepio.fileexists(outfile): errmsg = ( 'ERROR -- KEPEXTRACT: {} exists. Use --overwrite'.format(outfile)) kepmsg.err(logfile, errmsg, verbose) # open input file instr = pyfits.open(infile, mode='readonly', memmap=True) tstart, tstop, bjdref, cadence = kepio.timekeys(instr, infile, logfile, verbose) # fudge non-compliant FITS keywords with no values instr = kepkey.emptykeys(instr, infile, logfile, verbose) # input file data cards0 = instr[0].header.cards cards1 = instr[1].header.cards cards2 = instr[2].header.cards table = instr[1].data[:] maskmap = copy(instr[2].data) print("Extracting information from Target Pixel File...") # input table data kepid, channel, skygroup, module, output, quarter, season, \ ra, dec, column, row, kepmag, xdim, ydim, time = \ kepio.readTPF(infile, 'TIME', logfile, verbose) time = np.array(time, dtype='float64') kepid, channel, skygroup, module, output, quarter, season, \ ra, dec, column, row, kepmag, xdim, ydim, timecorr = \ kepio.readTPF(infile, 'TIMECORR', logfile, verbose) timecorr = np.array(timecorr, dtype='float32') kepid, channel, skygroup, module, output, quarter, season, \ ra, dec, column, row, kepmag, xdim, ydim, cadenceno = \ kepio.readTPF(infile, 'CADENCENO', logfile, verbose) cadenceno = np.array(cadenceno, dtype='int') kepid, channel, skygroup, module, output, quarter, season, \ ra, dec, column, row, kepmag, xdim, ydim, raw_cnts = \ kepio.readTPF(infile, 'RAW_CNTS', logfile, verbose) kepid, channel, skygroup, module, output, quarter, season, \ ra, dec, column, row, kepmag, xdim, ydim, flux = \ kepio.readTPF(infile, 'FLUX', logfile, verbose) kepid, channel, skygroup, module, output, quarter, season, \ ra, dec, column, row, kepmag, xdim, ydim, flux_err = \ kepio.readTPF(infile, 'FLUX_ERR', logfile, verbose) kepid, channel, skygroup, module, output, quarter, season, \ ra, dec, column, row, kepmag, xdim, ydim, flux_bkg = \ kepio.readTPF(infile, 'FLUX_BKG', logfile, verbose) kepid, channel, skygroup, module, output, quarter, season, \ ra, dec, column, row, kepmag, xdim, ydim, flux_bkg_err = \ kepio.readTPF(infile, 'FLUX_BKG_ERR', logfile, verbose) kepid, channel, skygroup, module, output, quarter, season, \ ra, dec, column, row, kepmag, xdim, ydim, cosmic_rays = \ kepio.readTPF(infile, 'COSMIC_RAYS', logfile, verbose) kepid, channel, skygroup, module, output, quarter, season, \ ra, dec, column, row, kepmag, xdim, ydim, quality = \ kepio.readTPF(infile, 'QUALITY', logfile, verbose) quality = np.array(quality, dtype='int') try: # ---for FITS wave #2 pos_corr1 = np.array(table.field('POS_CORR1'), dtype='float64') except: pos_corr1 = np.empty(len(time)) # ---temporary before FITS wave #2 pos_corr1[:] = np.nan try: # ---for FITS wave #2 pos_corr2 = np.array(table.field('POS_CORR2'), dtype='float64') except: pos_corr2 = np.empty(len(time)) # ---temporary before FITS wave #2 pos_corr2[:] = np.nan # dummy columns for output file psf_centr1 = np.empty(len(time)) psf_centr1[:] = np.nan psf_centr2 = np.empty(len(time)) psf_centr2[:] = np.nan mom_centr1 = np.empty(len(time)) mom_centr1[:] = np.nan mom_centr2 = np.empty(len(time)) mom_centr2[:] = np.nan psf_centr1_err = np.empty(len(time)) psf_centr1_err[:] = np.nan psf_centr2_err = np.empty(len(time)) psf_centr2_err[:] = np.nan mom_centr1_err = np.empty(len(time)) mom_centr1_err[:] = np.nan mom_centr2_err = np.empty(len(time)) mom_centr2_err[:] = np.nan # read mask definition file if 'aper' not in maskfile.lower() and maskfile.lower() != 'all': maskx = np.array([], 'int') masky = np.array([], 'int') lines = kepio.openascii(maskfile, 'r', logfile, verbose) for line in lines: line = line.strip().split('|') if len(line) == 6: y0 = int(line[3]) x0 = int(line[4]) line = line[5].split(';') for items in line: try: masky = np.append(masky, y0 + int(items.split(',')[0])) maskx = np.append(maskx, x0 + int(items.split(',')[1])) except: continue kepio.closeascii(lines, logfile, verbose) if len(maskx) == 0 or len(masky) == 0: errmsg = 'ERROR -- KEPEXTRACT: {} contains no pixels.'.format( maskfile) kepmsg.err(logfile, errmsg, verbose) # subimage physical WCS data crpix1p = cards2['CRPIX1P'].value crpix2p = cards2['CRPIX2P'].value crval1p = cards2['CRVAL1P'].value crval2p = cards2['CRVAL2P'].value cdelt1p = cards2['CDELT1P'].value cdelt2p = cards2['CDELT2P'].value # define new subimage bitmap... if 'aper' not in maskfile.lower() and maskfile.lower() != 'all': aperx = np.array([], 'int') apery = np.array([], 'int') aperb = np.array([], 'int') for i in range(maskmap.shape[0]): for j in range(maskmap.shape[1]): aperx = np.append(aperx, crval1p + (j + 1 - crpix1p) * cdelt1p) apery = np.append(apery, crval2p + (i + 1 - crpix2p) * cdelt2p) if maskmap[i, j] == 0: aperb = np.append(aperb, 0) else: aperb = np.append(aperb, 1) maskmap[i, j] = 1 for k in range(len(maskx)): if aperx[-1] == maskx[k] and apery[-1] == masky[k]: aperb[-1] = 3 maskmap[i, j] = 3 # trap case where no aperture needs to be defined but pixel positions are # still required for centroiding if maskfile.lower() == 'all': aperx = np.array([], 'int') apery = np.array([], 'int') aperb = np.array([], 'int') for i in range(maskmap.shape[0]): for j in range(maskmap.shape[1]): aperx = np.append(aperx, crval1p + (j + 1 - crpix1p) * cdelt1p) apery = np.append(apery, crval2p + (i + 1 - crpix2p) * cdelt2p) if maskmap[i, j] == 0: aperb = np.append(aperb, 0) else: aperb = np.append(aperb, 3) maskmap[i, j] = 3 # ...or use old subimage bitmap if 'aper' in maskfile.lower(): aperx = np.array([], 'int') apery = np.array([], 'int') aperb = np.array([], 'int') for i in range(maskmap.shape[0]): for j in range(maskmap.shape[1]): aperb = np.append(aperb, maskmap[i, j]) aperx = np.append(aperx, crval1p + (j + 1 - crpix1p) * cdelt1p) apery = np.append(apery, crval2p + (i + 1 - crpix2p) * cdelt2p) # subtract median pixel value for background? sky = np.zeros(len(time), 'float32') if bkg: for i in range(len(time)): sky[i] = np.median(flux[i, :]) # legal mask defined? if len(aperb) == 0: errmsg = ('ERROR -- KEPEXTRACT: no legal pixels within the subimage' ' are defined.') kepmsg.err(logfile, errmsg, verbose) # construct new table flux data naper = (aperb == 3).sum() ntime = len(time) sap_flux = np.array([], 'float32') sap_flux_err = np.array([], 'float32') sap_bkg = np.array([], 'float32') sap_bkg_err = np.array([], 'float32') raw_flux = np.array([], 'float32') print("Aperture photometry...") for i in tqdm(range(len(time))): work1 = np.array([], 'float64') work2 = np.array([], 'float64') work3 = np.array([], 'float64') work4 = np.array([], 'float64') work5 = np.array([], 'float64') for j in range(len(aperb)): if aperb[j] == 3: work1 = np.append(work1, flux[i, j] - sky[i]) work2 = np.append(work2, flux_err[i, j]) work3 = np.append(work3, flux_bkg[i, j]) work4 = np.append(work4, flux_bkg_err[i, j]) work5 = np.append(work5, raw_cnts[i, j]) sap_flux = np.append(sap_flux, np.sum(work1)) sap_flux_err = np.append(sap_flux_err, math.sqrt(np.sum(work2 * work2))) sap_bkg = np.append(sap_bkg, np.sum(work3)) sap_bkg_err = np.append(sap_bkg_err, math.sqrt(np.sum(work4 * work4))) raw_flux = np.append(raw_flux, np.sum(work5)) print("Sample moments...") # construct new table moment data for i in tqdm(range(ntime)): xf = np.zeros(shape=(naper)) yf = np.zeros(shape=(naper)) f = np.zeros(shape=(naper)) xfe = np.zeros(shape=(naper)) yfe = np.zeros(shape=(naper)) fe = np.zeros(shape=(naper)) k = -1 for j in range(len(aperb)): if aperb[j] == 3: k += 1 xf[k] = aperx[j] * flux[i, j] xfe[k] = aperx[j] * flux_err[i, j] yf[k] = apery[j] * flux[i, j] yfe[k] = apery[j] * flux_err[i, j] f[k] = flux[i, j] fe[k] = flux_err[i, j] xfsum = np.sum(xf) yfsum = np.sum(yf) fsum = np.sum(f) xfsume = math.sqrt(np.sum(xfe * xfe) / naper) yfsume = math.sqrt(np.sum(yfe * yfe) / naper) fsume = math.sqrt(np.sum(fe * fe) / naper) mom_centr1[i] = xfsum / fsum mom_centr2[i] = yfsum / fsum mom_centr1_err[i] = math.sqrt((xfsume / xfsum)**2 + ((fsume / fsum)**2)) mom_centr2_err[i] = math.sqrt((yfsume / yfsum)**2 + ((fsume / fsum)**2)) mom_centr1_err = mom_centr1_err * mom_centr1 mom_centr2_err = mom_centr2_err * mom_centr2 if psfcentroid: print("PSF Centroiding...") # construct new table PSF data psf_centr1 = np.zeros(shape=(ntime)) psf_centr2 = np.zeros(shape=(ntime)) psf_centr1_err = np.zeros(shape=(ntime)) psf_centr2_err = np.zeros(shape=(ntime)) modx = np.zeros(shape=(naper)) mody = np.zeros(shape=(naper)) k = -1 for j in range(len(aperb)): if (aperb[j] == 3): k += 1 modx[k] = aperx[j] mody[k] = apery[j] for i in tqdm(range(ntime)): modf = np.zeros(shape=(naper)) k = -1 guess = [ mom_centr1[i], mom_centr2[i], np.nanmax(flux[i:]), 1.0, 1.0, 0.0, 0.0 ] for j in range(len(aperb)): if (aperb[j] == 3): k += 1 modf[k] = flux[i, j] args = (modx, mody, modf) try: ans = leastsq(kepfunc.PRFgauss2d, guess, args=args, xtol=1.0e-8, ftol=1.0e-4, full_output=True) s_sq = (ans[2]['fvec']**2).sum() / (ntime - len(guess)) psf_centr1[i] = ans[0][0] psf_centr2[i] = ans[0][1] except: pass try: psf_centr1_err[i] = sqrt(diag(ans[1] * s_sq))[0] except: psf_centr1_err[i] = np.nan try: psf_centr2_err[i] = sqrt(diag(ans[1] * s_sq))[1] except: psf_centr2_err[i] = np.nan # construct output primary extension hdu0 = pyfits.PrimaryHDU() for i in range(len(cards0)): if cards0[i].keyword not in hdu0.header.keys(): hdu0.header[cards0[i].keyword] = (cards0[i].value, cards0[i].comment) else: hdu0.header.cards[cards0[i].keyword].comment = cards0[i].comment kepkey.history(call, hdu0, outfile, logfile, verbose) outstr = pyfits.HDUList(hdu0) # construct output light curve extension col1 = pyfits.Column(name='TIME', format='D', unit='BJD - 2454833', array=time) col2 = pyfits.Column(name='TIMECORR', format='E', unit='d', array=timecorr) col3 = pyfits.Column(name='CADENCENO', format='J', array=cadenceno) col4 = pyfits.Column(name='SAP_FLUX', format='E', array=sap_flux) col5 = pyfits.Column(name='SAP_FLUX_ERR', format='E', array=sap_flux_err) col6 = pyfits.Column(name='SAP_BKG', format='E', array=sap_bkg) col7 = pyfits.Column(name='SAP_BKG_ERR', format='E', array=sap_bkg_err) col8 = pyfits.Column(name='PDCSAP_FLUX', format='E', array=sap_flux) col9 = pyfits.Column(name='PDCSAP_FLUX_ERR', format='E', array=sap_flux_err) col10 = pyfits.Column(name='SAP_QUALITY', format='J', array=quality) col11 = pyfits.Column(name='PSF_CENTR1', format='E', unit='pixel', array=psf_centr1) col12 = pyfits.Column(name='PSF_CENTR1_ERR', format='E', unit='pixel', array=psf_centr1_err) col13 = pyfits.Column(name='PSF_CENTR2', format='E', unit='pixel', array=psf_centr2) col14 = pyfits.Column(name='PSF_CENTR2_ERR', format='E', unit='pixel', array=psf_centr2_err) col15 = pyfits.Column(name='MOM_CENTR1', format='E', unit='pixel', array=mom_centr1) col16 = pyfits.Column(name='MOM_CENTR1_ERR', format='E', unit='pixel', array=mom_centr1_err) col17 = pyfits.Column(name='MOM_CENTR2', format='E', unit='pixel', array=mom_centr2) col18 = pyfits.Column(name='MOM_CENTR2_ERR', format='E', unit='pixel', array=mom_centr2_err) col19 = pyfits.Column(name='POS_CORR1', format='E', unit='pixel', array=pos_corr1) col20 = pyfits.Column(name='POS_CORR2', format='E', unit='pixel', array=pos_corr2) col21 = pyfits.Column(name='RAW_FLUX', format='E', array=raw_flux) cols = pyfits.ColDefs([ col1, col2, col3, col4, col5, col6, col7, col8, col9, col10, col11, col12, col13, col14, col15, col16, col17, col18, col19, col20, col21 ]) hdu1 = pyfits.BinTableHDU.from_columns(cols) hdu1.header['TTYPE1'] = ('TIME', 'column title: data time stamps') hdu1.header['TFORM1'] = ('D', 'data type: float64') hdu1.header['TUNIT1'] = ('BJD - 2454833', 'column units: barycenter corrected JD') hdu1.header['TDISP1'] = ('D12.7', 'column display format') hdu1.header['TTYPE2'] = ('TIMECORR', 'column title: barycentric-timeslice correction') hdu1.header['TFORM2'] = ('E', 'data type: float32') hdu1.header['TUNIT2'] = ('d', 'column units: days') hdu1.header['TTYPE3'] = ('CADENCENO', 'column title: unique cadence number') hdu1.header['TFORM3'] = ('J', 'column format: signed integer32') hdu1.header['TTYPE4'] = ('SAP_FLUX', 'column title: aperture photometry flux') hdu1.header['TFORM4'] = ('E', 'column format: float32') hdu1.header['TUNIT4'] = ('e-/s', 'column units: electrons per second') hdu1.header['TTYPE5'] = ('SAP_FLUX_ERR', 'column title: aperture phot. flux error') hdu1.header['TFORM5'] = ('E', 'column format: float32') hdu1.header['TUNIT5'] = ('e-/s', 'column units: electrons per second (1-sigma)') hdu1.header['TTYPE6'] = ('SAP_BKG', 'column title: aperture phot. background flux') hdu1.header['TFORM6'] = ('E', 'column format: float32') hdu1.header['TUNIT6'] = ('e-/s', 'column units: electrons per second') hdu1.header['TTYPE7'] = ('SAP_BKG_ERR', 'column title: ap. phot. background flux error') hdu1.header['TFORM7'] = ('E', 'column format: float32') hdu1.header['TUNIT7'] = ('e-/s', 'column units: electrons per second (1-sigma)') hdu1.header['TTYPE8'] = ('PDCSAP_FLUX', 'column title: PDC photometry flux') hdu1.header['TFORM8'] = ('E', 'column format: float32') hdu1.header['TUNIT8'] = ('e-/s', 'column units: electrons per second') hdu1.header['TTYPE9'] = ('PDCSAP_FLUX_ERR', 'column title: PDC flux error') hdu1.header['TFORM9'] = ('E', 'column format: float32') hdu1.header['TUNIT9'] = ('e-/s', 'column units: electrons per second (1-sigma)') hdu1.header['TTYPE10'] = ('SAP_QUALITY', 'column title: aperture photometry quality flag') hdu1.header['TFORM10'] = ('J', 'column format: signed integer32') hdu1.header['TTYPE11'] = ('PSF_CENTR1', 'column title: PSF fitted column centroid') hdu1.header['TFORM11'] = ('E', 'column format: float32') hdu1.header['TUNIT11'] = ('pixel', 'column units: pixel') hdu1.header['TTYPE12'] = ('PSF_CENTR1_ERR', 'column title: PSF fitted column error') hdu1.header['TFORM12'] = ('E', 'column format: float32') hdu1.header['TUNIT12'] = ('pixel', 'column units: pixel') hdu1.header['TTYPE13'] = ('PSF_CENTR2', 'column title: PSF fitted row centroid') hdu1.header['TFORM13'] = ('E', 'column format: float32') hdu1.header['TUNIT13'] = ('pixel', 'column units: pixel') hdu1.header['TTYPE14'] = ('PSF_CENTR2_ERR', 'column title: PSF fitted row error') hdu1.header['TFORM14'] = ('E', 'column format: float32') hdu1.header['TUNIT14'] = ('pixel', 'column units: pixel') hdu1.header['TTYPE15'] = ('MOM_CENTR1', 'column title: moment-derived column centroid') hdu1.header['TFORM15'] = ('E', 'column format: float32') hdu1.header['TUNIT15'] = ('pixel', 'column units: pixel') hdu1.header['TTYPE16'] = ('MOM_CENTR1_ERR', 'column title: moment-derived column error') hdu1.header['TFORM16'] = ('E', 'column format: float32') hdu1.header['TUNIT16'] = ('pixel', 'column units: pixel') hdu1.header['TTYPE17'] = ('MOM_CENTR2', 'column title: moment-derived row centroid') hdu1.header['TFORM17'] = ('E', 'column format: float32') hdu1.header['TUNIT17'] = ('pixel', 'column units: pixel') hdu1.header['TTYPE18'] = ('MOM_CENTR2_ERR', 'column title: moment-derived row error') hdu1.header['TFORM18'] = ('E', 'column format: float32') hdu1.header['TUNIT18'] = ('pixel', 'column units: pixel') hdu1.header['TTYPE19'] = ('POS_CORR1', 'column title: col correction for vel. abbern') hdu1.header['TFORM19'] = ('E', 'column format: float32') hdu1.header['TUNIT19'] = ('pixel', 'column units: pixel') hdu1.header['TTYPE20'] = ('POS_CORR2', 'column title: row correction for vel. abbern') hdu1.header['TFORM20'] = ('E', 'column format: float32') hdu1.header['TUNIT20'] = ('pixel', 'column units: pixel') hdu1.header['TTYPE21'] = ('RAW_FLUX', 'column title: raw aperture photometry flux') hdu1.header['TFORM21'] = ('E', 'column format: float32') hdu1.header['TUNIT21'] = ('e-/s', 'column units: electrons per second') hdu1.header['EXTNAME'] = ('LIGHTCURVE', 'name of extension') for i in range(len(cards1)): if (cards1[i].keyword not in hdu1.header.keys() and cards1[i].keyword[:4] not in [ 'TTYP', 'TFOR', 'TUNI', 'TDIS', 'TDIM', 'WCAX', '1CTY', '2CTY', '1CRP', '2CRP', '1CRV', '2CRV', '1CUN', '2CUN', '1CDE', '2CDE', '1CTY', '2CTY', '1CDL', '2CDL', '11PC', '12PC', '21PC', '22PC' ]): hdu1.header[cards1[i].keyword] = (cards1[i].value, cards1[i].comment) outstr.append(hdu1) # construct output mask bitmap extension hdu2 = pyfits.ImageHDU(maskmap) for i in range(len(cards2)): if cards2[i].keyword not in hdu2.header.keys(): hdu2.header[cards2[i].keyword] = (cards2[i].value, cards2[i].comment) else: hdu2.header.cards[cards2[i].keyword].comment = cards2[i].comment outstr.append(hdu2) # write output file outstr.writeto(outfile, checksum=True) # close input structure instr.close() # end time kepmsg.clock('KEPEXTRACT finished at', logfile, verbose)
def createOutput(self): """Create pyfits object for output file.""" # Get header info from the input. ifd = fits.open(self.input[self.index_max_nelem], mode="copyonwrite") detector = ifd[0].header["detector"] primary_hdu = fits.PrimaryHDU(header=ifd[0].header) cosutil.updateFilename(primary_hdu.header, self.output) # Add new keywords with comma-separated values. list_keywords = [("MFPPOS", "fppos", self.keywords["fppos"]), ("MFPOFSET", "fpoffset", self.keywords["fpoffset"]), ("MCENWAVE", "cenwave", self.keywords["cenwave"])] for (new_kwd, old_kwd, list_value) in list_keywords: str_value = makeStringList(list_value) primary_hdu.header.set(new_kwd, str_value, after=old_kwd) # xxx # xxx primary_hdu.header.insert(old_kwd, (new_kwd, str_value), # xxx after=True) del_these = ["segment", "wavecals", "fppos", "fpoffset"] for keyword in del_these: if keyword in primary_hdu.header: del (primary_hdu.header[keyword]) if len(self.keywords["cenwave"]) > 1: del (primary_hdu.header["cenwave"]) ofd = fits.HDUList(primary_hdu) rpt = str(self.output_nelem) # used for defining columns # Define the columns explicitly, rather than using an input table # as a template and then modifying the lengths of arrays (see below), # because the modified columns kept reverting to the original length. col = [] col.append(fits.Column(name="SEGMENT", format="4A")) col.append( fits.Column(name="EXPTIME", format="1D", disp="F8.3", unit="s")) col.append(fits.Column(name="NELEM", format="1J", disp="I6")) col.append( fits.Column(name="WAVELENGTH", format=rpt + "D", unit="angstrom")) col.append( fits.Column(name="FLUX", format=rpt + "E", unit="erg /s /cm**2 /angstrom")) col.append( fits.Column(name="ERROR", format=rpt + "E", unit="erg /s /cm**2 /angstrom")) col.append(fits.Column(name="GROSS", format=rpt + "E", unit="count /s")) col.append(fits.Column(name="GCOUNTS", format=rpt + "E", unit="count")) col.append(fits.Column(name="NET", format=rpt + "E", unit="count /s")) col.append( fits.Column(name="BACKGROUND", format=rpt + "E", unit="count /s")) col.append(fits.Column(name="DQ", format=rpt + "I")) col.append(fits.Column(name="DQ_WGT", format=rpt + "E")) cd = fits.ColDefs(col) # Modify some of the output columns. #cd = ifd[1].columns # this is a ColDefs object #col_names = cd.names #col_formats = cd.formats #ncols = len(col_names) # xxx x = ifd[1].data # xxx touch the data #for i in range(ncols): # fmt = col_formats[i] # if fmt[-1] in ["D", "E", "I", "J"] and fmt[0] in "123456789": # x = ifd[1].data # xxx touch the data # newfmt = rpt + fmt[-1] # cd.change_attrib(col_names[i], "format", newfmt) # Create output HDU for the table. newhdu = delExtraColumns(ifd[1]) ifd[1].header = newhdu.header hdu = fits.BinTableHDU.from_columns(cd, header=ifd[1].header, nrows=self.nrows) hdu.header["exptime"] = self.keywords["exptime"] if detector == "FUV": hdu.header["exptimea"] = self.keywords["exptimea"] hdu.header["exptimeb"] = self.keywords["exptimeb"] hdu.header["expstart"] = self.keywords["expstart"] hdu.header["expend"] = self.keywords["expend"] hdu.header["expstrtj"] = self.keywords["expstrtj"] hdu.header["expendj"] = self.keywords["expendj"] hdu.header["plantime"] = self.keywords["plantime"] if self.keywords["globrate"] >= 0.: hdu.header["globrate"] = round(self.keywords["globrate"], 4) if self.keywords["globrt_a"] >= 0.: hdu.header["globrt_a"] = round(self.keywords["globrt_a"], 4) if self.keywords["globrt_b"] >= 0.: hdu.header["globrt_b"] = round(self.keywords["globrt_b"], 4) # Delete some keywords because they are specific to one exposure. delSomeKeywords(hdu.header) ofd.append(hdu) self.fpInitData(ofd) # initialize data in output hdu ifd.close() self.ofd = ofd
def file_output(data_array, file_name): fits.BinTableHDU.from_columns(fits.ColDefs(np.array(data_array))).writeto( file_name, overwrite=True)
def write_catalogs_to_disk(outputfile, outputdataarray, literaturecontent=True, verbose=True): """ """ outputdataarray = np.sort(outputdataarray, order='id') # sorting array by ID outputdir = '/Users/kschmidt/work/publications/MUSE_UVemissionlines/catalog_releases/' outtxt = outputdir+outputfile outfits = outputdir+outputfile.replace('.txt','.fits') #------------------------------------------------------------------------------------------------------------- if verbose: print(' - Initializing the output file: \n '+outtxt) fout = open(outtxt,'w') if verbose: print(' Putting together header for ascii output') fout.write('# Value-added source catalog released with Schmidt et al. (2021) A&A XXXX:YYYY \n') fout.write('# Upper and lower limits are given as values with uncertainty of +99 or -99, respectively. \n') if literaturecontent: fout.write('# When using this catalog please cite Schmidt et al. (2021) A&A XXXX:YYYY ' 'and the original papers the data were assmbled from in the reference column (see Schmidt et al. 2021) \n') else: fout.write('# When using this catalog please cite Schmidt et al. (2021) A&A XXXX:YYYY \n') fout.write('# \n') # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - colnames = outputdataarray.dtype.names Ncols = len(colnames) if verbose: print(' The output files will contain '+str(Ncols)+' columns ') fout.write('# The catalog contains the following '+str(Ncols)+' columns:\n') fout.write('# '+(' '.join([str("%20s" % colname) for colname in list(colnames)])).replace('reference',' reference')+' \n') if verbose: print(' The total number of objects in the output is '+str(len(outputdataarray['id']))) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - if verbose: print(' - Writing output data array to ascii file \n '+outputfile) dtypetranslator = {'>i8':'%20i', 'float64':'%20.4f', '|S30':'%30s'} for oo, id in enumerate(outputdataarray['id']): outstr = ' ' for cc, colval in enumerate(outputdataarray[oo].tolist()): strfmt = dtypetranslator[str(outputdataarray.dtype[cc])] if outputdataarray.dtype.names[cc] in ['ra','dec']: strfmt = '%20.10f' if strfmt == '%30s': outstr = outstr +' '+ str(strfmt % colval.decode('UTF-8')) else: outstr = outstr +' '+ str(strfmt % colval) fout.write(outstr+' \n') fout.close() #------------------------------------------------------------------------------------------------------------- if verbose: print(' - Creating fits version of output: \n '+outfits) if literaturecontent: fitsformat = ['K','D','D','20A','30A','D'] + ['D']*(Ncols-6) else: fitsformat = ['K','D','D','D','10A','K','K'] + ['D']*(Ncols-15) + ['K', 'D']*4 fitsformat[-19] = 'K' # The Kerutt ID # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - if verbose: print(' Reading ascii file ') data = np.genfromtxt(outtxt,names=colnames,skip_header=6,comments='#',dtype=outputdataarray.dtype) keys = data.dtype.names # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - if verbose: print(' Initialize and fill dictionary with data') datadic = {} for kk in keys: datadic[kk] = [] try: lenarr = len(np.asarray(data[kk])) datadic[kk] = np.asarray(data[kk]) except: # if only one row of data is to be written datadic[kk] = np.asarray([data[kk]]) if verbose: print(' Found '+str(len(keys))+' columns to insert into fits binary table') if len(fitsformat) != len(keys): fitsformat = np.asarray([fitsformat]*len(keys)) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - if verbose: print(' Writing to fits table') columndefs = [] for kk, key in enumerate(keys): columndefs.append(afits.Column(name=key , format=fitsformat[kk], unit=uca.get_unit(key), array=datadic[key])) cols = afits.ColDefs(columndefs) tbhdu = afits.BinTableHDU.from_columns(cols) # creating table header hdu = afits.PrimaryHDU() # creating primary (minimal) header thdulist = afits.HDUList([hdu, tbhdu]) # combine primary and table header to hdulist thdulist.writeto(outfits,overwrite=True) # write fits file
aaa = orig_cols.del_col('CALIBFLUX') aaa = orig_cols.del_col('CALIBFLUX_IVAR') table_all = [] headers = "" for fiber, mjd in zip(orig_table['FIBERID'], orig_table['MJD']): fitFile = join( os.environ['EBOSSDR14_DIR'], dir, "stellarpop", plate, "spFly-" + plate.zfill(4) + "-" + str(mjd) + "-" + str(fiber).zfill(4) + suffix) # print fitFile if os.path.isfile(fitFile): table_entry, headers = get_table_entry_full( hduSPM=fits.open(fitFile)[1]) table_all.append(table_entry) else: table_all.append(n.ones(66) * dV) newDat = n.transpose(table_all) all_cols = [] for data_array, head in zip(newDat, headers.split()): all_cols.append(fits.Column(name=head, format='D', array=data_array)) new_cols = fits.ColDefs(all_cols) hdu = fits.BinTableHDU.from_columns(orig_cols + new_cols) if os.path.isfile(plate_catalog): os.remove(plate_catalog) hdu.writeto(plate_catalog)
aexps.append(aaa) out_name = os.path.join(os.environ["MD40"], 'output_MD_4.0Gpc.fits') redshift = 1. / n.array(aexps) - 1. dCom = cosmoMD.comoving_distance(redshift) ids = n.argsort(redshift) col0 = fits.Column(name='snap_name', format='A4', array=n.array(names)[ids]) col1 = fits.Column(name='N_columns', format='I', array=n.array(colN)[ids]) col2 = fits.Column(name='aexp', format='D', array=n.array(aexps)[ids]) col3 = fits.Column(name='redshift', format='D', array=redshift[ids]) col4 = fits.Column(name='comoving_distance', format='D', array=dCom.value[ids]) array = 10**9 * cosmoMD.age(redshift).value col5 = fits.Column(name='age_yr', format='D', array=array[ids]) array = cosmoMD.arcsec_per_kpc_comoving(redshift).value * 3.6 col6 = fits.Column(name='deg_per_Mpc_comoving', format='D', array=array[ids]) #define the table hdu hdu_cols = fits.ColDefs([col0, col1, col2, col3, col4, col5, col6]) #, col7, col8, col9, col10]) tb_hdu = fits.BinTableHDU.from_columns(hdu_cols) #define the header prihdr = fits.Header() prihdr['sim'] = 'HMD' prihdr['author'] = 'JC' prihdu = fits.PrimaryHDU(header=prihdr) #writes the file thdulist = fits.HDUList([prihdu, tb_hdu]) #os.system("rm "+out_name) thdulist.writeto(out_name)
def _make_target_extension(self): """Create the 'TARGETTABLES' extension (i.e. extension #1).""" # Turn the data arrays into fits columns and initialize the HDU coldim = '({},{})'.format(self.n_cols, self.n_rows) eformat = '{}E'.format(self.n_rows * self.n_cols) jformat = '{}J'.format(self.n_rows * self.n_cols) cols = [] cols.append( fits.Column(name='TIME', format='D', unit='BJD - 2454833', array=self.time)) cols.append( fits.Column(name='TIMECORR', format='E', unit='D', array=self.timecorr)) cols.append( fits.Column(name='CADENCENO', format='J', array=self.cadenceno)) cols.append( fits.Column(name='RAW_CNTS', format=jformat, unit='count', dim=coldim, array=self.raw_cnts)) cols.append( fits.Column(name='FLUX', format=eformat, unit='e-/s', dim=coldim, array=self.flux)) cols.append( fits.Column(name='FLUX_ERR', format=eformat, unit='e-/s', dim=coldim, array=self.flux_err)) cols.append( fits.Column(name='FLUX_BKG', format=eformat, unit='e-/s', dim=coldim, array=self.flux_bkg)) cols.append( fits.Column(name='FLUX_BKG_ERR', format=eformat, unit='e-/s', dim=coldim, array=self.flux_bkg_err)) cols.append( fits.Column(name='COSMIC_RAYS', format=eformat, unit='e-/s', dim=coldim, array=self.cosmic_rays)) cols.append(fits.Column(name='QUALITY', format='J', array=self.quality)) cols.append( fits.Column(name='POS_CORR1', format='E', unit='pixels', array=self.pos_corr1)) cols.append( fits.Column(name='POS_CORR2', format='E', unit='pixels', array=self.pos_corr2)) coldefs = fits.ColDefs(cols) hdu = fits.BinTableHDU.from_columns(coldefs) # Set the header with defaults template = self._header_template(1) for kw in template: if kw not in [ 'XTENSION', 'NAXIS1', 'NAXIS2', 'CHECKSUM', 'BITPIX' ]: try: hdu.header[kw] = (self.keywords[kw], self.keywords.comments[kw]) except KeyError: hdu.header[kw] = (template[kw], template.comments[kw]) # Override the defaults where necessary hdu.header['EXTNAME'] = 'TARGETTABLES' hdu.header['OBJECT'] = self.target_id hdu.header['KEPLERID'] = self.target_id for n in [5, 6, 7, 8, 9]: hdu.header["TFORM{}".format(n)] = eformat hdu.header["TDIM{}".format(n)] = coldim hdu.header['TFORM4'] = jformat hdu.header['TDIM4'] = coldim return hdu
def toPixels(args): """ Convert coordinates from pixels. Assumes HSC pixel size """ verbose = True """ options """ pixelScale = 0.17 fileInName = args.input.split(",") """ read input file """ cols, _ = getCols(fileInName[0], ['user_ra', 'user_dec', 'ra', 'dec'], dictionary=True) # coord = SkyCoord(cols['ra'], cols['dec'], unit="deg") N = len(cols['ra']) """ create wcs object """ w = createZeroWcs(pixelScale, 0.0, 0.0) x = np.zeros(N) y = np.zeros(N) w.wcs.crval = [cols['user_ra'][0], cols['user_dec'][0]] count = 0 """ loop over all objects but do the conversion in blocks sharing the same nearby star """ # count = 0 for i in range(N): w.wcs.crval = [cols['user_ra'][i], cols['user_dec'][i]] x[i], y[i] = w.wcs_world2pix(cols['ra'][i], cols['dec'][i], 1) # try: # np.testing.assert_array_almost_equal(w.wcs.crval, [cols['user_ra'][i], cols['user_dec'][i]], decimal=4) # except: # x[i-count:i+1], y[i-count:i+1] = w.wcs_world2pix(cols['ra'][i-count:i+1], cols['dec'][i-count:i+1], 1) # w.wcs.crval = [cols['user_ra'][i], cols['user_dec'][i]] # count = 0 # count += 1 #try: # np.testing.assert_array_almost_equal(w.wcs.crval, [cols['user_ra'][i], cols['user_dec'][i]], decimal=4) #except: # x[i-count:i+1], y[i-count:i+1] = wcs.utils.skycoord_to_pixel(coord[i-count:i+1], w, origin=1, mode='wcs') # w.wcs.crval = [cols['user_ra'][i], cols['user_dec'][i]] # count = 0 #count += 1 if verbose: if (i+1)%10000 == 0: sys.stderr.write("\r" + "Processed {0:d}/{1:d} objects ({2:.2f}%)".format(i+1, N, 100.0*float(i+1)/float(N))) sys.stderr.flush() # count -= 1 # x[i-count:i+1], y[i-count:i+1] = w.wcs_world2pix(cols['ra'][i-count:N], cols['dec'][i-count:N], 1) #count -= 1 #x[i-count:N], y[i-count:N] = wcs.utils.skycoord_to_pixel(coord[i-count:N], w, origin=1) if verbose: sys.stderr.write("\r" + "Processed {0:d}/{1:d} objects ({2:.2f}%)\n".format(i+1, N, 100.0)) outCols = [fits.Column(name='x', format='E', array=x), fits.Column(name='y', format='E', array=y)] fileIn = fits.open(fileInName[0]) tbhdu = fits.HDUList([fileIn[0], fits.BinTableHDU.from_columns(fileIn[1].columns + fits.ColDefs(outCols))]) tbhdu.writeto(args.output, clobber=True) fileIn.close() return
for sub_survey_name in sub_survey_names ]) ssm_files = np.array([ survey + '_SSM_' + str(sub_survey_name) + '.fits' for sub_survey_name in sub_survey_names ]) tmax_files = np.array([ survey + '_TMAX_' + str(sub_survey_name) + '.fits' for sub_survey_name in sub_survey_names ]) areq_files = np.array([ survey + '_AREQ_' + str(sub_survey_name) + '.fits' for sub_survey_name in sub_survey_names ]) out_file_PARA = os.path.join(working_dir, survey + '_SUBSURVEY_PARAMS.fits') cols = fits.ColDefs([ fits.Column("SUBSURVEY", unit='', format="20A", array=sub_survey_names), fits.Column("LSM_FILENAME", unit='', format="200A", array=lsm_files), fits.Column("SSM_FILENAME", unit='', format="200A", array=ssm_files), fits.Column("TMAX_FILENAME", unit='', format="200A", array=tmax_files), fits.Column("AREQ_FILENAME", unit='', format="200A", array=areq_files), ]) tbhdu = fits.BinTableHDU.from_columns(cols) tbhdu.header['author'] = 'JC' print(out_file_PARA) if os.path.isfile(out_file_PARA): os.system("rm " + out_file_PARA) tbhdu.writeto(out_file_PARA)
def kepfold(infile, outfile, period, bjd0, bindata=False, binmethod='median', threshold=1.0, niter=5, nbins=1000, rejqual=False, plottype='sap', overwrite=False, verbose=False, logfile="kepfold.log"): """ kepfold: Phase-fold light curve data on linear ephemeris. kepfold calculates the phase of all time-tagged data points relative to a user-supplied linear ephemeris. The relation is: .. math:: TIME_i = bjd0 + period \cdot PHASE_i :math:`TIME` is the column within the FITS light curve file containing barycenter-corrected time stamps. :math:`bjd0` is a user-supplied BJD for zero phase. period is a user-supplied period in units of days. PHASE is the calculated phase for each time stamp; these results are written to a new float column in the LIGHT CURVE extension of the input file before being exported as a new file with name defined by the user. Optionally, kepfold will plot the data folded on the ephemeris and store it within a new FITS extension of the output file called FOLDED. Both the SAP and PDC fluxes are binned and stored in the new extension. There are a number of binning algorithms, mean, median and sigma clipping. The user has options to adapt bin size, binning method and the rejection of outliers. Parameters ---------- inile : str The name of a MAST standard format FITS file containing a Kepler light curve within the first data extension. outfile : str The name of the output FITS file with a new extension containing a phased light curve. period : str Period over which to fold the light curve, in units of days. bjd0 : float Time of zero phase for the folded data, in units of BJD. bindata: bool Collect the data into discrete bins during the fold? binmethod : str Binning method. * `mean` calculates the mean of all data points contained within a bin. * `median` calculates the median of all data points within a bin. * `sigclip` calculates a mean iteratively. Each iteration rejects data lying further than a threshold number of standard deviations from the mean before recalculating the result. threshold : float The sigma clipping threshold in units of the standard deviation about the calculated mean within a phase bin. A typical outlier lies > 3.0:math:`\sigma` from the mean. niter : int The maximum number of iterations over which to reject outliers before accepting the sigclip result. nbins : int The number of phase bins to calculate. rejqual : bool If `True`, timestamps with quality issues recorded as a finite quality flag in the input file will be thrown away before folding the data. plottype : str The type of data to plot. The choices refer to the types of photometry stored in the input file. * ``sap`` is Simple Aperture Photometry, stored in the column, SAP_FLUX. SAP data is generated by the Kepler pipeline but it can also be generated from a target pixel file using the kepextract tool. * ``pdc`` is Pre-search Data Conditioning photometry, stored in the column PDCSAP_FLUX. PDC data is a Kepler pipeline product. * ``cbv`` Cotrending Basis Vector is SAP photometry corrected manually by the user using the tool ``kepcotrend``. CBV data is stored in the column CBVSAP_FLUX. * ``det`` data has been detrended using piecemeal polynomials with the kepflatten tool. DET data is stored in the column DETSAP_FLUX. overwrite : bool Overwrite the output file? verbose : bool Print informative messages and warnings to the shell and logfile? logfile : str Name of the logfile containing error and warning messages. Examples -------- .. code-block:: bash $ kepfold kplr010544976-2009201121230_slc.fits kepfold.fits 0.350471 2455002.825 --bindata --binmethod median --threshold 3.0 --niter 1000 --plottype sap --verbose .. image:: ../_static/images/api/kepfold.png :align: center """ # log the call hashline = '--------------------------------------------------------------' kepmsg.log(logfile, hashline, verbose) call = ('KEPFOLD -- ' + ' infile={}'.format(infile) + ' outfile={}'.format(outfile) + ' period={}'.format(period) + ' bjd0={}'.format(bjd0) + ' bindata={}'.format(bindata) + ' binmethod={}'.format(binmethod) + ' threshold={}'.format(threshold) + ' niter={}'.format(niter) + ' nbins={}'.format(nbins) + ' rejqual={}'.format(rejqual) + ' plottype={}'.format(plottype) + ' overwrite={}'.format(overwrite) + ' verbose={}'.format(verbose) + ' logfile={}'.format(logfile)) kepmsg.log(logfile, call + '\n', verbose) # start time kepmsg.clock('KEPFOLD started at', logfile, verbose) # overwrite output file if overwrite: kepio.overwrite(outfile, logfile, verbose) if kepio.fileexists(outfile): errmsg = ( 'ERROR -- KEPFOLD: {} exists. Use --overwrite'.format(outfile)) kepmsg.err(logfile, errmsg, verbose) # open input file instr = pyfits.open(infile, 'readonly') tstart, tstop, bjdref, cadence = kepio.timekeys(instr, infile, logfile, verbose) try: work = instr[0].header['FILEVER'] cadenom = 1.0 except: cadenom = cadence # fudge non-compliant FITS keywords with no values instr = kepkey.emptykeys(instr, infile, logfile, verbose) # input data table = instr[1].data incards = instr[1].header.cards try: sap = instr[1].data.field('SAP_FLUX') except: try: sap = instr[1].data.field('ap_raw_flux') except: sap = np.zeros(len(table.field(0))) try: saperr = instr[1].data.field('SAP_FLUX_ERR') except: try: saperr = instr[1].data.field('ap_raw_err') except: saperr = np.zeros(len(table.field(0))) try: pdc = instr[1].data.field('PDCSAP_FLUX') except: try: pdc = instr[1].data.field('ap_corr_flux') except: pdc = np.zeros(len(table.field(0))) try: pdcerr = instr[1].data.field('PDCSAP_FLUX_ERR') except: try: pdcerr = instr[1].data.field('ap_corr_err') except: pdcerr = np.zeros(len(table.field(0))) try: cbv = instr[1].data.field('CBVSAP_FLUX') except: cbv = np.zeros(len(table.field(0))) if 'cbv' in plottype: errmsg = ("ERROR -- KEPFOLD: CBVSAP_FLUX column is not populated." " Use kepcotrend") kepmsg.err(logfile, txt, verbose) try: det = instr[1].data.field('DETSAP_FLUX') except: det = np.zeros(len(table.field(0))) if 'det' in plottype: txt = ("ERROR -- KEPFOLD: DETSAP_FLUX column is not populated." "Use kepflatten") kepmsg.err(logfile, txt, verbose) try: deterr = instr[1].data.field('DETSAP_FLUX_ERR') except: deterr = np.zeros(len(table.field(0))) if 'det' in plottype: txt = ("ERROR -- KEPFOLD: DETSAP_FLUX_ERR column is not populated." " Use kepflatten.") kepmsg.err(logfile, txt, verbose) try: quality = instr[1].data.field('SAP_QUALITY') except: quality = np.zeros(len(table.field(0))) if qualflag: txt = 'WARNING -- KEPFOLD: Cannot find a QUALITY data column' kepmsg.warn(logfile, txt) barytime = kepio.readtimecol(infile, table, logfile, verbose) barytime1 = copy(barytime) # filter out NaNs and quality > 0 work1, work2, work3, work4 = [], [], [], [] work5, work6, work8, work9 = [], [], [], [] if 'sap' in plottype: datacol = copy(sap) errcol = copy(saperr) if 'pdc' in plottype: datacol = copy(pdc) errcol = copy(pdcerr) if 'cbv' in plottype: datacol = copy(cbv) errcol = copy(saperr) if 'det' in plottype: datacol = copy(det) errcol = copy(deterr) for i in range(len(barytime)): if (np.isfinite(barytime[i]) and np.isfinite(datacol[i]) and datacol[i] != 0.0 and np.isfinite(errcol[i]) and errcol[i] > 0.0): if rejqual and quality[i] == 0: work1.append(barytime[i]) work2.append(sap[i]) work3.append(saperr[i]) work4.append(pdc[i]) work5.append(pdcerr[i]) work6.append(cbv[i]) work8.append(det[i]) work9.append(deterr[i]) elif not rejqual: work1.append(barytime[i]) work2.append(sap[i]) work3.append(saperr[i]) work4.append(pdc[i]) work5.append(pdcerr[i]) work6.append(cbv[i]) work8.append(det[i]) work9.append(deterr[i]) barytime = np.array(work1, dtype='float64') sap = np.array(work2, dtype='float32') / cadenom saperr = np.array(work3, dtype='float32') / cadenom pdc = np.array(work4, dtype='float32') / cadenom pdcerr = np.array(work5, dtype='float32') / cadenom cbv = np.array(work6, dtype='float32') / cadenom det = np.array(work8, dtype='float32') / cadenom deterr = np.array(work9, dtype='float32') / cadenom # calculate phase if bjd0 < bjdref: bjd0 += bjdref date1 = (barytime1 + bjdref - bjd0) phase1 = (date1 / period) - np.floor(date1 / period) date2 = (barytime + bjdref - bjd0) phase2 = (date2 / period) - np.floor(date2 / period) phase2 = np.array(phase2, 'float32') # sort phases ptuple = [] phase3 = [] sap3, saperr3 = [], [] pdc3, pdcerr3 = [], [] cbv3, cbverr3 = [], [] det3, deterr3 = [], [] for i in range(len(phase2)): ptuple.append([ phase2[i], sap[i], saperr[i], pdc[i], pdcerr[i], cbv[i], saperr[i], det[i], deterr[i] ]) phsort = sorted(ptuple, key=lambda ph: ph[0]) for i in range(len(phsort)): phase3.append(phsort[i][0]) sap3.append(phsort[i][1]) saperr3.append(phsort[i][2]) pdc3.append(phsort[i][3]) pdcerr3.append(phsort[i][4]) cbv3.append(phsort[i][5]) cbverr3.append(phsort[i][6]) det3.append(phsort[i][7]) deterr3.append(phsort[i][8]) phase3 = np.array(phase3, 'float32') sap3 = np.array(sap3, 'float32') saperr3 = np.array(saperr3, 'float32') pdc3 = np.array(pdc3, 'float32') pdcerr3 = np.array(pdcerr3, 'float32') cbv3 = np.array(cbv3, 'float32') cbverr3 = np.array(cbverr3, 'float32') det3 = np.array(det3, 'float32') deterr3 = np.array(deterr3, 'float32') # bin phases if bindata: work1 = np.array([sap3[0]], 'float32') work2 = np.array([saperr3[0]], 'float32') work3 = np.array([pdc3[0]], 'float32') work4 = np.array([pdcerr3[0]], 'float32') work5 = np.array([cbv3[0]], 'float32') work6 = np.array([cbverr3[0]], 'float32') work7 = np.array([det3[0]], 'float32') work8 = np.array([deterr3[0]], 'float32') phase4 = np.array([], 'float32') sap4 = np.array([], 'float32') saperr4 = np.array([], 'float32') pdc4 = np.array([], 'float32') pdcerr4 = np.array([], 'float32') cbv4 = np.array([], 'float32') cbverr4 = np.array([], 'float32') det4 = np.array([], 'float32') deterr4 = np.array([], 'float32') dt = 1.0 / nbins nb = 0.0 rng = np.append(phase3, phase3[0] + 1.0) for i in range(len(rng)): if rng[i] < nb * dt or rng[i] >= (nb + 1.0) * dt: if len(work1) > 0: phase4 = np.append(phase4, (nb + 0.5) * dt) if binmethod == 'mean': sap4 = np.append(sap4, np.nanmean(work1)) saperr4 = np.append(saperr4, kepstat.mean_err(work2)) pdc4 = np.append(pdc4, np.nanmean(work3)) pdcerr4 = np.append(pdcerr4, kepstat.mean_err(work4)) cbv4 = np.append(cbv4, np.nanmean(work5)) cbverr4 = np.append(cbverr4, kepstat.mean_err(work6)) det4 = np.append(det4, np.nanmean(work7)) deterr4 = np.append(deterr4, kepstat.mean_err(work8)) elif binmethod == 'median': sap4 = np.append(sap4, np.nanmedian(work1)) saperr4 = np.append(saperr4, kepstat.mean_err(work2)) pdc4 = np.append(pdc4, np.nanmedian(work3)) pdcerr4 = np.append(pdcerr4, kepstat.mean_err(work4)) cbv4 = np.append(cbv4, np.nanmedian(work5)) cbverr4 = np.append(cbverr4, kepstat.mean_err(work6)) det4 = np.append(det4, np.nanmedian(work7)) deterr4 = np.append(deterr4, kepstat.mean_err(work8)) else: coeffs, errors, covar, iiter, sigma, chi2, dof, fit, \ plotx, ploty = kepfit.lsqclip(kepfunc.poly0, [np.nanmean(work1)], np.arange(0.0, float(len(work1)), 1.0), work1, work2, threshold, threshold, niter, logfile, False) sap4 = np.append(sap4, coeffs[0]) saperr4 = np.append(saperr4, kepstat.mean_err(work2)) coeffs, errors, covar, iiter, sigma, chi2, dof, fit, \ plotx, ploty = kepfit.lsqclip(kepfunc.poly0, [np.nanmean(work3)], np.arange(0.0, float(len(work3)), 1.0), work3, work4, threshold, threshold, niter, logfile, False) pdc4 = np.append(pdc4, coeffs[0]) pdcerr4 = np.append(pdcerr4, kepstat.mean_err(work4)) coeffs, errors, covar, iiter, sigma, chi2, dof, fit, \ plotx, ploty = kepfit.lsqclip(kepfunc.poly0, [np.nanmean(work5)], np.arange(0.0, float(len(work5)), 1.0), work5, work6, threshold, threshold, niter, logfile, False) cbv4 = np.append(cbv4, coeffs[0]) cbverr4 = np.append(cbverr4, kepstat.mean_err(work6)) coeffs, errors, covar, iiter, sigma, chi2, dof, fit, \ plotx, ploty = kepfit.lsqclip(kepfunc.poly0, [np.nanmean(work7)], np.arange(0.0, float(len(work7)), 1.0), work7, work8, threshold, threshold, niter, logfile, False) det4 = np.append(det4, coeffs[0]) deterr4 = np.append(deterr4, kepstat.mean_err(work8)) work1 = np.array([], 'float32') work2 = np.array([], 'float32') work3 = np.array([], 'float32') work4 = np.array([], 'float32') work5 = np.array([], 'float32') work6 = np.array([], 'float32') work7 = np.array([], 'float32') work8 = np.array([], 'float32') nb += 1.0 else: work1 = np.append(work1, sap3[i]) work2 = np.append(work2, saperr3[i]) work3 = np.append(work3, pdc3[i]) work4 = np.append(work4, pdcerr3[i]) work5 = np.append(work5, cbv3[i]) work6 = np.append(work6, cbverr3[i]) work7 = np.append(work7, det3[i]) work8 = np.append(work8, deterr3[i]) # update HDU1 for output file cols = (instr[1].columns + pyfits.ColDefs( [pyfits.Column(name='PHASE', format='E', array=phase1)])) instr[1] = pyfits.BinTableHDU.from_columns(cols) instr[1].header.cards[ 'TTYPE' + str(len(instr[1].columns))].comment = 'column title: phase' instr[1].header.cards[ 'TFORM' + str(len(instr[1].columns))].comment = 'data type: float32' for i in range(len(incards)): if incards[i].keyword not in instr[1].header.keys(): instr[1].header[incards[i].keyword] = (incards[i].value, incards[i].comment) else: instr[1].header.cards[ incards[i].keyword].comment = incards[i].comment instr[1].header['PERIOD'] = (period, 'period defining the phase [d]') instr[1].header['BJD0'] = (bjd0, 'time of phase zero [BJD]') # write new phased data extension for output file if bindata: col1 = pyfits.Column(name='PHASE', format='E', array=phase4) col2 = pyfits.Column(name='SAP_FLUX', format='E', unit='e/s', array=sap4 / cadenom) col3 = pyfits.Column(name='SAP_FLUX_ERR', format='E', unit='e/s', array=saperr4 / cadenom) col4 = pyfits.Column(name='PDC_FLUX', format='E', unit='e/s', array=pdc4 / cadenom) col5 = pyfits.Column(name='PDC_FLUX_ERR', format='E', unit='e/s', array=pdcerr4 / cadenom) col6 = pyfits.Column(name='CBV_FLUX', format='E', unit='e/s', array=cbv4 / cadenom) col7 = pyfits.Column(name='DET_FLUX', format='E', array=det4 / cadenom) col8 = pyfits.Column(name='DET_FLUX_ERR', format='E', array=deterr4 / cadenom) cols = pyfits.ColDefs([col1, col2, col3, col4, col5, col6, col7, col8]) instr.append(pyfits.BinTableHDU.from_columns(cols)) instr[-1].header.cards['TTYPE1'].comment = 'column title: phase' instr[-1].header.cards[ 'TTYPE2'].comment = 'column title: simple aperture photometry' instr[-1].header.cards[ 'TTYPE3'].comment = 'column title: SAP 1-sigma error' instr[-1].header.cards[ 'TTYPE4'].comment = 'column title: pipeline conditioned photometry' instr[-1].header.cards[ 'TTYPE5'].comment = 'column title: PDC 1-sigma error' instr[-1].header.cards[ 'TTYPE6'].comment = 'column title: cotrended basis vector photometry' instr[-1].header.cards[ 'TTYPE7'].comment = 'column title: Detrended aperture photometry' instr[-1].header.cards[ 'TTYPE8'].comment = 'column title: DET 1-sigma error' instr[-1].header.cards['TFORM1'].comment = 'column type: float32' instr[-1].header.cards['TFORM2'].comment = 'column type: float32' instr[-1].header.cards['TFORM3'].comment = 'column type: float32' instr[-1].header.cards['TFORM4'].comment = 'column type: float32' instr[-1].header.cards['TFORM5'].comment = 'column type: float32' instr[-1].header.cards['TFORM6'].comment = 'column type: float32' instr[-1].header.cards['TFORM7'].comment = 'column type: float32' instr[-1].header.cards['TFORM8'].comment = 'column type: float32' instr[-1].header.cards[ 'TUNIT2'].comment = 'column units: electrons per second' instr[-1].header.cards[ 'TUNIT3'].comment = 'column units: electrons per second' instr[-1].header.cards[ 'TUNIT4'].comment = 'column units: electrons per second' instr[-1].header.cards[ 'TUNIT5'].comment = 'column units: electrons per second' instr[-1].header.cards[ 'TUNIT6'].comment = 'column units: electrons per second' instr[-1].header['EXTNAME'] = ('FOLDED', 'extension name') instr[-1].header['PERIOD'] = (period, 'period defining the phase [d]') instr[-1].header['BJD0'] = (bjd0, 'time of phase zero [BJD]') instr[-1].header['BINMETHD'] = (binmethod, 'phase binning method') if binmethod == 'sigclip': instr[-1].header['THRSHOLD'] = (threshold, 'sigma-clipping threshold [sigma]') instr[-1].header['NITER'] = ( niter, 'max number of sigma-clipping iterations') # history keyword in output file kepkey.history(call, instr[0], outfile, logfile, verbose) instr.writeto(outfile) # clean up x-axis unit ptime1, ptime2 = np.array([], 'float32'), np.array([], 'float32') pout1, pout2 = np.array([], 'float32'), np.array([], 'float32') if bindata: work = sap4 if plottype == 'pdc': work = pdc4 if plottype == 'cbv': work = cbv4 if plottype == 'det': work = det4 for i in range(len(phase4)): if phase4[i] > 0.5: ptime2 = np.append(ptime2, phase4[i] - 1.0) pout2 = np.append(pout2, work[i]) ptime2 = np.append(ptime2, phase4) pout2 = np.append(pout2, work) for i in range(len(phase4)): if phase4[i] <= 0.5: ptime2 = np.append(ptime2, phase4[i] + 1.0) pout2 = np.append(pout2, work[i]) work = sap3 if plottype == 'pdc': work = pdc3 if plottype == 'cbv': work = cbv3 if plottype == 'det': work = det3 for i in range(len(phase3)): if phase3[i] > 0.5: ptime1 = np.append(ptime1, phase3[i] - 1.0) pout1 = np.append(pout1, work[i]) ptime1 = np.append(ptime1, phase3) pout1 = np.append(pout1, work) for i in tqdm(range(len(phase3))): if phase3[i] <= 0.5: ptime1 = np.append(ptime1, phase3[i] + 1.0) pout1 = np.append(pout1, work[i]) xlab = 'Orbital Phase ($\phi$)' # clean up y-axis units nrm = len(str(int(pout1[np.isfinite(pout1)].max()))) - 1 pout1 = pout1 / 10**nrm pout2 = pout2 / 10**nrm if nrm == 0: ylab = 'e$^-$ s$^{-1}$' else: ylab = "10$^{0}$ {1}".format(nrm, 'e$^-$ s$^{-1}$') # data limits xmin = ptime1.min() xmax = ptime1.max() ymin = pout1[np.isfinite(pout1)].min() ymax = pout1[np.isfinite(pout1)].max() xr = xmax - xmin yr = ymax - ymin ptime1 = np.insert(ptime1, [0], [ptime1[0]]) ptime1 = np.append(ptime1, [ptime1[-1]]) pout1 = np.insert(pout1, [0], [0.0]) pout1 = np.append(pout1, 0.0) if bindata: ptime2 = np.insert(ptime2, [0], ptime2[0] - 1.0 / nbins) ptime2 = np.insert(ptime2, [0], ptime2[0]) ptime2 = np.append( ptime2, [ptime2[-1] + 1.0 / nbins, ptime2[-1] + 1.0 / nbins]) pout2 = np.insert(pout2, [0], [pout2[-1]]) pout2 = np.insert(pout2, [0], [0.0]) pout2 = np.append(pout2, [pout2[2], 0.0]) # plot new light curve if plottype != 'none': plt.figure() plt.clf() ax = plt.axes([0.06, 0.11, 0.93, 0.86]) plt.gca().xaxis.set_major_formatter( plt.ScalarFormatter(useOffset=False)) plt.gca().yaxis.set_major_formatter( plt.ScalarFormatter(useOffset=False)) labels = ax.get_yticklabels() if bindata: plt.fill(ptime2, pout2, color='#ffff00', linewidth=0.0, alpha=0.2) else: if 'det' in plottype: plt.fill(ptime1, pout1, color='#ffff00', linewidth=0.0, alpha=0.2) plt.plot(ptime1, pout1, color='#0000ff', linestyle='', linewidth=2.0, marker='.') if bindata: plt.plot(ptime2[1:-1], pout2[1:-1], color='r', linestyle='-', linewidth=2.0, marker='') plt.xlabel(xlab, {'color': 'k'}) plt.ylabel(ylab, {'color': 'k'}) plt.xlim(-0.49999, 1.49999) if ymin >= 0.0: plt.ylim(ymin - yr * 0.01, ymax + yr * 0.01) else: plt.ylim(1.0e-10, ymax + yr * 0.01) plt.grid() plt.show() # close input file instr.close() # stop time kepmsg.clock('KEPFOLD ended at: ', logfile, verbose)
def get_param(self, res, lib_all, zrecom, Czrec0, Czrec1, z_cz, scl_cz0, scl_cz1, fitc, tau0=[0.1, 0.2, 0.3], tcalc=1.): print('##########################') print('### Writing parameters ###') print('##########################') ID0 = self.ID0 PA0 = self.PA0 age = self.AGE nage = np.arange(0, len(age), 1) Zall = self.ZALL fnc = Func(Zall, nage) # Set up the number of Age/ZZ bfnc = Basic(Zall) DIR_TMP = self.DIR_TEMP # Filters import os.path home = os.path.expanduser('~') fil_path = self.DIR_FILT nmc = self.NMC ndim = self.NDIM mmax = 300 if nmc < mmax: mmax = int(nmc / 2.) # RF color uv = np.zeros(int(mmax), dtype='float32') bv = np.zeros(int(mmax), dtype='float32') vj = np.zeros(int(mmax), dtype='float32') zj = np.zeros(int(mmax), dtype='float32') # Lick indeces Dn4 = np.zeros(int(mmax), dtype='float32') Mgb = np.zeros(int(mmax), dtype='float32') Fe52 = np.zeros(int(mmax), dtype='float32') Fe53 = np.zeros(int(mmax), dtype='float32') Mg1 = np.zeros(int(mmax), dtype='float32') Mg2 = np.zeros(int(mmax), dtype='float32') G4300 = np.zeros(int(mmax), dtype='float32') NaD = np.zeros(int(mmax), dtype='float32') Hb = np.zeros(int(mmax), dtype='float32') #Muv = np.zeros(int(mmax), dtype='float32') samples = res.chain[:, :, :].reshape((-1, ndim)) # Already burned. ############################## # Best parameters Amc = np.zeros((len(age), 3), dtype='float32') Ab = np.zeros(len(age), dtype='float32') Zmc = np.zeros((len(age), 3), dtype='float32') Zb = np.zeros(len(age), dtype='float32') NZbest = np.zeros(len(age), dtype='int') if self.f_dust: Mdustmc = np.zeros(3, dtype='float32') nTdustmc = np.zeros(3, dtype='float32') Tdustmc = np.zeros(3, dtype='float32') f0 = fits.open(DIR_TMP + 'ms_' + ID0 + '_PA' + PA0 + '.fits') sedpar = f0[1] ms = np.zeros(len(age), dtype='float32') msmc0 = 0 for aa in range(len(age)): Ab[aa] = res.params['A' + str(aa)].value Amc[aa, :] = np.percentile(res.flatchain['A' + str(aa)], [16, 50, 84]) try: Zb[aa] = res.params['Z' + str(aa)].value Zmc[aa, :] = np.percentile(res.flatchain['Z' + str(aa)], [16, 50, 84]) except: Zb[aa] = res.params['Z0'].value Zmc[aa, :] = np.percentile(res.flatchain['Z0'], [16, 50, 84]) NZbest[aa] = bfnc.Z2NZ(Zb[aa]) ms[aa] = sedpar.data['ML_' + str(NZbest[aa])][aa] msmc0 += res.flatchain['A' + str(aa)] * ms[aa] msmc = np.percentile(msmc0, [16, 50, 84]) Avb = res.params['Av'].value Avmc = np.percentile(res.flatchain['Av'], [16, 50, 84]) AAvmc = [Avmc] try: zmc = np.percentile(res.flatchain['zmc'], [16, 50, 84]) except: zmc = z_cz AA_tmp = np.zeros(len(age), dtype='float32') ZZ_tmp = np.zeros(len(age), dtype='float32') NZbest = np.zeros(len(age), dtype='int') DIR_TMP = self.DIR_TEMP # # Get mcmc model templates, plus some indicies. # #print(res.flatchain['Av'][0]) from lmfit import Parameters fit_params = Parameters() for mm in range(0, mmax, 1): rn = np.random.randint(len(samples)) ''' par_tmp = samples[np.random.randint(len(samples))] AA_tmp[:] = par_tmp[:len(age)] Av_tmp = par_tmp[len(age)] if self.ZEVOL == 1: ZZ_tmp[:] = par_tmp[len(age)+1:len(age)+1+len(age)] else: ZZ_tmp[:] = par_tmp[len(age)+1:len(age)+1+1] ''' for aa in range(len(age)): fit_params.add('A' + str(aa), value=res.flatchain['A%d' % (aa)][rn], min=0, max=10000) fit_params.add('Av', value=res.flatchain['Av'][rn], min=0, max=10) for aa in range(len(age)): try: fit_params.add('Z' + str(aa), value=res.flatchain['Z%d' % (aa)][rn], min=-10, max=10) except: pass model2, xm_tmp = fnc.tmp04(ID0, PA0, fit_params, zrecom, lib_all, tau0=tau0) ''' # not necessary here. if self.f_dust: model2_dust, xm_tmp_dust = fnc.tmp04_dust(ID0, PA0, par_tmp, zrecom, lib_all, tau0=tau0) model2 = np.append(model2,model2_dust) xm_tmp = np.append(xm_tmp,xm_tmp_dust) ''' lmrest = xm_tmp / (1. + zrecom) band0 = ['u', 'b', 'v', 'j', 'sz'] lmconv, fconv = filconv(band0, lmrest, model2, fil_path) # model2 in fnu Dn4[mm] = calc_Dn4(xm_tmp, model2, zrecom) # Dust attenuation is not included? uv[mm] = -2.5 * np.log10(fconv[0] / fconv[2]) bv[mm] = -2.5 * np.log10(fconv[1] / fconv[2]) vj[mm] = -2.5 * np.log10(fconv[2] / fconv[3]) zj[mm] = -2.5 * np.log10(fconv[4] / fconv[3]) ''' AA_tmp_sum = 0 for ii in range(len(ZZ_tmp)): NZbest[ii] = bfnc.Z2NZ(ZZ_tmp[ii]) AA_tmp_sum += AA_tmp[ii] f0 = fits.open(DIR_TMP + 'index_'+str(NZbest[ii])+'.fits') Mgb[mm] += f0[1].data['Mgb_'+str(NZbest[ii])][ii] * AA_tmp[ii] Fe52[mm] += f0[1].data['Fe5270_'+str(NZbest[ii])][ii] * AA_tmp[ii] Fe53[mm] += f0[1].data['Fe5335_'+str(NZbest[ii])][ii] * AA_tmp[ii] G4300[mm]+= f0[1].data['G4300_'+str(NZbest[ii])][ii] * AA_tmp[ii] NaD[mm] += f0[1].data['NaD_'+str(NZbest[ii])][ii] * AA_tmp[ii] Hb[mm] += f0[1].data['Hb_'+str(NZbest[ii])][ii] * AA_tmp[ii] Mg1[mm] += f0[1].data['Mg1_'+str(NZbest[ii])][ii] * AA_tmp[ii] Mg2[mm] += f0[1].data['Mg2_'+str(NZbest[ii])][ii] * AA_tmp[ii] Mgb[mm] /= AA_tmp_sum Fe52[mm] /= AA_tmp_sum Fe53[mm] /= AA_tmp_sum G4300[mm] /= AA_tmp_sum NaD[mm] /= AA_tmp_sum Hb[mm] /= AA_tmp_sum Mg1[mm] /= AA_tmp_sum Mg2[mm] /= AA_tmp_sum ''' conper = (Dn4 > -99) #(Dn4>0) Dnmc = np.percentile(Dn4[conper], [16, 50, 84]) uvmc = np.percentile(uv[conper], [16, 50, 84]) bvmc = np.percentile(bv[conper], [16, 50, 84]) vjmc = np.percentile(vj[conper], [16, 50, 84]) zjmc = np.percentile(zj[conper], [16, 50, 84]) Mgbmc = np.percentile(Mgb[conper], [16, 50, 84]) Fe52mc = np.percentile(Fe52[conper], [16, 50, 84]) Fe53mc = np.percentile(Fe53[conper], [16, 50, 84]) G4300mc = np.percentile(G4300[conper], [16, 50, 84]) NaDmc = np.percentile(NaD[conper], [16, 50, 84]) Hbmc = np.percentile(Hb[conper], [16, 50, 84]) Mg1mc = np.percentile(Mg1[conper], [16, 50, 84]) Mg2mc = np.percentile(Mg2[conper], [16, 50, 84]) ############ # Get SN. ############ file = DIR_TMP + 'spec_obs_' + ID0 + '_PA' + PA0 + '.cat' fds = np.loadtxt(file, comments='#') nrs = fds[:, 0] lams = fds[:, 1] fsp = fds[:, 2] esp = fds[:, 3] consp = (nrs < 10000) & (lams / (1. + zrecom) > 3600) & (lams / (1. + zrecom) < 4200) NSN = len((fsp / esp)[consp]) if NSN > 0: SN = np.median((fsp / esp)[consp]) else: SN = 0 ###################### # Write in Fits table. ###################### # Header prihdr = fits.Header() prihdr['ID'] = ID0 prihdr['PA'] = PA0 prihdr['Cz0'] = Czrec0 prihdr['Cz1'] = Czrec1 prihdr['z'] = zrecom prihdr['SN'] = SN prihdr['nSN'] = NSN prihdr['NDIM'] = ndim prihdr['tcalc'] = tcalc prihdr['chi2'] = fitc[0] prihdr['chi2nu'] = fitc[1] prihdu = fits.PrimaryHDU(header=prihdr) # Data col01 = [] for aa in range(len(age)): col50 = fits.Column(name='A' + str(aa), format='E', unit='', array=Amc[aa][:]) col01.append(col50) for aa in range(len(AAvmc)): col50 = fits.Column(name='Av' + str(aa), format='E', unit='mag', array=AAvmc[aa][:]) col01.append(col50) for aa in range(len(Zmc)): col50 = fits.Column(name='Z' + str(aa), format='E', unit='logZsun', array=Zmc[aa][:]) col01.append(col50) if self.f_dust: Mdustmc[:] = np.percentile(res.flatchain['MDUST'], [16, 50, 84]) nTdustmc[:] = np.percentile(res.flatchain['TDUST'], [16, 50, 84]) Tdustmc[:] = self.DT0 + self.dDT * nTdustmc[:] col50 = fits.Column(name='MDUST', format='E', unit='Msun', array=Mdustmc[:]) col01.append(col50) col50 = fits.Column(name='nTDUST', format='E', unit='K', array=nTdustmc[:]) col01.append(col50) col50 = fits.Column(name='TDUST', format='E', unit='K', array=Tdustmc[:]) col01.append(col50) # zmc #if int(inputs['ZMC']) == 1: col50 = fits.Column(name='zmc', format='E', unit='', array=zmc[:]) col01.append(col50) # Dn4000 col50 = fits.Column(name='Dn4', format='E', unit='', array=Dnmc[:]) col01.append(col50) # Mass col50 = fits.Column(name='ms', format='E', unit='Msun', array=msmc[:]) col01.append(col50) # U-V col50 = fits.Column(name='uv', format='E', unit='mag', array=uvmc[:]) col01.append(col50) # V-J col50 = fits.Column(name='vj', format='E', unit='mag', array=vjmc[:]) col01.append(col50) # B-V col50 = fits.Column(name='bv', format='E', unit='mag', array=bvmc[:]) col01.append(col50) # z-J col50 = fits.Column(name='zj', format='E', unit='mag', array=zjmc[:]) col01.append(col50) # zmc col50 = fits.Column(name='z_cz', format='E', unit='', array=z_cz[:]) col01.append(col50) # Chi col50 = fits.Column(name='chi', format='E', unit='', array=fitc[:]) col01.append(col50) # C0 scale col50 = fits.Column(name='Cscale0', format='E', unit='', array=scl_cz0[:]) col01.append(col50) # C1 scale col50 = fits.Column(name='Cscale1', format='E', unit='', array=scl_cz1[:]) col01.append(col50) # Mgb col50 = fits.Column(name='Mgb', format='E', unit='', array=Mgbmc[:]) col01.append(col50) # Fe5270 col50 = fits.Column(name='Fe5270', format='E', unit='', array=Fe52mc[:]) col01.append(col50) # Fe5335 col50 = fits.Column(name='Fe5335', format='E', unit='', array=Fe53mc[:]) col01.append(col50) # G4300 col50 = fits.Column(name='G4300', format='E', unit='', array=G4300mc[:]) col01.append(col50) # NaD col50 = fits.Column(name='NaD', format='E', unit='', array=NaDmc[:]) col01.append(col50) # Hb col50 = fits.Column(name='Hb', format='E', unit='', array=Hbmc[:]) col01.append(col50) # Mg1 col50 = fits.Column(name='Mg1', format='E', unit='', array=Mg1mc[:]) col01.append(col50) # Mg2 col50 = fits.Column(name='Mg2', format='E', unit='', array=Mg2mc[:]) col01.append(col50) # Summarize; colms = fits.ColDefs(col01) dathdu = fits.BinTableHDU.from_columns(colms) hdu = fits.HDUList([prihdu, dathdu]) hdu.writeto('summary_' + ID0 + '_PA' + PA0 + '.fits', overwrite=True) ########## # LINES ########## MB = Mainbody(self.inputs) LW, fLW = MB.get_lines(self.LW0) fw = open('table_' + ID0 + '_PA' + PA0 + '_lines.txt', 'w') fw.write( '# ID PA WL Fcont50 Fcont16 Fcont84 Fline50 Fline16 Fline84 EW50 EW16 EW84\n' ) for ii in range(len(LW)): if fLW[ii] == 1: fw.write( '%s %s %d %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f\n' % (ID0, PA0, LW[ii], np.median( Fcont[ii, :]), np.percentile(Fcont[ii, :], 16), np.percentile(Fcont[ii, :], 84), np.median( Fline[ii, :]), np.percentile(Fline[ii, :], 16), np.percentile(Fline[ii, :], 84), np.median( EW[ii, :]), np.percentile( EW[ii, :], 16), np.percentile(EW[ii, :], 84))) else: fw.write('%s %s %d 0 0 0 0 0 0 0 0 0\n' % (ID0, PA0, LW[ii])) fw.close()
def subtract_self(frand, index, FTSobsid, redshift, width_of_sm_kernel, apod_width, Name, window): freq_Cp = 1900.55 / (1 + redshift) freq_Oiii88 = frand #random freq signal freq_Oiii51 = 5785.88 / (1 + redshift) freq_NII122 = 2459.38 / (1 + redshift) freq_OI63 = 4744.75 / (1 + redshift) freq_H2O1 = 1661. / (1 + redshift) freq_H2O2 = 1670. / (1 + redshift) freq_OH = 2512.30 / (1 + redshift) freq_HF10 = 1232.48 / (1 + redshift) freq_OI145 = 2060.07 / (1 + redshift) freq_list = [ [freq_Cp, "C$^+$ 158"], [freq_Oiii88, 'O$_{III} 88$'], [freq_Oiii51, 'O$_{III} 51$'], [freq_NII122, 'N$_{II}$122'], [freq_OI63, 'O$_{I}$63'], [freq_H2O1, 'H$_2$O-1'], [freq_H2O2, 'H$_2$O-2'], [freq_OH, 'OH'], [freq_OI145, 'O$_I$145'], ] ## read in the target spectra spec = fits.open(str(FTSobsid) + '_HR_spectrum_point_apod.fits') # spec = fits.open(str(FTSobsid)+'_HR_spectrum_point.fits') spec_ori = fits.open(str(FTSobsid) + '_HR_spectrum_point.fits') # define detectors of SLW and SSW centreDetectors = ["SLWC3", "SSWD4"] # define the output spectra (using the central pixel) cent_spec_SLW = np.full((3, 1905), 1.0) cent_spec_SSW = np.full((3, 2082), 1.0) # assignment of the output spectra for k in range(2, 24): if (spec[k].header['EXTNAME'] == centreDetectors[0]): cent_spec_SLW[0, ] = spec[k].data.wave cent_spec_SLW[1, ] = spec[k].data.flux cent_spec_SLW[2, ] = spec_ori[k].data.error / np.sqrt( apod_width / 1.2) if (spec[k].header['EXTNAME'] == centreDetectors[1]): cent_spec_SSW[0, ] = spec[k].data.wave cent_spec_SSW[1, ] = spec[k].data.flux cent_spec_SSW[2, ] = spec_ori[k].data.error / np.sqrt( apod_width / 1.2) ## -------------define different Gaussian Kernels g = Gaussian1DKernel(stddev=width_of_sm_kernel) ## --------------- make random frequency of sinc functions and add in p0 = 0.3 # peak p1 = frand #800 # central freq p2 = 0.37733 * 2 # Delta sigma / pi; FWHM = 1.20671 * \Delta sigma x = cent_spec_SLW[0, ] sinconly = p0 * np.sinc((x - p1) / p2) spec_n_sinc = sinconly + cent_spec_SLW[1, ] cent_spec_SLW[1, ] = spec_n_sinc #------------------------------------------------------------ # directly derive the local baseline using the spectra themselves, without dark sky subtraction ## - mask/flag the channels with signals #------------------------------------------------------------ cent_SLW_nan = copy.copy(cent_spec_SLW[1]) for freq_obs, name in freq_list: cent_SLW_nan[np.where( np.abs(cent_spec_SLW[0] - freq_obs) < window / 2)] = np.nan cent_SSW_nan = copy.copy(cent_spec_SSW[1]) for freq_obs, name in freq_list: cent_SSW_nan[np.where( np.abs(cent_spec_SSW[0] - freq_obs) < window / 2)] = np.nan #------------------------------------------------------------ ## ----- convolve the central spectra (after blanking) to lower resolutions to derive the 'local' baseline shape. cent_SLW_nan_sm = convolve(cent_SLW_nan, g, boundary='extend') cent_SLW_subtract_self_base = cent_spec_SLW[1] - cent_SLW_nan_sm cent_SSW_nan_sm = convolve(cent_SSW_nan, g, boundary='extend') cent_SSW_subtract_self_base = cent_spec_SSW[1] - cent_SSW_nan_sm cent_SLW_err = cent_spec_SLW[2, ] cent_SSW_err = cent_spec_SSW[2, ] edge_cut = 0 #120 edge_SLW_low_cut = 0 #30 edge_SLW_high_cut = 0 #180 edge_SSW_low_cut = 0 #30 edge_SSW_high_cut = 0 #30 SLW_size = len(cent_spec_SLW[0]) SSW_size = len(cent_spec_SSW[0]) cent_SLW_subtract_self_base = copy.copy( cent_SLW_subtract_self_base[edge_SLW_low_cut:SLW_size - edge_SLW_high_cut]) cent_SSW_subtract_self_base = copy.copy( cent_SSW_subtract_self_base[edge_SSW_low_cut:SSW_size - edge_SSW_high_cut]) cent_SLW_wave = copy.copy(cent_spec_SLW[0][edge_SLW_low_cut:SLW_size - edge_SLW_high_cut]) cent_SSW_wave = copy.copy(cent_spec_SSW[0][edge_SSW_low_cut:SSW_size - edge_SSW_high_cut]) #-------------- plot the added sinc spectra ---------------- plt.clf() fig, ax_f = plt.subplots() ax_f.plot(cent_spec_SLW[0], sinconly, label='SLW', linewidth=0.1) # ax_f.plot(cent_spec_SSW[0], spec_n_sinc , label='SSW' , linewidth=0.1 ) ymin, ymax = ax_f.get_ylim() ax_f.set_xlim(400, 1600) ax_f.annotate(Name, (1200, ymax * 0.9), size=12) ax_f.annotate('obsid ' + str(FTSobsid), (1200, ymax * 0.8), size=12) ax_f.text(250, 0.2, "Flux density (Jy)", rotation=90, size='12') ax_f.text(800, ymin - 0.2, "Frequency (GHz)", size='12') textlines(ax_f, redshift, 0.3, freq_list) plt.legend(loc=2, borderaxespad=0.) plt.savefig('plots/overlay/' + str(FTSobsid) + str(index) + '_sinc_only.pdf') #-------------- plot the baseline and original spectra ---------------- #-------------- plot the baseline and original spectra ---------------- plt.clf() fig, ax_f = plt.subplots() ax_f.plot(cent_spec_SLW[0], cent_spec_SLW[1], label='SLW', linewidth=0.1) ax_f.plot(cent_spec_SSW[0], cent_spec_SSW[1], label='SSW', linewidth=0.1) ax_f.plot(cent_spec_SLW[0], cent_SLW_nan_sm, label='BL SLW', linewidth=0.1) ax_f.plot(cent_spec_SSW[0], cent_SSW_nan_sm, label='BL SSW', linewidth=0.1) print(cent_SLW_nan_sm) ymin, ymax = ax_f.get_ylim() ax_f.set_xlim(400, 1600) ax_f.annotate(Name, (1200, ymax * 0.9), size=12) ax_f.annotate('obsid ' + str(FTSobsid), (1200, ymax * 0.8), size=12) ax_f.text(250, 0.2, "Flux density (Jy)", rotation=90, size='12') ax_f.text(800, ymin - 0.2, "Frequency (GHz)", size='12') textlines(ax_f, redshift, 0.3, freq_list) plt.legend(loc=2, borderaxespad=0.) plt.savefig('plots/overlay/' + str(FTSobsid) + str(index) + '_subtracted.pdf') #-------------- plot the baseline and original spectra ---------------- #-------------- plot the baseline subtracted spectra ---------------- plt.clf() fig, ax_f = plt.subplots() ax_f.plot(cent_SLW_wave, cent_SLW_subtract_self_base, label='SLW', linewidth=0.1) # ax_f.plot(cent_spec_SLW[0], cent_SLW_err, label='SLW err') # ax_f.plot(cent_spec_SLW[0], cent_SLW_err*(-1)) ax_f.plot(cent_SSW_wave, cent_SSW_subtract_self_base, label='SSW', linewidth=0.1) # ax_f.plot(cent_spec_SSW[0], cent_SSW_subtract_self_base* 0, label=str(Name)) # ax_f.plot(cent_spec_SSW[0], cent_SLW_err, label='SSW err') # ax_f.plot(cent_spec_SSW[0], cent_SLW_err*(-1)) ax_f.set_ylim(-0.5, 0.7) ax_f.set_xlim(400, 1600) ax_f.annotate(Name, (1400, 0.6), size=12) ax_f.text(250, 0.2, "Flux density (Jy)", rotation=90, size='12') ax_f.text(800, -0.6, "Frequency (GHz)", size='12') ax_f.set_xlim(freq_Oiii88 - 20, freq_Oiii88 + 20) textlines(ax_f, redshift, 0.3, freq_list) plt.legend(loc=2, borderaxespad=0.) plt.savefig('plots/overlay/all' + str(FTSobsid) + str(index) + '_subtracted.pdf') ax_f.set_ylim(-0.5, 0.7) plt.legend(loc=2, borderaxespad=0.) textlines(ax_f, redshift, 0.3, freq_list) ax_f.set_xlim(freq_Cp - 20, freq_Cp + 20) plt.savefig('plots/overlay/cplus' + str(FTSobsid) + str(index) + '_subtracted.pdf') ax_f.set_xlim(freq_Oiii88 - 20, freq_Oiii88 + 20) plt.savefig('plots/overlay/oiii88' + str(FTSobsid) + str(index) + '_subtracted.pdf') #----------------------------------------------------------------- #----------------- output fits files -------------------- # SLW hdu = fits.PrimaryHDU() table_hdu = fits.new_table( fits.ColDefs([ fits.Column(name='wave', format='D', unit='GHz', array=cent_spec_SLW[0]), fits.Column(name='flux', format='D', unit='Jy', array=cent_SLW_subtract_self_base), fits.Column(name='error', format='D', unit='Jy', array=cent_spec_SLW[2, ]), ])) hdulist = fits.HDUList([hdu, table_hdu]) hdulist.writeto('baselined/' + str(FTSobsid) + '_HR_spectrum_point_SLW_apod_baselined.fits', clobber=True) # SSW hdu = fits.PrimaryHDU() table_hdu = fits.new_table( fits.ColDefs([ fits.Column(name='wave', format='D', unit='GHz', array=cent_spec_SSW[0]), fits.Column(name='flux', format='D', unit='Jy', array=cent_SSW_subtract_self_base), fits.Column(name='error', format='D', unit='Jy', array=cent_spec_SSW[2, ]), ])) hdulist = fits.HDUList([hdu, table_hdu]) hdulist.writeto('baselined/' + str(FTSobsid) + '_HR_spectrum_point_SSW_apod_baselined.fits', clobber=True)
def main(argv=None): import argparse parser = argparse.ArgumentParser( description= "Use PINT to compute event phases and make plots of photon event files." ) parser.add_argument( "eventfile", help= "Photon event FITS file name (e.g. from NICER, RXTE, XMM, Chandra).") parser.add_argument("parfile", help="par file to construct model from") parser.add_argument("--orbfile", help="Name of orbit file", default=None) parser.add_argument("--maxMJD", help="Maximum MJD to include in analysis", default=None) parser.add_argument("--plotfile", help="Output figure file name (default=None)", default=None) parser.add_argument("--addphase", help="Write FITS file with added phase column", default=False, action='store_true') parser.add_argument( "--absphase", help="Write FITS file with integral portion of pulse phase (ABS_PHASE)", default=False, action='store_true') parser.add_argument( "--barytime", help= "Write FITS file with a column containing the barycentric time as double precision MJD.", default=False, action='store_true') parser.add_argument( "--outfile", help="Output FITS file name (default=same as eventfile)", default=None) parser.add_argument("--ephem", help="Planetary ephemeris to use (default=DE421)", default="DE421") parser.add_argument( '--tdbmethod', help="Method for computing TT to TDB (default=astropy)", default="default") parser.add_argument("--plot", help="Show phaseogram plot.", action='store_true', default=False) parser.add_argument("--use_gps", default=False, action='store_true', help="Apply GPS to UTC clock corrections") parser.add_argument("--use_bipm", default=False, action='store_true', help="Use TT(BIPM) instead of TT(TAI)") # parser.add_argument("--fix",help="Apply 1.0 second offset for NICER", action='store_true', default=False) args = parser.parse_args(argv) # If outfile is specified, that implies addphase if args.outfile is not None: args.addphase = True # If plotfile is specified, that implies plot if args.plotfile is not None: args.plot = True # Read event file header to figure out what instrument is is from hdr = pyfits.getheader(args.eventfile, ext=1) log.info('Event file TELESCOPE = {0}, INSTRUMENT = {1}'.format( hdr['TELESCOP'], hdr['INSTRUME'])) if hdr['TELESCOP'] == 'NICER': # Instantiate NICERObs once so it gets added to the observatory registry if args.orbfile is not None: log.info('Setting up NICER observatory') NICERObs(name='NICER', FPorbname=args.orbfile, tt2tdb_mode='pint') # Read event file and return list of TOA objects try: tl = load_NICER_TOAs(args.eventfile) except KeyError: log.error( "Observatory not recognized. This probably means you need to provide an orbit file or barycenter the event file." ) sys.exit(1) elif hdr['TELESCOP'] == 'XTE': # Instantiate RXTEObs once so it gets added to the observatory registry if args.orbfile is not None: # Determine what observatory type is. log.info('Setting up RXTE observatory') RXTEObs(name='RXTE', FPorbname=args.orbfile, tt2tdb_mode='pint') # Read event file and return list of TOA objects tl = load_RXTE_TOAs(args.eventfile) elif hdr['TELESCOP'].startswith('XMM'): # Not loading orbit file here, since that is not yet supported. tl = load_XMM_TOAs(args.eventfile) elif hdr['TELESCOP'].startswith('NuSTAR'): # Not loading orbit file here, since that is not yet supported. tl = load_NuSTAR_TOAs(args.eventfile) else: log.error( "FITS file not recognized, TELESCOPE = {0}, INSTRUMENT = {1}". format(hdr['TELESCOP'], hdr['INSTRUME'])) sys.exit(1) # Now convert to TOAs object and compute TDBs and posvels if len(tl) == 0: log.error("No TOAs, exiting!") sys.exit(0) # Read in model modelin = pint.models.get_model(args.parfile) use_planets = False if 'PLANET_SHAPIRO' in modelin.params: if modelin.PLANET_SHAPIRO.value: use_planets = True # Discard events outside of MJD range if args.maxMJD is not None: tlnew = [] print("pre len : ", len(tl)) maxT = Time(float(args.maxMJD), format='mjd') print("maxT : ", maxT) for tt in tl: if tt.mjd < maxT: tlnew.append(tt) tl = tlnew print("post len : ", len(tlnew)) ts = toa.get_TOAs_list(tl, ephem=args.ephem, include_bipm=args.use_bipm, include_gps=args.use_gps, planets=use_planets, tdb_method=args.tdbmethod) ts.filename = args.eventfile # if args.fix: # ts.adjust_TOAs(TimeDelta(np.ones(len(ts.table))*-1.0*u.s,scale='tt')) print(ts.get_summary()) mjds = ts.get_mjds() print(mjds.min(), mjds.max()) # Compute model phase for each TOA iphss, phss = modelin.phase(ts, abs_phase=True) # ensure all postive negmask = phss < 0.0 * u.cycle phases = np.where(negmask, phss + 1.0 * u.cycle, phss) h = float(hm(phases)) print("Htest : {0:.2f} ({1:.2f} sigma)".format(h, h2sig(h))) if args.plot: phaseogram_binned(mjds, phases, bins=100, plotfile=args.plotfile) if args.addphase: # Read input FITS file (again). # If overwriting, open in 'update' mode if args.outfile is None: hdulist = pyfits.open(args.eventfile, mode='update') else: hdulist = pyfits.open(args.eventfile) if len(hdulist[1].data) != len(phases): raise RuntimeError( 'Mismatch between length of FITS table ({0}) and length of phase array ({1})!' .format(len(hdulist[1].data), len(phases))) data_to_add = {'PULSE_PHASE': [phases, 'D']} if args.absphase: data_to_add['ABS_PHASE'] = [iphss - negmask * u.cycle, 'K'] if args.barytime: bats = modelin.get_barycentric_toas(ts) data_to_add['BARY_TIME'] = [bats, 'D'] datacol = [] for key in data_to_add.keys(): if key in hdulist[1].columns.names: log.info('Found existing %s column, overwriting...' % key) # Overwrite values in existing Column hdulist[1].data[key] = data_to_add[key][0] else: # Construct and append new column, preserving HDU header and name log.info('Adding new %s column.' % key) datacol.append( pyfits.ColDefs([ pyfits.Column(name=key, format=data_to_add[key][1], array=data_to_add[key][0]) ])) if len(datacol) > 0: cols = hdulist[1].columns for c in datacol: cols = cols + c bt = pyfits.BinTableHDU.from_columns(cols, header=hdulist[1].header, name=hdulist[1].name) hdulist[1] = bt if args.outfile is None: # Overwrite the existing file log.info('Overwriting existing FITS file ' + args.eventfile) hdulist.flush(verbose=True, output_verify='warn') else: # Write to new output file log.info('Writing output FITS file ' + args.outfile) hdulist.writeto(args.outfile, overwrite=True, checksum=True, output_verify='warn')
def _write_singledish_hdu(self): """ Define the SINGLE DISH table. """ scanList = [] dateList = [] timeList = [] intTimeList = [] beamList = [] mList = [] rawList = [] scanCount = 1 for i, dataSet in enumerate(self.data): if dataSet.pol == self.stokes[0]: tempMList = {} for stokes in self.stokes: tempMList[stokes] = {} beams = list(dataSet.dataDict.keys()) beams.sort() for b in beams: specData = dataSet.dataDict[b] # Load the data into a matrix tempMList[dataSet.pol][b] = specData.ravel() if dataSet.pol == self.stokes[0]: # Observation date and time utc = astro.taimjd_to_utcjd(dataSet.obsTime) date = astro.get_date(utc) date.hours = 0 date.minutes = 0 date.seconds = 0 utc0 = date.to_jd() scanList.append(scanCount) dateList.append('%4i-%02i-%02i' % (date.years, date.months, date.days)) timeList.append((utc - utc0) * 24 * 3600) intTimeList.append(dataSet.intTime) beamList.append(b.id) rawList.append(b) if dataSet.pol == self.stokes[-1]: for b in rawList: matrix = numpy.zeros((self.nStokes, self.nChan), dtype=numpy.float32) for p in range(self.nStokes): try: matrix[p, :] = tempMList[self.stokes[p]][b] except KeyError: warnings.warn( colorfy( "{{%%yellow Key mis-match %s %s}}" % (str(b), str(tempMList[self.stokes[p]].keys()))), RuntimeWarning) mList.append(matrix.ravel()) scanCount += 1 rawList = [] # Scan number c1 = astrofits.Column(name='SCAN', format='1I', array=numpy.array(scanList)) ## Cycle #c2 = astrofits.Column(name='CYCLE', format='1J', #array=numpy.array([1,]*len(scanList))) # DATE-OBS c3 = astrofits.Column(name='DATE-OBS', format='10A', array=numpy.array(dateList)) # Time elapsed since 0h c4 = astrofits.Column(name='TIME', format='1D', unit='s', array=numpy.array(timeList)) # Integration time (seconds) c5 = astrofits.Column(name='EXPOSURE', format='1E', unit='s', array=numpy.array(intTimeList, dtype=numpy.float32)) # Object name c6 = astrofits.Column(name='OBJECT', format='16A', array=numpy.array([ 'LWA_OBS', ] * len(scanList))) # Object position (deg and deg) c7 = astrofits.Column(name='OBJ-RA', format='1D', unit='deg', array=numpy.array([ 0.0, ] * len(scanList))) c8 = astrofits.Column(name='OBJ-DEC', format='1D', unit='deg', array=numpy.array([ 0.0, ] * len(scanList))) # Rest frequency (Hz) c9 = astrofits.Column(name='RESTFRQ', format='1D', unit='Hz', array=numpy.array([ 0.0, ] * len(scanList))) # Observation mode c10 = astrofits.Column(name='OBSMODE', format='16A', array=numpy.array([ self.mode, ] * len(scanList))) # Beam (tuning) c11 = astrofits.Column(name='BEAM', format='1I', array=numpy.array(beamList)) # IF c12 = astrofits.Column(name='IF', format='1I', array=numpy.array([ self.freq[0].id, ] * len(scanList))) # Frequency resolution (Hz) c13 = astrofits.Column(name='FREQRES', format='1D', unit='Hz', array=numpy.array([ self.freq[0].chWidth, ] * len(scanList))) # Bandwidth of the system (Hz) c14 = astrofits.Column(name='BANDWID', format='1D', unit='Hz', array=numpy.array([ self.freq[0].totalBW, ] * len(scanList))) # Frequency axis - 1 c15 = astrofits.Column(name='CRPIX1', format='1E', array=numpy.array([ self.refPix, ] * len(scanList))) c16 = astrofits.Column(name='CRVAL1', format='1D', unit='Hz', array=numpy.array([ self.refVal, ] * len(scanList))) c17 = astrofits.Column(name='CDELT1', format='1D', unit='Hz', array=numpy.array([ self.freq[0].chWidth, ] * len(scanList))) c18 = astrofits.Column(name='CRVAL3', format='1D', unit='deg', array=numpy.array([ 0.0, ] * len(scanList))) # Dec. axis - 4 c19 = astrofits.Column(name='CRVAL4', format='1D', unit='deg', array=numpy.array([ 0.0, ] * len(scanList))) ## Scan rate #c20 = astrofits.Column(name='SCANRATE', format='2E', unit='deg/s', #array=numpy.array([[0,0],]*len(scanList))) # # Calibration information (currently not implemented) # ## System temperature *** UNKNOWN *** #c21 = astrofits.Column(name='TSYS', format='2E', unit='K', #array=numpy.array([[self.tSys,self.tSys],]*len(scanList))) ## CALFCTR *** UNKNOWN *** #c22 = astrofits.Column(name='CALFCTR', format='2E', unit='K', #array=numpy.array([[1,1],]*len(scanList))) # Data c23 = astrofits.Column(name='DATA', format='%iE' % (self.nStokes * self.nChan), unit='UNCALIB', array=numpy.array(mList)) # # Data masking table (currently not implemented) # # Flag table #c24 = astrofits.Column(name='FLAGGED', format='%iB' % (self.nStokes*self.nChan), #array=numpy.array([[0,]*self.nStokes*self.nChan for s in scanList])) # # Calibration information (currently not implemented) # ## TCAL *** UNKNOWN *** #c25 = astrofits.Column(name='TCAL', format='2E', unit='Jy', #array=numpy.array([[1,1] for s in scanList])) ## TCALTIME *** UNKNOWN *** #c26 = astrofits.Column(name='TCALTIME', format='16A', #array=numpy.array(['UNKNOWN',]*len(scanList))) # # Pointing information (currently not implemented) # ## Azimuth *** UNKNOWN *** #c27 = astrofits.Column(name='AZIMUTH', format='1E', unit='deg', #array=numpy.array([0,]*len(scanList))) ## Elevation *** UNKNOWN *** #c28 = astrofits.Column(name='ELEVATIO', format='1E', unit='deg', #array=numpy.array([0,]*len(scanList))) ## Parallactic angle *** UNKNOWN *** #c29 = astrofits.Column(name='PARANGLE', format='1E', unit='deg', #array=numpy.array([0,]*len(scanList))) # # Focusing information (currently not implemented and probably never will be) # ## FOCUSAXI *** NOT NEEDED *** #c30 = astrofits.Column(name='FOCUSAXI', format='1E', unit='m', #array=numpy.array([0,]*len(scanList))) ## FOCUSTAN *** NOT NEEDED *** #c31 = astrofits.Column(name='FOCUSTAN', format='1E', unit='m', #array=numpy.array([0,]*len(scanList))) ## FOCUSROT *** NOT NEEDED *** #c32 = astrofits.Column(name='FOCUSROT', format='1E', unit='deg', #array=numpy.array([0,]*len(scanList))) # # Weather information (currently not implemented) # ## Ambient temperature *** UNKNOWN *** #c33 = astrofits.Column(name='TAMBIENT', format='1E', unit='C', #array=numpy.array([0,]*len(scanList))) ## Air pressure *** UNKNOWN *** #c34 = astrofits.Column(name='PRESSURE', format='1E', unit='Pa', #array=numpy.array([0,]*len(scanList))) ## Humidity *** UNKNOWN *** #c35 = astrofits.Column(name='HUMIDITY', format='1E', unit='%', #array=numpy.array([0,]*len(scanList))) ## Wind speed *** UNKNOWN *** #c36 = astrofits.Column(name='WINDSPEE', format='1E', unit='m/s', #array=numpy.array([0,]*len(scanList))) ## Wind direction *** UNKNOWN *** #c37 = astrofits.Column(name='WINDDIRE', format='1E', unit='deg', #array=numpy.array([0,]*len(scanList))) # Gather together all of the needed columns and figure out which ones # store the data and flag tables. This information is needed later to # set the appropriate TDIM keywords. cs = [ c1, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c23 ] dataIndex = 0 #flagIndex = 0 for i, c in enumerate(cs): try: if c.name == 'DATA': dataIndex = i + 1 #if c.name == 'FLAGGED': #flagIndex = n except NameError: pass colDefs = astrofits.ColDefs(cs) # Create the SINGLE DISH table and update its header sd = astrofits.BinTableHDU.from_columns(colDefs) ## Single disk keywords - order seems to matter sd.header['EXTNAME'] = ('SINGLE DISH', 'SDFITS table name') sd.header['NMATRIX'] = 1 sd.header['OBSERVER'] = (self.observer, 'Observer name(s)') sd.header['PROJID'] = (self.project, 'Project name') sd.header['TELESCOP'] = (self.site.name, 'Telescope name') x, y, z = self.site.geocentric_location sd.header['OBSGEO-X'] = (x, '[m] Antenna ECEF X-coordinate') sd.header['OBSGEO-Y'] = (y, '[m] Antenna ECEF Y-coordinate') sd.header['OBSGEO-Z'] = (z, '[m] Antenna ECEF Z-coordinate') sd.header['SPECSYS'] = ('LSRK', 'Doppler reference frame (transformed)') sd.header['SSYSOBS'] = ('TOPOCENT', 'Doppler reference frame of observation') sd.header['EQUINOX'] = (2000.0, 'Equinox of equatorial coordinates') sd.header['RADESYS'] = ('FK5', 'Equatorial coordinate system frame') ## Data and flag table dimensionality sd.header['TDIM%i' % dataIndex] = ('(%i,%i,1,1)' % (self.nChan, self.nStokes)) #sd.header.set('TDIM%i' % flagIndex, '(%i,%i,1,1)' % (self.nChan, self.nStokes), after='TFORM%i' % flagIndex) ## Data and flag table axis descriptions ### Frequency sd.header['CTYPE1'] = ('FREQ', 'axis 1 is FREQ (frequency)') sd.header['CDELT1'] = self.freq[0].chWidth sd.header['CRPIX1'] = self.refPix sd.header['CRVAL1'] = self.refVal ### Stokes sd.header['CTYPE2'] = ('STOKES', 'axis 2 is STOKES axis (polarization)') if self.stokes[0] < 0: sd.header['CDELT2'] = -1.0 else: sd.header['CDELT2'] = 1.0 sd.header['CRPIX2'] = 1.0 sd.header['CRVAL2'] = float(self.stokes[0]) ### RA sd.header['CTYPE3'] = ('RA', 'axis 3 is RA axis (pointing)') sd.header['CRPIX3'] = 1.0 sd.header['CDELT3'] = -1.0 ### Dec sd.header['CTYPE4'] = ('DEC', 'axis 4 is Dec. axis (pointing)') sd.header['CRPIX4'] = 1.0 sd.header['CDELT4'] = 1.0 self.FITS.append(sd) self.FITS.flush()
def keptrial(infile, outfile, datacol='SAP_FLUX', errcol='SAP_FLUX_ERR', fmin=0.1, fmax=50, nfreq=100, method='ft', ntrials=1000, plot=False, overwrite=False, verbose=False, logfile='keptrial.log'): """ keptrial -- Calculate best period and error estimate from time series ``keptrial`` measures the strongest period within the frequency range :math:`fmin` to :math:`fmax` and estimates 1-:math:`\sigma` error associated with that period. The error estimate is performed by constructing ntrial new light curves from the original data provided in datacol and adjusting each individual data point according to a random number generator and a shot noise model. While a shot noise model is not uniformly applicable to all Kepler targets it provides a useful 1st order estimate for most. A power spectrum is calculated for each light curve using a user-specified method and the highest peak in each power spectrum recorded. The distribution of peaks is fit by a normal function, the centroid is adopted as the best period and 1-standard deviation error is taken from the standard deviation. A confidence limit is recorded as the range within which all trial periods fall. While this is termed a '100%' confidence limit, this only refers to the total number of trials rather than formal confidence. The larger the number of **ntrials**, the more robust the result. The values of nfreq and ntrial have to be chosen carefully to avoid excessive run times. The values of **fmin**, **fmax** and **nfreq** have to be chosen carefully in order to provide a sensible measure of period and error. It is recommended that ``kepft`` be used to estimate the period and error before attempting to use ``keptrial``. An exercise of trial and error will most-likely be needed to choose a permutation of :math:`fmin`, :math:`fmax` and :math:`nfreq` that resolves the period distribution over a significant number of frequency bins. If requested, the distribution and normal fit are plotted. The plot updates after every ntrial iteration, partly to relieve boredom, and partly for the user to assess whether they are using the correct permutation of input parameters. Parameters ---------- infile : str The name of a MAST standard format FITS file containing a Kepler light curve within the first data extension. outfile : str The name of the output FITS file with a new extension containing the results of a Monte Carlo period analysis. datacol : str The column name containing data stored within extension 1 of infile. This data is the input data for a series of Fourier transform calculations. Typically this name is SAP_FLUX (Simple Aperture Photometry fluxes), but any data column within extension 1 of the FITS file can be used provided it is coupled to an error column name using errcol. errcol : str The uncertainty data coupled to datacol. Typically this column is called SAP_FLUX_ERR. fmin : float [1/day] The minimum frequency on which each power spectrum will be calculated. fmax : float [1/day] The maximum frequency on which each power spectrum will be calculated. nfreq : int The number of uniform frequency steps between fmin and fmax over which the power spectrum will be calculated. method : str Choose a method for calculating the power spectrum. Currently, only 'ft', a discrete Fourier transform, is available. ntrials : int The number of Monte Carlo trials required before calculating the best periods, period uncertainty and confidence in the measurement. plot : bool Plot the output window function? overwrite : bool Overwrite the output file? verbose : bool Print informative messages and warnings to the shell and logfile? logfile : str Name of the logfile containing error and warning messages. """ # startup parameters labelsize = 24 ticksize = 16 xsize = 18 ysize = 6 lcolor = '#0000ff' lwidth = 1.0 fcolor = '#ffff00' falpha = 0.2 # log the call hashline = '--------------------------------------------------------------' kepmsg.log(logfile, hashline, verbose) call = ('KEPTRIAL -- ' + ' infile={}'.format(infile) + ' outfile={}'.format(outfile) + ' datacol={}'.format(datacol) + ' errcol={}'.format(errcol) + ' fmin={}'.format(fmin) + ' fmax={}'.format(fmax) + ' nfreq={}'.format(nfreq) + ' method={}'.format(method) + ' ntrials={}'.format(ntrials) + ' plot={}'.format(plot) + ' overwrite={}'.format(overwrite) + ' verbose={}'.format(verbose) + ' logfile={}'.format(logfile)) kepmsg.log(logfile, call + '\n', verbose) # start time kepmsg.clock('KEPTRIAL started at', logfile, verbose) # overwrite output file if overwrite: kepio.overwrite(outfile, logfile, verbose) if kepio.fileexists(outfile): errmsg = 'ERROR -- KEPTRIAL: {} exists. Use --overwrite'.format( outfile) kepmsg.err(logfile, errmsg, verbose) # open input file instr = pyfits.open(infile, 'readonly') # fudge non-compliant FITS keywords with no values instr = kepkey.emptykeys(instr, infile, logfile, verbose) # input data try: barytime = instr[1].data.field('barytime') except: barytime = kepio.readfitscol(infile, instr[1].data, 'time', logfile, verbose) signal = kepio.readfitscol(infile, instr[1].data, datacol, logfile, verbose) err = kepio.readfitscol(infile, instr[1].data, errcol, logfile, verbose) # remove infinite data from time series try: nanclean = instr[1].header['NANCLEAN'] except: incols = [barytime, signal, err] [barytime, signal, err] = kepstat.removeinfinlc(signal, incols) # frequency steps and Monte Carlo iterations deltaf = (fmax - fmin) / nfreq freq, pmax, trial = [], [], [] for i in tqdm(range(ntrials)): trial.append(i + 1) # adjust data within the error bars work1 = kepstat.randarray(signal, err) # determine FT power fr, power = kepfourier.ft(barytime, work1, fmin, fmax, deltaf, False) # determine peak in FT pmax.append(-1.0e30) for j in range(len(fr)): if (power[j] > pmax[-1]): pmax[-1] = power[j] f1 = fr[j] freq.append(f1) # plot stop-motion histogram plt.figure() plt.clf() plt.axes([0.08, 0.08, 0.88, 0.89]) plt.gca().xaxis.set_major_formatter(plt.ScalarFormatter(useOffset=False)) plt.gca().yaxis.set_major_formatter(plt.ScalarFormatter(useOffset=False)) n, bins, patches = plt.hist(freq, bins=nfreq, range=[fmin, fmax], align='mid', rwidth=1, ec='#0000ff', fc='#ffff00', lw=2) # fit normal distribution to histogram x = np.zeros(len(bins)) for j in range(1, len(bins)): x[j] = (bins[j] + bins[j - 1]) / 2 pinit = np.array([float(i), freq[-1], deltaf]) n = np.array(n, dtype='float32') coeffs, errors, covar, sigma, chi2, dof, fit, plotx, ploty = \ kepfit.leastsquares(kepfunc.gauss, pinit, x[1:], n, None, logfile, verbose) f = np.arange(fmin, fmax, (fmax - fmin) / 100) fit = kepfunc.gauss(coeffs, f) plt.plot(f, fit, 'r-', linewidth=2) plt.xlabel(r'Frequency (1/d)', {'color': 'k'}) plt.ylabel('N', {'color': 'k'}) plt.xlim(fmin, fmax) plt.grid() # render plot if plot: plt.show() # period results p = 1.0 / coeffs[1] perr = p * coeffs[2] / coeffs[1] f1 = fmin f2 = fmax gotbin = False for i in range(len(n)): if n[i] > 0 and not gotbin: f1 = bins[i] gotbin = True gotbin = False for i in range(len(n) - 1, 0, -1): if n[i] > 0 and not gotbin: f2 = bins[i + 1] gotbin = True powave, powstdev = np.mean(pmax), np.std(pmax) # print result print(' best period: %.10f days (%.7f min)' % (p, p * 1440.0)) print(' 1-sigma period error: %.10f days (%.7f min)' % (perr, perr * 1440.0)) print(' search range: %.10f - %.10f days ' % (1.0 / fmax, 1.0 / fmin)) print(' 100%% confidence range: %.10f - %.10f days ' % (1.0 / f2, 1.0 / f1)) print(' number of trials: %d' % ntrials) print(' number of frequency bins: %d' % nfreq) # history keyword in output file kepkey.history(call, instr[0], outfile, logfile, verbose) ## write output file col1 = pyfits.Column(name='TRIAL', format='J', array=trial) col2 = pyfits.Column(name='FREQUENCY', format='E', unit='1/day', array=freq) col3 = pyfits.Column(name='POWER', format='E', array=pmax) cols = pyfits.ColDefs([col1, col2, col3]) instr.append(pyfits.BinTableHDU.from_columns(cols)) try: instr[-1].header['EXTNAME'] = ('TRIALS', 'Extension name') except: raise KeyError("Could not write EXTNAME to the header of the output" " file") try: instr[-1].header['SEARCHR1'] = (1.0 / fmax, 'Search range lower bound (days)') except: raise KeyError("Could not write SEARCHR1 to the header of the output" " file") try: instr[-1].header['SEARCHR2'] = (1.0 / fmin, 'Search range upper bound (days)') except: raise KeyError("Could not write SEARCHR2 to the header of the output" " file") try: instr[-1].header['NFREQ'] = (nfreq, 'Number of frequency bins') except: raise KeyError("Could not write NFREQ to the header of the output" " file") try: instr[-1].header['PERIOD'] = (p, 'Best period (days)') except: raise KeyError("Could not write PERIOD to the header of the output" " file") try: instr[-1].header['PERIODE'] = (perr, '1-sigma period error (days)') except: raise KeyError("Could not write PERIODE to the header of the output" " file") try: instr[-1].header['CONFIDR1'] = (1.0 / f2, 'Trial confidence lower bound (days)') except: raise KeyError("Could not write CONFIDR1 to the header of the output" " file") try: instr[-1].header['CONFIDR2'] = (1.0 / f1, 'Trial confidence upper bound (days)') except: raise KeyError("Could not write CONFIDR2 to the header of the output" " file") try: instr[-1].header['NTRIALS'] = (ntrials, 'Number of trials') except: raise KeyError("Could not write NTRIALS to the header of the output" " file") instr.writeto(outfile) # close input file instr.close() ## end time kepmsg.clock('KEPTRAIL completed at', logfile, verbose)
plt.ylabel('r^2 xi(r)') plt.grid(True, which='both') plt.savefig(save_location+'xir2_v2_{}_{}_{}.pdf'.format(pixels[0],pixels[-1],basedir[-7:-2])) plt.figure() plt.errorbar(R_binned,xi*(R_binned**2),yerr=err*(R_binned**2),fmt='o') #plt.plot(R_binned,(mean*R_binned**2)) plt.xlabel('r [Mpc/h]') plt.ylabel('r^2 xi(r)') plt.grid(True, which='both') plt.savefig(save_location+'xir2_v2_{}_{}_errors_{}.pdf'.format(pixels[0],pixels[-1],basedir[-7:-2])) file_data_list = [] for result in results: file_data_list += [(result[0],result[1],result[2],result[3])] dtype = [('bin_n', '>f4'), ('N_contributions_chunk', '>f4'), ('xi_chunk', '>f4'), ('del_squared_chunk', '>f4')] file_data = np.array(file_data_list,dtype=dtype) prihdr = fits.Header() prihdu = fits.PrimaryHDU(header=prihdr) cols_xi = fits.ColDefs(file_data) hdu_xi = fits.BinTableHDU.from_columns(cols_xi,name='XI DATA') hdulist = fits.HDUList([prihdu, hdu_xi]) hdulist.writeto(save_location+'xi_data_v2_{}_{}_{}.fits'.format(pixels[0],pixels[-1],basedir[-7:-2])) hdulist.close print('files saved to {}!'.format(save_location)) #plt.show()
array=hdulist[1].data.field('ra_error')*mas_to_deg), pyfits.Column(name='dec_error', format='D', unqit='Angle[deg]', array=hdulist[1].data.field('dec_error')*mas_to_deg), pyfits.Column(name='phot_g_mean_mag', format='D', unit='Magnitude[mag]', array=hdulist[1].data.field('phot_g_mean_mag')), pyfits.Column(name='phot_g_mean_mag_error', format='D', unit='Magnitude[mag]', array=mag_error), ] # for col in col_names: # for tbcol in hdulist[1].columns: # if (tbcol.name == col): # columns.append(pyfits.Column(name=col, # format=tbcol.format, # disp=tbcol.disp, # unit=tbcol.unit, # array=hdulist[1].data.field(col))) # # columns.append(pyfits.Column( # name='phot_g_mean_mag_error', array=mag_error, unit='Magnitude[mag]', format='D')) coldefs = pyfits.ColDefs(columns) tbhdu = pyfits.BinTableHDU.from_columns(coldefs) tbhdu.name = 'GAIA_CAT' # assemble the output FITS file # copy primary extension out_list = [hdulist[0], tbhdu] out_hdulist = pyfits.HDUList(out_list) out_hdulist.writeto(out_fn, overwrite=True)
intens_sum = intens_photo + intens_out ratio = intens_photo / intens_sum #ratio = 1 ### wlen_expand = wlen * 1e-6 niu = const.c / wlen_expand ncflux = recal(intens_sum, cflux, niu, ctemp) comb_photo = ncflux * ratio / factor_photo comb_out = ncflux * (1 - ratio) / factor_out comb = comb_photo + comb_out comb = comb * np.e**(-obs_tau / loca) comb = comb + gggflux #comb = comb_photo + ngflux ### fspec = np.concatenate((fspec, comb)) print i fspec = fspec[1:] col1 = fits.Column(name='GRAMS', format='I', array=gram) col2 = fits.Column(name='C2H2', format='I', array=c2h2) col4 = fits.Column(name='Fspec', format='365E', array=fspec) cols = fits.ColDefs([col1, col2, col4]) tbhdu = fits.BinTableHDU.from_columns(cols) tbhdu.writeto('/arrays/igloo1/ssp201701/fits/2012/9100.fits') print('end')
def calc(inputDataDict, outfile, indir="simha/", lib="miles"): from scipy.stats import chi2 import CosmologicalDistance import os import logging logging.debug('Starting smass.calc()') cd = CosmologicalDistance.CosmologicalDistance() ldistDict = dict() splineDict = dict() splines, zmet = loadPopColors.doAll(indir, lib=lib) id = inputDataDict["id"] haloid = inputDataDict["haloid"] i = inputDataDict["i"] ierr = inputDataDict["ierr"] gr = inputDataDict["gr"] ri = inputDataDict["ri"] iz = inputDataDict["iz"] grerr = inputDataDict["grerr"] rierr = inputDataDict["rierr"] izerr = inputDataDict["izerr"] allzed = inputDataDict["zed"] GR_P_COLOR = inputDataDict["GR_P_COLOR"] RI_P_COLOR = inputDataDict["RI_P_COLOR"] IZ_P_COLOR = inputDataDict["IZ_P_COLOR"] P_RADIAL = inputDataDict["P_RADIAL"] P_REDSHIFT = inputDataDict["P_REDSHIFT"] P_MEMBER = inputDataDict["P_MEMBER"] DIST_TO_CENTER = inputDataDict["DIST_TO_CENTER"] GRP_RED = inputDataDict["GRP_RED"] GRP_BLUE = inputDataDict["GRP_BLUE"] RIP_RED = inputDataDict["RIP_RED"] RIP_BLUE = inputDataDict["RIP_BLUE"] IZP_RED = inputDataDict["IZP_RED"] IZP_BLUE = inputDataDict["IZP_BLUE"] #print zmet # protect against too small of errors => values = 0 ix = np.nonzero(grerr < 0.02) grerr[ix] = 0.02 ix = np.nonzero(rierr < 0.02) rierr[ix] = 0.02 ix = np.nonzero(izerr < 0.02) izerr[ix] = 0.02 # prepping for output out_id,out_haloid, out_gr, out_stdgr, out_gi, out_stdgi, \ out_kri, out_stdkri, out_kii, out_stdkii, out_iobs, out_distmod, \ out_bestzmet,out_stdzmet, out_rabs, out_iabs, out_mass_gr, out_mass_gi, out_mass, out_stdmass, out_sfr, out_stdsfr, out_age, out_stdage, \ out_GR_P_COLOR,out_RI_P_COLOR,out_IZ_P_COLOR,out_P_RADIAL,out_P_REDSHIFT,out_P_MEMBER,out_DIST_TO_CENTER, \ out_GRP_RED,out_GRP_BLUE,out_RIP_RED,out_RIP_BLUE,out_IZP_RED,out_IZP_BLUE,out_zmet, out_zed =\ [],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[] out_bestsp, out_bestchisq = [], [] size = id.size #size = 10 for galaxy in range(0, size): zed = allzed[galaxy] logging.debug('{i} of {len}, z = {z}'.format(i=galaxy + 1, len=size, z=zed)) rest_gr, rest_gi, weight, chisqs = [], [], [], [] masslight, sfrs, ages, zmets, kii, kri = [], [], [], [], [], [] minChiSq = 999 spIndex = -1 for sp in range(0, len(splines)): # for speed skey = str(sp) + "-" + str(zed) #if skey in splineDict : # sgr,sri,siz,sgrr,sgir,skii,skri,sml = splineDict[skey] #else : # sgr = splines[sp][0](zed) # sri = splines[sp][1](zed) # siz = splines[sp][2](zed) # sgrr = splines[sp][4](zed) ;# restframe g-r # sgir = splines[sp][5](zed) ;# restframe g-i # skii = splines[sp][6](zed) ;# kcorrection: i_o - i_obs # skri = splines[sp][7](zed) ;# kcorrection: r_o - i_obs # sml = splines[sp][8](zed) ;# log(mass/light) (M_sun/L_sun) # ssfr = splines[sp][9](zed) # sage_cosmic = splines[sp][10](zed) # sage = splines[sp][11](zed) # zmet = splines[12] sgr = splines[sp][0](zed) sri = splines[sp][1](zed) siz = splines[sp][2](zed) sgrr = splines[sp][4](zed) # restframe g-r sgir = splines[sp][5](zed) # restframe g-i skii = splines[sp][6](zed) # kcorrection: i_o - i_obs skri = splines[sp][7](zed) # kcorrection: r_o - i_obs sml = splines[sp][8](zed) # log(mass/light) (M_sun/L_sun) ssfr = splines[sp][9](zed) if (ssfr < -20.): ssfr = -20. sage_cosmic = splines[sp][10](zed) sage = splines[sp][11](zed) szmet = zmet[sp] #To be changed if SFH changes #splineDict[skey] = sgr,sri,siz,sgrr,sgir,skii,skri,sml gre = grerr[galaxy] rie = rierr[galaxy] ize = izerr[galaxy] gr_chisq = pow((gr[galaxy] - sgr) / gre, 2) ri_chisq = pow((ri[galaxy] - sri) / rie, 2) iz_chisq = pow((iz[galaxy] - siz) / ize, 2) rest_gr.append(sgrr) rest_gi.append(sgir) kii.append(skii) kri.append(skri) masslight.append(sml) sfrs.append(ssfr) ages.append(sage) zmets.append(szmet) chisq = gr_chisq + ri_chisq + iz_chisq probability = 1 - chi2.cdf(chisq, 3 - 1) # probability of chisq greater than this weight.append(probability) chisqs.append(chisq) spIndex = np.argmax(weight) rest_gr = np.array(rest_gr) rest_gi = np.array(rest_gi) kii = np.array(kii) kri = np.array(kri) masslight = np.array(masslight) sfrs = np.array(sfrs) idx_sfr = (sfrs < -8.) ages = np.array(ages) weight = np.array(weight) gr_weighted = rest_gr * weight gi_weighted = rest_gi * weight kii_weighted = kii * weight kri_weighted = kri * weight #weight_norm = weight/np.sum(weight) masslight_weighted = masslight * weight sfr_weighted = 10**sfrs[idx_sfr] * weight[idx_sfr] age_weighted = ages * weight zmet_weighted = zmets * weight w1 = weight.sum() w2 = (weight**2).sum() if w1 == 0: w1 = 1e-10 if w2 == 0: w2 = 1e-10 mean_gr = gr_weighted.sum() / w1 mean_gi = gi_weighted.sum() / w1 mean_kii = kii_weighted.sum() / w1 mean_kri = kri_weighted.sum() / w1 mean_masslight = masslight_weighted.sum() / w1 #try : # if weight.shape[0]>1.: # mean_sfr = float(ws.numpy_weighted_median(sfrs, weights=weight)) #np.median(sfr_weighted) #sfr_weighted.sum()/w1 # else: # mean_sfr = -70. #except : # mean_sfr = -70. #print mean_sfr mean_age = age_weighted.sum() / w1 mean_zmet = zmet_weighted.sum() / w1 mean_sfr = sfr_weighted.sum() / w1 # unbiased weighted estimator of the sample variance w3 = w1**2 - w2 if w3 == 0: w3 = 1e-10 var_gr = (w1 / w3) * (weight * (rest_gr - mean_gr)**2).sum() var_gi = (w1 / w3) * (weight * (rest_gi - mean_gi)**2).sum() var_kii = (w1 / w3) * (weight * (kii - mean_kii)**2).sum() var_kri = (w1 / w3) * (weight * (kri - mean_kii)**2).sum() var_masslight = (w1 / w3) * (weight * (masslight - mean_masslight)**2).sum() var_sfr = (w1 / w3) * (weight * (sfrs - mean_sfr)**2).sum() var_age = (w1 / w3) * (weight * (ages - mean_age)**2).sum() var_zmet = (w1 / w3) * (weight * (zmets - mean_zmet)**2).sum() std_gr = var_gr**0.5 std_gi = var_gi**0.5 std_kii = var_kii**0.5 std_kri = var_kri**0.5 std_masslight = var_masslight**0.5 std_sfr = var_sfr**0.5 std_age = var_age**0.5 std_zmet = var_zmet**0.5 if std_gr > 99.99: std_gr = 99.99 if std_gi > 99.99: std_gi = 99.99 if std_kii > 99.99: std_kii = 99.99 if std_kri > 99.99: std_kri = 99.99 if std_sfr > 99.99: std_sfr = 99.99 if std_age > 99.99: std_age = 99.99 if std_masslight > 99.99: std_masslight = 99.99 if std_zmet > 99.99: std_zmet = 99.99 # Comment -distanceModulus out for fsps versions <2.5, as their mags don't include distance modulus if zed in ldistDict: lumdist = ldistDict[zed] else: lumdist = cd.luminosity_distance(zed) # in Mpc ldistDict[zed] = lumdist distanceModulus = 5 * np.log10(lumdist * 1e6 / 10.) iabs = i[galaxy] + mean_kii - distanceModulus rabs = i[galaxy] + mean_kri - distanceModulus taMass = taylorMass(mean_gi, iabs) mcMass = mcintoshMass(mean_gr, rabs) fsMass = fspsMass(mean_masslight, iabs) # JTA: to make purely distance modulus #iabs = i[galaxy] - distanceModulus #fsMass = gstarMass( iabs ) # saving for output out_id.append(id[galaxy]) out_haloid.append(haloid[galaxy]) out_gr.append(mean_gr) out_stdgr.append(std_gr) out_gi.append(mean_gi) out_stdgi.append(std_gi) out_kii.append(mean_kii) out_stdkii.append(std_kii) out_kri.append(mean_kri) out_stdkri.append(std_kri) out_iobs.append(i[galaxy]) out_distmod.append(distanceModulus) out_iabs.append(iabs) out_rabs.append(rabs) out_mass_gr.append(mcMass) out_mass_gi.append(taMass) out_mass.append(fsMass) out_stdmass.append(std_masslight) out_bestsp.append(spIndex) out_bestzmet.append(zmets[spIndex]) out_bestchisq.append(chisqs[spIndex]) out_sfr.append(mean_sfr) out_stdsfr.append(std_sfr) out_age.append(mean_age) out_stdage.append(std_age) out_zmet.append(mean_zmet) out_stdzmet.append(std_zmet) out_zed.append(allzed[galaxy]) out_GR_P_COLOR.append(GR_P_COLOR[galaxy]) out_RI_P_COLOR.append(RI_P_COLOR[galaxy]) out_IZ_P_COLOR.append(IZ_P_COLOR[galaxy]) out_P_RADIAL.append(P_RADIAL[galaxy]) out_P_REDSHIFT.append(P_REDSHIFT[galaxy]) out_P_MEMBER.append(P_MEMBER[galaxy]) out_DIST_TO_CENTER.append(DIST_TO_CENTER[galaxy]) out_GRP_RED.append(GRP_RED[galaxy]) out_GRP_BLUE.append(GRP_BLUE[galaxy]) out_RIP_RED.append(RIP_RED[galaxy]) out_RIP_BLUE.append(RIP_BLUE[galaxy]) out_IZP_RED.append(IZP_RED[galaxy]) out_IZP_BLUE.append(IZP_BLUE[galaxy]) out_id = np.array(out_id).astype(int) out_haloid = np.array(out_haloid).astype(int) out_gr = np.array(out_gr) out_stdgr = np.array(out_stdgr) out_gi = np.array(out_gi) out_stdgi = np.array(out_stdgi) out_kii = np.array(out_kii) out_stdkii = np.array(out_stdkii) out_kri = np.array(out_kri) out_stdkri = np.array(out_stdkri) out_iobs = np.array(out_iobs) out_distmod = np.array(out_distmod) out_iabs = np.array(out_iabs) out_rabs = np.array(out_rabs) out_mass_gr = np.array(out_mass_gr) out_mass_gi = np.array(out_mass_gi) out_mass = np.array(out_mass) out_stdmass = np.array(out_stdmass) out_sfr = np.array(out_sfr) out_stdsfr = np.array(out_stdsfr) out_age = np.array(out_age) out_stdage = np.array(out_stdage) out_bestsp = np.array(out_bestsp) out_GR_P_COLOR = np.array(out_GR_P_COLOR) out_RI_P_COLOR = np.array(out_RI_P_COLOR) out_IZ_P_COLOR = np.array(out_IZ_P_COLOR) out_P_RADIAL = np.array(out_P_RADIAL) out_P_REDSHIFT = np.array(out_P_REDSHIFT) out_P_MEMBER = np.array(out_P_MEMBER) out_DIST_TO_CENTER = np.array(out_DIST_TO_CENTER) out_GRP_RED = np.array(out_GRP_RED) out_GRP_BLUE = np.array(out_GRP_BLUE) out_RIP_RED = np.array(out_RIP_RED) out_RIP_BLUE = np.array(out_RIP_BLUE) out_IZP_RED = np.array(out_IZP_RED) out_IZP_BLUE = np.array(out_IZP_BLUE) out_zmet = np.array(out_zmet) out_bestzmet = np.array(out_bestzmet) out_zed = np.array(out_zed) out_bestchisq = np.array(out_bestchisq) col1 = pf.Column(name='MEM_MATCH_ID', format='J', array=out_haloid) col2 = pf.Column(name='Z', format='E', array=out_zed) col3 = pf.Column(name='ID', format='K', array=out_id) col4 = pf.Column(name='gr_o', format='E', array=out_gr) col5 = pf.Column(name='gr_o_err', format='E', array=out_stdgr) col6 = pf.Column(name='gi_o', format='E', array=out_gi) col7 = pf.Column(name='gi_o_err', format='E', array=out_stdgi) col8 = pf.Column(name='kri', format='E', array=out_kri) col9 = pf.Column(name='kri_err', format='E', array=out_stdkri) col10 = pf.Column(name='kii', format='E', array=out_kii) col11 = pf.Column(name='kii_err', format='E', array=out_stdkii) col12 = pf.Column(name='iobs', format='E', array=out_iobs) col13 = pf.Column(name='distmod', format='E', array=out_distmod) col14 = pf.Column(name='rabs', format='E', array=out_rabs) col15 = pf.Column(name='iabs', format='E', array=out_iabs) col16 = pf.Column(name='mcMass', format='E', array=out_mass_gr) col17 = pf.Column(name='taMass', format='E', array=out_mass_gi) col18 = pf.Column(name='mass', format='E', array=out_mass) col19 = pf.Column(name='mass_err', format='E', array=out_stdmass) col20 = pf.Column(name='ssfr', format='E', array=out_sfr) col21 = pf.Column(name='ssfr_std', format='E', array=out_stdsfr) col22 = pf.Column(name='mass_weight_age', format='E', array=out_age) col23 = pf.Column(name='mass_weight_age_err', format='E', array=out_stdage) col24 = pf.Column(name='best_model', format='E', array=out_bestsp) col25 = pf.Column(name='best_zmet', format='E', array=out_bestzmet) col26 = pf.Column(name='zmet', format='E', array=out_zmet) col27 = pf.Column(name='best_chisq', format='E', array=out_bestchisq) col28 = pf.Column(name='GR_P_COLOR', format='E', array=out_GR_P_COLOR) col29 = pf.Column(name='RI_P_COLOR', format='E', array=out_RI_P_COLOR) col30 = pf.Column(name='IZ_P_COLOR', format='E', array=out_IZ_P_COLOR) col31 = pf.Column(name='P_RADIAL', format='E', array=out_P_RADIAL) col32 = pf.Column(name='P_REDSHIFT', format='E', array=out_P_REDSHIFT) col33 = pf.Column(name='P_MEMBER', format='E', array=out_P_MEMBER) col34 = pf.Column(name='DIST_TO_CENTER', format='E', array=out_DIST_TO_CENTER) col35 = pf.Column(name='GRP_RED', format='E', array=out_GRP_RED) col36 = pf.Column(name='GRP_BLUE', format='E', array=out_GRP_BLUE) col37 = pf.Column(name='RIP_RED', format='E', array=out_RIP_RED) col38 = pf.Column(name='RIP_BLUE', format='E', array=out_RIP_BLUE) col39 = pf.Column(name='IZP_RED', format='E', array=out_IZP_RED) col40 = pf.Column(name='IZP_BLUE', format='E', array=out_IZP_BLUE) cols = pf.ColDefs([ col1, col2, col3, col4, col5, col6, col7, col8, col9, col10, col11, col12, col13, col14, col15, col16, col17, col18, col19, col20, col21, col22, col23, col24, col25, col26, col27, col28, col29, col30, col31, col32, col33, col34, col35, col36, col37, col38, col39, col40 ]) tbhdu = pf.BinTableHDU.from_columns(cols) tbhdu.writeto(outfile, clobber=True) data = np.array([out_id, out_haloid, out_gr, out_stdgr, out_gi, out_stdgi, \ out_kri, out_stdkri, out_kii, out_stdkii, out_iobs, out_distmod, \ out_rabs, out_iabs, out_mass_gr, out_mass_gi, out_mass, out_stdmass, \ out_zed,out_sfr, out_stdsfr, out_age, out_stdage, out_bestsp,out_bestzmet,out_zmet,out_GR_P_COLOR,out_RI_P_COLOR,out_IZ_P_COLOR,out_P_RADIAL,out_P_REDSHIFT,out_P_MEMBER,out_DIST_TO_CENTER, \ out_GRP_RED,out_GRP_BLUE,out_RIP_RED,out_RIP_BLUE,out_IZP_RED,out_IZP_BLUE]) #header = "# id, haloid, gr_o, std, gi_o, std, kri, std, kii, std, i, distmod, " #header = header + "r_abs, i_abs, mcMass, taMass, mass, std, zed, sfr, sfrstd, age, agestd, bestsp,best_zmet,mean_zmet \ # out_GR_P_COLOR,out_RI_P_COLOR,out_IZ_P_COLOR,out_GR_P_MEMBER,out_RI_P_MEMBER,out_IZ_P_MEMBER,out_DIST_TO_CENTER, \ # out_GRP_RED,out_GRP_BLUE,out_RIP_RED,out_RIP_BLUE,out_IZP_RED,out_IZP_BLUE\n" #fd = open(outfile,"w") #fd.write(header) #fd.close() #np.savetxt(outfile+".dat", data.T, "%d,%d,%6.3f,%6.4f,%6.3f,%6.4f,%6.3f,%6.4f,%6.3f,%6.4f,\ # %6.3f,%6.3f,%6.3f,%6.3f,%6.3f,%6.3f,%6.3f,%6.3f,%6.3f,%6.4f,%6.3f,%6.3f,%6.3f,%d,%6.3f, %6.3f,%6.3f,%6.3f,%6.3f,%6.3f,%6.3f,%6.3f,%6.4f,%6.3f,%6.3f,%6.3f,%6.3f,%6.3f, %6.3f") #os.system("cat {} >> {}; rm {}".format(outfile+".dat", outfile, outfile+".dat")) logging.debug('Returning from smass.calc()')
def tsys_writeudbfits(xdat, calflag): ''' This takes the dictionary xdat of rd_miriad_tsys_file and creates a UDB FITS file. Unlike the original UDB fits files this puts the tsys data as the primary output because I cannot figure out how to get a multidimensional array into a column...''' file_out = '' if xdat == None or len(xdat) == 0: print 'tsys_writeudbfits: No data input' return file_out # end #UDB fits files udbfitsdir = '/data1/eovsa/fits/' #create a filename file0 = xdat['file0'].split("/") lf0 = len(file0) file0 = file0[lf0 - 1] print file0 yr = file0[3:7] yr2 = file0[5:7] mn = file0[7:9] dy = file0[9:11] hh = file0[11:13] mm = file0[13:15] ss = file0[15:] file_out = 'eovsa_1-18GHz_sp_' + yr + mn + dy + '_' + hh + mm + ss + '.fts' #add directory outdir = udbfitsdir + yr + mn + dy if os.path.isdir(outdir) == False: print "tsys_writeudbfits: creating " + outdir os.mkdir(outdir) #end if file_out = outdir + '/' + file_out date_obs = yr + '-' + mn + '-' + dy + 'T' + hh + ':' + mm + ':' + ss + '.000' #Convert to unix time, and add seconds to get date_end #http://astropy.readthedocs.org/en/latest/time ut = xdat['ut_mjd'] print "date_obs: ", date_obs t0 = Time(date_obs) dt = int(86400 * (max(ut) - min(ut))) t1 = Time(t0.unix + dt, format='unix') date_end = t1.isot # Create the primary header version = xdat['version'] if version == "1.0": tpwr = xdat['tsys'] else: tpwr = xdat['tpwr'] #endif hdu = fits.PrimaryHDU(tpwr) # Set up the extensions: sfreq, sdf, ut sfreq = xdat['sfreq'] col1 = fits.Column(name='sfreq', format='E', array=sfreq) cols1 = fits.ColDefs([col1]) tbhdu1 = fits.BinTableHDU.from_columns(cols1) # tbhdu1.update_ext_name('SFREQ') tbhdu1.name = 'SFREQ' sdf = xdat['sdf'] col2 = fits.Column(name='sdf', format='E', array=sdf) cols2 = fits.ColDefs([col2]) tbhdu2 = fits.BinTableHDU.from_columns(cols2) tbhdu2.name = 'SDF' # ut = xdat['ut'] # Split up mjd into days and msec, really intuitive syntax, thanks python ut_int = ut.astype(np.int32) ut_msec = 1000.0 * 86400.0 * (ut - ut_int) ut_ms1 = ut_msec.astype(np.int32) # J is the format code for a 32 bit integer, who would have thought # http://astropy.readthedocs.org/en/latest/io/fits/usage/table.html col3 = fits.Column(name='mjd', format='J', array=ut_int) col4 = fits.Column(name='time', format='J', array=ut_ms1) cols3 = fits.ColDefs([col3, col4]) tbhdu3 = fits.BinTableHDU.from_columns(cols3) tbhdu3.name = 'UT' #create an HDUList object to put in header information hdulist = fits.HDUList([hdu, tbhdu1, tbhdu2, tbhdu3]) #primary header prihdr = hdulist[0].header #Header information, strip last character from strings obj_id = xdat['source'] obj_id = obj_id[:len(obj_id) - 1] scan_id = xdat['scanid'] scan_id = scan_id[:len(scan_id) - 1] proj_id = xdat['proj'] proj_id = proj_id[:len(proj_id) - 1] proj_id = strip_non_printable(proj_id) ant_list = xdat['antennalist'] ant_list = ant_list[:len(ant_list) - 1] temp_out = file_out.split("/") temp_out = temp_out[len(temp_out) - 1] prihdr.set('FILENAME', temp_out) prihdr.set('ORIGIN', 'NJIT', 'Institute where file was written') prihdr.set('TELESCOP', 'EOVSA', 'Expanded Owens Valley Solar Array') prihdr.set('OBJ_ID', obj_id, 'Object ID') prihdr.set('SCAN_ID', scan_id, 'Scan ID for this dataset') prihdr.set('PROJECT_', proj_id, 'EOVSA Project ID') prihdr.set('ID', int(yr2 + mn + dy + hh + mm + ss), 'Catalog ID, yymmddhhmm') prihdr.set('TYPE', 1, 'Spectrum') prihdr.set('DATE_OBS', date_obs, 'Start date/time of observation') prihdr.set('DATE_END', date_end, 'End date/time of observation') prihdr.set('FREQMIN', min(sfreq), 'Min freq in observation (GHz)') prihdr.set('FREQMAX', max(sfreq), 'Max freq in observation (GHz)') prihdr.set('XCEN', 0.0, 'Antenna pointing in arcsec from Sun centre') prihdr.set('YCEN', 0.0, 'Antenna pointing in arcsec from Sun centre') prihdr.set('POLARIZA', 'XX, YY', 'Polarizations present') prihdr.set('RESOLUTI', 0.0, 'Resolution value') prihdr.set('NANTS', xdat['nants'], 'Number of Antennae') prihdr.set('ANTENNA', ant_list, 'Used antennae') prihdr.set('VERSION', version, 'SW version') if (calflag == True): prihdr.set('CAL_FLAG', 1, 'Calibration Flag: 1 for calibrated, 0 for not') else: prihdr.set('CAL_FLAG', 0, 'Calibration Flag: 1 for calibrated, 0 for not') #endif # Write the file hdulist.writeto(file_out, clobber=True) return file_out
def daily_xsp_writefits(xdat, pdata): '''This takes the dictionary output from a read_idb, and pdata from daily_xsp, and creates a FITS file. The data is the primary output. ''' file_out = '' if xdat == None or len(xdat) == 0: print 'xsp_writefits: No data input' return file_out # end #UDB allday fits files xspfitsdir = '/data1/eovsa/fits/XSP/' if os.path.isdir(xspfitsdir) == False: print "daily_xsp_writefits: creating " + xspfitsdir os.mkdir(xspfitsdir) #end if #create a filename, just use the start time t = xdat['time'] print t[0] t0 = Time(t[0], format='jd' ) #The format is to tell the Time object about the input time t01 = t0.isot yr = t01[0:4] mn = t01[5:7] dy = t01[8:10] file_out = 'XSP' + yr + mn + dy + '.fts' #add directory outdir = xspfitsdir + '/' + yr + '/' if os.path.isdir(outdir) == False: print "daily_xsp_writefits: creating " + outdir os.mkdir(outdir) #end if file_out = outdir + '/' + file_out date_obs = t01 #Convert to unix time, and add seconds to get date_end #http://astropy.readthedocs.org/en/latest/time print "date_obs: ", date_obs t0 = Time(date_obs) dt = int(86400 * (max(t) - min(t))) t1 = Time(t0.unix + dt, format='unix') date_end = t1.isot print "date_end: ", date_end # Create the primary header tpwr = pdata hdu = fits.PrimaryHDU(tpwr) # Set up the extensions: sfreq, ut sfreq = xdat['fghz'] col1 = fits.Column(name='sfreq', format='E', array=sfreq) cols1 = fits.ColDefs([col1]) tbhdu1 = fits.BinTableHDU.from_columns(cols1) tbhdu1.name = 'SFREQ' # Split up mjd into days and msec, really intuitive syntax, thanks python ut = Time(t, format='jd') #Format is for the input time ut = ut.mjd ut_int = ut.astype(np.int32) ut_msec = 1000.0 * 86400.0 * (ut - ut_int) ut_ms1 = ut_msec.astype(np.int32) # J is the format code for a 32 bit integer, who would have thought # http://astropy.readthedocs.org/en/latest/io/fits/usage/table.html col3 = fits.Column(name='mjd', format='J', array=ut_int) col4 = fits.Column(name='time', format='J', array=ut_ms1) cols3 = fits.ColDefs([col3, col4]) tbhdu3 = fits.BinTableHDU.from_columns(cols3) tbhdu3.name = 'UT' #create an HDUList object to put in header information hdulist = fits.HDUList([hdu, tbhdu1, tbhdu3]) #primary header prihdr = hdulist[0].header #Header information, strip last character from strings obj_id = strip_non_printable(xdat['source']) temp_out = file_out.split("/") temp_out = temp_out[len(temp_out) - 1] prihdr.set('FILENAME', temp_out) prihdr.set('ORIGIN', 'NJIT', 'Institute where file was written') prihdr.set('TELESCOP', 'EOVSA', 'Expanded Owens Valley Solar Array') prihdr.set('OBJ_ID', obj_id, 'Object ID') prihdr.set('TYPE', 1, 'Spectrum') prihdr.set('DATE_OBS', date_obs, 'Start date/time of observation') prihdr.set('DATE_END', date_end, 'End date/time of observation') prihdr.set('FREQMIN', min(sfreq), 'Min freq in observation (GHz)') prihdr.set('FREQMAX', max(sfreq), 'Max freq in observation (GHz)') prihdr.set('XCEN', 0.0, 'Antenna pointing in arcsec from Sun centre') prihdr.set('YCEN', 0.0, 'Antenna pointing in arcsec from Sun centre') prihdr.set('POLARIZA', 'XX, YY', 'Polarizations present') prihdr.set('RESOLUTI', 0.0, 'Resolution value') # Write the file hdulist.writeto(file_out, clobber=True) return file_out