def new_binning(xmin, xmax, nbin=25, bin_type='lin', out_type=int, custom_bins=None): """ Define the new binning. Parameters ---------- Returns ------- array the array with the edges of the new binning """ if bin_type == 'lin' and custom_bins is None: binning_ = np.linspace(xmin, xmax, num=nbin + 1, dtype=out_type) elif bin_type == 'log' and custom_bins is None: if xmin == 0: xmin = 1 binning_ = np.logspace(np.log10(xmin), np.log10(xmax), num=nbin + 1, dtype=out_type) elif type(custom_bins) == list or type(custom_bins) == np.ndarray: binning_ = np.array(custom_bins) else: logger.info( 'ERROR: Invalid binning type. Choose lin or log, or customize it.') sys.exit() logger.info('Multipole binning:%s' % str(binning_)) return binning_
def gtEbindef(ebinning_array, file_name='ebinning.txt'): """ Produces a fits file defining the enrgy binning to fed gtbin. Parameters ---------- ebinning_array: numpy array array in which the energy binnin is defined. file_name : str file name for the output txt file. (Default = 'ebinning.txt') Returns ------- str file name of the fits file created """ if not os.path.exists(X_OUT): os.makedirs(X_OUT) txt_file_name = os.path.join(X_OUT, file_name) txt_file = open(txt_file_name, 'w') fits_file_name = os.path.join(X_OUT, file_name.replace('.txt', '.fits')) for emin, emax in zip(ebinning_array[:-1], ebinning_array[1:]): txt_file.write('%.4f %.4f\n' % (emin, emax)) txt_file.close() os.system('gtbindef bintype=E binfile=%s outfile=%s energyunits=MeV' \ %(txt_file_name, fits_file_name)) logger.info('Created %s...' % fits_file_name) return fits_file_name
def flux_view(**kwargs): """ Viewer interface for flux spectrum """ params = parse_datafluxmaps(kwargs['infile']) _emin, _emax, _emean = params[0], params[1], params[2] if len(params[-1]) == 0: _f, _ferr = params[3], params[4] else: _n, _nsx, _ndx = params[-6], params[-5], params[-4] _f, _fsxerr, _fdxerr = params[-3], params[-2], params[-1] _ferr = [abs(_f - _fsxerr), abs(_f - _fdxerr)] logger.info('Plotting Energy Spectrum ...') fig, ax = plt.subplots(1) leg, lab = ref_igrb_band() spec = plt.errorbar(_emean, (_f) / (_emax - _emin) * _emean**2, fmt='o', color='red', markersize=3, elinewidth=2, xerr=[(_emean - _emin), (_emax - _emean)], yerr=_ferr / (_emax - _emin) * _emean**2) Aeff_sys = plt.fill_between(_emean, (_f - 0.1 * _f) / (_emax - _emin) * _emean**2, (_f + 0.1 * _f) / (_emax - _emin) * _emean**2, color='red', alpha=0.3) plt.xscale("log") plt.yscale("log") plt.xlabel('Energy [MeV]', size=14) plt.ylabel('E$^{2}$ $\cdot$ Flux [MeV cm$^{-2}$ s$^{-1}$ sr$^{-1}$]', size=14) plt.title(kwargs['title']) plt.legend([leg, spec, Aeff_sys], [lab, 'UGRB flux (Xgam)', 'A$_{eff}$ sys. band'], loc=3, fontsize=15) plt.tick_params(axis='both', which='major', labelsize=15) plt.ylim(1e-7, 4.e-2) plt.xlim(100, 1000000) if len(params[-1]) != 0: logger.info('Plotting Foreground best-fit Normalization ...') plt.figure() plt.title(kwargs['title']) plt.fill_between(_emean, _nsx, _ndx, color='lightcoral', alpha=0.5) plt.plot(_emean, _n, 'ro-') plt.xscale('log') plt.xlabel('Energy [MeV]', size=14) plt.ylabel('IEM Normalization', size=14) plt.show()
def find_outer_energies(en_val, en_arr): """ Gives the first element on the right and the first on the left of a given E value (en_val), among all values in an ordered array (en_arr). These values are used to integrate the foreground model in the considered energy bin. Parameters ---------- en_val : float mean energy en_arr : float array of the energies at which the foreground model is given. Returns ------- float, float first element on the right and the first on the left """ en_sx_arr = en_arr[en_arr < en_val] en_dx_arr = en_arr[en_arr > en_val] if en_sx_arr.size == 0: en_sx = en_dx_arr[0] en_dx = en_dx_arr[1] logger.info('Considering model in the interval %.1f-%.1f MeV' % (en_sx, en_dx)) elif en_dx_arr.size == 0: en_sx = en_sx_arr[-2] en_dx = en_sx_arr[-1] logger.info('Considering model in the interval %.1f-%.1f MeV' % (en_sx, en_dx)) else: en_sx = en_sx_arr[-1] en_dx = en_dx_arr[0] return en_sx, en_dx
def aps_compare(**kwargs): """ Viewer interface for APS and Covariance matrix """ logger.info('Generating comparison APS plots...') l_f, cl_f, clerr_f = [], [], [] for f in kwargs['infile']: params = parse_polspice_aps(f) _emin, _emax = params[0], params[1] _l, _cl, _clerr = params[2], params[3], params[4] _cov_ = params[5] l_f.append(_l) cl_f.append(_cl) clerr_f.append(_clerr) l_f = np.array(l_f) cl_f = np.array(cl_f) clerr_f = np.array(clerr_f) nfiles = l_f.shape[0] nebins = l_f.shape[1] lab = kwargs['labels'] if kwargs['labels'] is None: lab = [] for i in range(nfiles): lab.append('File %s' % i) for i in range(nebins): plt.figure() plt.hlines(0, 1, 1000, color='silver') plt.title('%s' % kwargs['title']) for j in range(nfiles): plt.errorbar(l_f[j][i], cl_f[j][i], fmt='o', markersize=5, elinewidth=2, yerr=clerr_f[j][i], label=lab[j]) plt.xscale(kwargs['xscale']) plt.xlabel('$\ell$', size=15) plt.ylabel('C$_{\ell}$', size=15) plt.legend() plt.show()
def gtselect(label, filter_dict): """ Calls gtselect from Science Tools. Parameters ---------- label: str To automatically set the name of the output file filter_dict: python dict To define all the parameters Returns ------- str the autogenerated output file name """ logger.info('Running gtselect...') LABEL = label OUTPATH = os.path.join(FT_DATA_OUT, 'output_gtselect') if not os.path.exists(OUTPATH): os.makedirs(OUTPATH) OUTFILE = os.path.join(OUTPATH, LABEL + '_outofselect.fits') if os.path.exists(OUTFILE): logger.info('ATT: Already created %s' % OUTFILE) else: for key in filter_dict: my_apps.filter[key] = filter_dict[key] my_apps.filter['outfile'] = OUTFILE my_apps.filter.run() logger.info('Created %s' % OUTFILE) logger.info('gtselect --> CPU time spent: %.2f' % time.clock()) return OUTFILE
def build_wbeam(psf, l_, out_file): """ Calculates the Wbeam(l, E) and return a bivariate slpine. Parameters ---------- psf : spline psf bivariate spline generated by get_psf l_ : array array of multipoles at wicht to compute the Wbeam out_file : str name of the output txt file that will be created in output/ Returns ------- spline spline of the beam window function """ out_txt = open(os.path.join(X_OUT, out_file), 'w') en_ = psf.x _wb_ = [] energy = str(list(en_)).replace('[','').replace(']','').replace(', ', ' ') out_txt.write('l\t%s\n'%energy) for e in en_: wb_e = np.array([]) psf_th = psf.vslice(e) for l in l_: pl_th = get_pl_vs_th(l, np.cos(psf_th.x)) fmt = dict(xname='th', xunits='rad', yname='convolution', \ yunits='MeV') _conv = xInterpolatedUnivariateSplineLinear(psf_th.x, \ np.sin(psf_th.x)*psf_th.y*pl_th, **fmt) wb_e_l = min(1., 2*np.pi*(_conv.integral(np.amin(psf_th.x), \ np.amax(psf_th.x)))) logger.info('Wbeam(%i, %.2f) = %e'%(l, e, wb_e_l)) wb_e = np.append(wb_e, [wb_e_l]) _wb_.append(wb_e) _wb_ = np.array(_wb_) fmt = dict(xname='$l$', xunits='', yname='Energy', yunits='MeV', zname='W$_{beam}$(E,$l$)') wbeam = xInterpolatedBivariateSplineLinear(l_, en_, _wb_.T, **fmt) for i, l in enumerate(l_): wb = str(list(_wb_.T[i])).replace('[','').replace(']','').\ replace(', ', ' ') out_txt.write('%i\t%s\n'%(l, wb)) out_txt.close() return _wb_
def parse_datafluxmaps(out_dataflux_map_file): """Parsing of *_parameters.txt files. cl_param_file : str This file is created by bin/mkdatarestyle.py app. """ logger.info('Loading parameters from %s' % out_dataflux_map_file) ff = open(out_dataflux_map_file, 'r') _emin, _emax, _emean = [], [], [] _f, _ferr, _cn, _fsky = [], [], [], [] _n, _n_sx, _n_dx, _c, _c_sx, _c_dx = [], [], [], [], [], [] for line in ff: try: emin, emax, emean, f, ferr, cn, fsky, n, nsx, ndx, c, csx, cdx = [float(item) for item in \ line.split()] _emin.append(emin) _emax.append(emax) _emean.append(emean) _f.append(f) _ferr.append(ferr) _cn.append(cn) _fsky.append(fsky) _n.append(n) _n_sx.append(nsx) _n_dx.append(ndx) _c.append(c) _c_sx.append(csx) _c_dx.append(cdx) except: try: emin, emax, emean, f, ferr, cn, fsky = [ float(item) for item in line.split() ] _emin.append(emin) _emax.append(emax) _emean.append(emean) _f.append(f) _ferr.append(ferr) _cn.append(cn) _fsky.append(fsky) except: pass ff.close() return [np.array(_emin), np.array(_emax), np.array(_emean), np.array(_f), \ np.array(_ferr), np.array(_cn), np.array(_fsky), np.array(_n),np.array(_n_sx),\ np.array(_n_dx), np.array(_c), np.array(_c_sx), np.array(_c_dx)]
def mergeft1(path_to_files, out_file_name, N1week, Nnweek): """ Creates a .txt file with the list of the FT files to merge. Parameters ---------- path_to_files: str path where datat files are stored out_file_name: str name of the txt output file (created in the same folder of data) N1week: int number of the starting week Nnweek: int number of the ending week Returns ------- str string to pass to gtselect function """ if N1week < 9: abort('Invalid number of weeks: the minimun must be > or = to 9') if Nnweek > 621: abort('Invalid number of weeks: the maximum must be < or = to 1000') outtxtfile = os.path.join(path_to_files, out_file_name) if not os.path.exists(outtxtfile): out_file = open(outtxtfile, 'w') for i in range(N1week, Nnweek + 1): if i == 9: out_file.write("%s/lat_photon_weekly_w00%i_p305_v001.fits \n" \ %(path_to_files,i)) if i >= 10 and i <= 99: out_file.write("%s/lat_photon_weekly_w0%i_p305_v001.fits \n" \ %(path_to_files,i)) if i > 99: if i == 512: pass else: out_file.write("%s/lat_photon_weekly_w%i_p305_v001.fits \n" \ %(path_to_files,i)) out_file.close() logger.info('Created %s...' % outtxtfile) return '@' + outtxtfile
def mask_galactic_src(cat_file, mask_rad, nside): """Returns the 'bad pixels' defined by the position of a galactic source and a certain radius away from that point. cat_file: str .fits file of the sorce catalog MASK_S_RAD: float radius around each source definig bad pixels to mask NSIDE: int healpix nside parameter """ logger.info('Mask for sources activated') src_cat = pf.open(cat_file) NPIX = hp.pixelfunc.nside2npix(nside) CAT = src_cat['LAT_Point_Source_Catalog'] RADrad = np.radians(mask_rad) SOURCES = CAT.data class1 = SOURCES.field('CLASS1') class_mask = (class1 == 'PSR') | (class1 == 'PWN') | (class1 == 'SNR') | \ (class1 == 'psr') | (class1 == 'pwn') | (class1 == 'snr') | \ (class1 == 'spp') | (class1 == 'SFR') | (class1 == 'HMB') | \ (class1 == 'LMB') | (class1 == 'NOV') | (class1 == 'BIN') | \ (class1 == 'lmb') | (class1 == 'SPP') | (class1 == 'hmb') | \ (class1 == 'glc') logger.info('Found %i galactic sources...' % sum(class_mask)) GLON = SOURCES.field('GLON')[class_mask] GLAT = SOURCES.field('GLAT')[class_mask] x, y, z = hp.rotator.dir2vec(GLON, GLAT, lonlat=True) bad_pix = list(hp.pixelfunc.vec2pix(nside, x, y, z)) bad_pix_inrad = [] for bn in bad_pix: pixVec = hp.pix2vec(nside, bn) radintpix = hp.query_disc(nside, pixVec, RADrad) bad_pix_inrad.extend(radintpix) bad_pix.extend(bad_pix_inrad) src_cat.close() return bad_pix
def gtpsf(label, gtpsf_dict): """ Calls gtpsf from Science Tools Parameters ---------- label: str To automatically set the name of the output file gtpsf_dict: python dict To define all the parameters Returns ------- str the autogenerated output file name """ logger.info('Running gtpsf...') LABEL = label OUTPATH = os.path.join(FT_DATA_FOLDER, 'output/output_gtpsf') if not os.path.exists(OUTPATH): os.makedirs(OUTPATH) INFILE = os.path.join(FT_DATA_FOLDER, 'output/output_gtltcube/%s_outofltcube.fits' % LABEL) OUTFILE = os.path.join(OUTPATH, LABEL + '_psf.fits') if os.path.exists(OUTFILE): logger.info('ATT: Already created %s' % OUTFILE) return OUTFILE if gtpsf_dict['outfile'] == 'DEFAULT': outfile = OUTFILE else: outfile = gtpsf_dict['outfile'] if gtpsf_dict['expcube'] == 'DEFAULT': expcube = INFILE else: expcube = gtpsf_dict['expcube'] irfs = gtpsf_dict['irfs'] evtype = gtpsf_dict['evtype'] ra = gtpsf_dict['ra'] dec = gtpsf_dict['dec'] emin = gtpsf_dict['emin'] emax = gtpsf_dict['emax'] nenergies = gtpsf_dict['nenergies'] thetamax = gtpsf_dict['thetamax'] ntheta = gtpsf_dict['ntheta'] os.system('gtpsf expcube=%s outfile=%s irfs=%s evtype=%i ra=%f dec=%f emin=%e emax=%e nenergies=%i thetamax=%i ntheta=%i' \ %(expcube, outfile, irfs, evtype, ra, dec, emin, emax, \ nenergies, thetamax, ntheta)) logger.info('Created %s' % outfile) logger.info('gtpsf --> CPU time spent: %.2f' % time.clock()) return OUTFILE
def mask_src(CAT_FILE, MASK_S_RAD, NSIDE, FLUX_THRESHOLD=None): """Returns the 'bad pixels' defined by the position of a source and a certain radius away from that point. cat_file: str .fits file of the sorce catalog MASK_S_RAD: float radius around each source definig bad pixels to mask NSIDE: int healpix nside parameter FLUX_TRHRESHOLD: float threshold in Integral photon flux from 1 to 100 GeV to mask sources; only sources with 'Flux1000' > FLUX_TRHRESHOLD will be masked. """ logger.info('Mask for sources activated') src_cat = pf.open(CAT_FILE) NPIX = hp.pixelfunc.nside2npix(NSIDE) CAT = src_cat['LAT_Point_Source_Catalog'] BAD_PIX_SRC = [] SOURCES = CAT.data RADrad = np.radians(MASK_S_RAD) for i in range(0, len(SOURCES) - 1): FLUX1000 = SOURCES.field('Flux1000')[i] if FLUX_THRESHOLD is not None: if FLUX1000 < FLUX_THRESHOLD: continue else: GLON = SOURCES.field('GLON')[i] GLAT = SOURCES.field('GLAT')[i] x, y, z = hp.rotator.dir2vec(GLON, GLAT, lonlat=True) b_pix = hp.pixelfunc.vec2pix(NSIDE, x, y, z) BAD_PIX_SRC.append(b_pix) BAD_PIX_inrad = [] for bn in BAD_PIX_SRC: pixVec = hp.pix2vec(NSIDE, bn) radintpix = hp.query_disc(NSIDE, pixVec, RADrad) BAD_PIX_inrad.extend(radintpix) BAD_PIX_SRC.extend(BAD_PIX_inrad) src_cat.close() return BAD_PIX_SRC
def get_param_error(profilelh_spline, param_array, lh_delta=2.3): """ """ lh_array = profilelh_spline(param_array) lh_min_idx = np.argmin(lh_array) lherr = lh_array[lh_min_idx] + lh_delta if lh_min_idx == 0: logger.info('ATT: UPPER limit!') sx_err = param_array[0] dx_err = param_array[-1] elif lh_min_idx == len(lh_array) - 1: logger.info('ATT: LOWER limit!') sx_err = param_array[0] dx_err = param_array[-1] else: sx_err = param_array[np.abs(lh_array[:lh_min_idx] - lherr).argmin()] dx_err = param_array[lh_min_idx + np.abs(lh_array[lh_min_idx:] - lherr).argmin()] return sx_err, dx_err
def combinemasks(**kwargs): """Routine to produce sky maps (limited edition) """ f_ = kwargs['maskfiles'] logger.info('Reading mask %s...' % f_[0]) combmask = hp.read_map(f_[0]) for f in f_[1:]: m = hp.read_map(f) combmask *= m hp.write_map( os.path.join(X_OUT, 'fits/MaskCombo_%s.fits' % kwargs['outflabel']), combmask) logger.info( 'Created %s' % os.path.join(X_OUT, 'fits/MaskCombo_%s.fits' % kwargs['outflabel'])) if kwargs['show'] == True: hp.mollview(combmask, cmap='bone') plt.show()
def pol_create_config(pol_dict, config_file_name): """ Creates and returns PolSpice config ascii file. Parameters ---------- pol_dict : python dict a dictionary where all the parameters of a tipical PolSpice config ascii file should have. config_file_name : str name of the confg ascii file that will be created Returns ------- str Name of the created PolSpice config file """ pol_config = config_file_name pol_config_file = open(pol_config, 'w') for key in pol_dict: pol_config_file.write('%s = %s \n' % (key, str(pol_dict[key]))) logger.info(config_file_name) return pol_config
def gtltsum(label, sumlt_dict): """ Calls gtltsum from Science Tools Parameters ---------- lablel: str To automatically set the name of the output file sumlt_dict: python dict To define all the parameters Returns ------- str the autogenerated output file name """ logger.info('Running gtltsum...') LABEL = label OUTPATH = os.path.join(FT_DATA_FOLDER, 'output/output_gtltsum') if not os.path.exists(OUTPATH): os.makedirs(OUTPATH) OUTFILE = os.path.join(OUTPATH, LABEL + '_ltsum.fits') if os.path.exists(OUTFILE): logger.info('ATT: Already created %s' % OUTFILE) else: for key in sumlt_dict: if key == 'outfile': if sumlt_dict[key] == 'DEFAULT': my_apps.addCubes['outfile'] = OUTFILE else: my_apps.addCubes[key] = sumlt_dict[key] continue my_apps.addCubes[key] = sumlt_dict[key] my_apps.addCubes.run() logger.info('Created %s' % OUTFILE) logger.info('gtsumlt --> CPU time spent: %.2f' % time.clock()) return OUTFILE
def gtmktime(label, maketime_dict): """ Calls gtmktime from Science Tools. Parameters ---------- label: str To automatically set the name of the output file filter_dict: python dict To define all the parameters Returns ------- str the autogenerated output file name """ logger.info('Running gtmktime...') LABEL = label OUTPATH = os.path.join(FT_DATA_OUT, 'output_gtmktime') if not os.path.exists(OUTPATH): os.makedirs(OUTPATH) OUTFILE = os.path.join(OUTPATH, LABEL + '_outofmktime.fits') if os.path.exists(OUTFILE): logger.info('ATT: Already created %s' % OUTFILE) else: for key in maketime_dict: if key == 'outfile': if maketime_dict[key] == 'DEFAULT': my_apps.maketime['outfile'] = OUTFILE else: my_apps.maketime[key] = maketime_dict[key] continue my_apps.maketime[key] = maketime_dict[key] my_apps.maketime.run() logger.info('Created %s' % OUTFILE) logger.info('gtmktime --> CPU time spent: %.2f' % time.clock()) return OUTFILE
def mask_extsrc(CAT_FILE, nside=512): """Returns the 'bad pixels' defined by the position of a source and a certain radius away from that point. cat_file: str .fits file of the sorce catalog mask_rad: float radius around each source definig bad pixels to mask nside: int healpix nside parameter """ logger.info('Mask for extended sources activated') src_cat = pf.open(CAT_FILE) NPIX = hp.pixelfunc.nside2npix(nside) CAT_EXTENDED = src_cat['ExtendedSources'] BAD_PIX_SRC = [] EXT_SOURCES = CAT_EXTENDED.data src_cat.close() for i, src in enumerate(EXT_SOURCES): NAME = EXT_SOURCES.field('Source_Name')[i] GLON = EXT_SOURCES.field('GLON')[i] GLAT = EXT_SOURCES.field('GLAT')[i] if 'LMC' in NAME or 'CenA Lobes' in NAME: logger.info('Masking %s with 10 deg radius disk...' % NAME) x, y, z = hp.rotator.dir2vec(GLON, GLAT, lonlat=True) b_pix = hp.pixelfunc.vec2pix(nside, x, y, z) BAD_PIX_SRC.append(b_pix) radintpix = hp.query_disc(nside, (x, y, z), np.radians(10)) BAD_PIX_SRC.extend(radintpix) else: logger.info('Masking %s with 5 deg radius disk...' % NAME) x, y, z = hp.rotator.dir2vec(GLON, GLAT, lonlat=True) b_pix = hp.pixelfunc.vec2pix(nside, x, y, z) BAD_PIX_SRC.append(b_pix) radintpix = hp.query_disc(nside, (x, y, z), np.radians(5)) BAD_PIX_SRC.extend(radintpix) return BAD_PIX_SRC
def mkSmartMask(**kwargs): """Routine to produce sky maps, according to defined macro-bins. """ logger.info('SmartMask production...') assert(kwargs['config'].endswith('.py')) get_var_from_file(kwargs['config']) macro_bins = data.MACRO_BINS mask_label = data.MASK_LABEL in_labels_list = data.IN_LABELS_LIST micro_bin_file = data.MICRO_BINS_FILE emin, emax, emean = get_energy_from_fits(micro_bin_file, \ minbinnum=macro_bins[0][0], maxbinnum=macro_bins[-1][1]) E_MIN, E_MAX = emin[0], emax[-1] logger.info('Checking PSF file...') PSF_FILE = kwargs['psffile'] if PSF_FILE is not None: logger.info('Using %s'%PSF_FILE) else: logger.info('ATT: File not found: %s'%PSF_FILE) logger.info('Creating PSF file with gtpsf...') try: IRFS = kwargs['irfs'] except: logger.info('ERROR: provide IRFS!') sys.exit() try: EVTYPE = kwargs['evtype'] except: logger.info('ERROR: provide event type!') sys.exit() try: LT_FILE = data.LT_FILE except: LT_FILE = '' if os.path.exists(LT_FILE): logger.info('Livetime file found.') else: try: LT_FILE = kwargs['ltfile'] except: logger.info('ERROR: provide livetime file or list!') sys.exit() if LT_FILE.lower().endswith(('.txt', '.dat')): lt_dict = {'infile1' : LT_FILE, 'outfile' : 'DEFAULT', 'chatter': 4, 'clobber': 'no'} from Xgam.utils.ScienceTools_ import gtltsum label_lt = IRFS + '_evt' + str(EVTYPE) out_gtltsum = gtltsum(label_lt,lt_dict) expcube = out_gtltsum else: expcube = LT_FILE from Xgam.utils.ScienceTools_ import gtpsf label_psf = IRFS + '_evt' + str(EVTYPE) psf_dict = {'expcube' : expcube, 'outfile' : 'DEFAULT', 'irfs' : IRFS, 'evtype' : EVTYPE, 'ra' : 45.0, 'dec' : 45.0, 'emin' : E_MIN, 'emax' : E_MAX, 'nenergies' : 500, 'thetamax' : 30.0, 'ntheta' : 100, 'chatter': 4, 'clobber': 'no'} PSF_FILE = gtpsf(label_psf, psf_dict) #NOTE: IMPLEMENT TYPE2 ?? if kwargs['typesrcmask'] == 1: from Xgam.utils.mkmask_ import mask_src_fluxPSFweighted_1 as mask_src else: from Xgam.utils.mkmask_ import mask_src_fluxPSFweighted_2 as mask_src from Xgam.utils.mkmask_ import mask_gp from Xgam.utils.parsing_ import get_psf_en_univariatespline nside = kwargs['nside'] out_label = kwargs['outflabel'] npix = hp.nside2npix(nside) src_cat = kwargs['srccat'] src_ext_cat = kwargs['srcextcat'] out_name_list = os.path.join(X_OUT, 'fits/MaskSmart_'+out_label+'_GAL_list.txt') out_list = [] for i, (minb, maxb) in enumerate(macro_bins): logger.info('Considering bins from %i to %i...' %(minb, maxb)) emin, emax, emean = get_energy_from_fits(micro_bin_file, minbinnum=minb, maxbinnum=maxb) E_MIN, E_MAX = emin[0], emax[-1] E_MEAN = np.sqrt(emax[0]*emin[-1]) logger.info('Energies %.1f - %.1f [MeV]' %(E_MIN, E_MAX)) if kwargs['coord']=='CEL': out_name = os.path.join(X_OUT, 'fits/MaskSmart_'+out_label+'_CEL_%i.fits'%(E_MIN)) else: out_name = os.path.join(X_OUT, 'fits/MaskSmart_'+out_label+'_GAL_%i.fits'%(E_MIN)) out_list.append(out_name) if os.path.exists(out_name) and not kwargs['overwrite']: logger.info('ATT: %s already exists! \n'%out_name) else: bad_pix = [] mask = np.ones(npix) bad_pix += mask_gp(kwargs['gpcut'], nside) psf_spline = get_psf_en_univariatespline(PSF_FILE) bad_pix += mask_src(src_cat, src_ext_cat, psf_spline, E_MIN, nside) for bpix in np.unique(bad_pix): mask[bpix] = 0 if not os.path.exists(os.path.join(X_OUT, 'fits')): os.system('mkdir %s' %os.path.join(X_OUT, 'fits')) fsky = 1-(len(np.unique(bad_pix))/float(npix)) logger.info('fsky = %.3f'%fsky) if kwargs['coord']=='CEL': from Xgam.utils.PolSpice_ import change_coord mask = change_coord(mask, ['G','C']) logger.info('Changing coordinate system to celestial...') hp.write_map(out_name, mask, coord='G', overwrite=True) logger.info('Created %s \n' %out_name) if kwargs['show'] == True: import matplotlib.pyplot as plt hp.mollview(mask, cmap='bone') plt.show() if kwargs['coord']=='CEL': out_name_list = out_name_list.replace('GAL', 'CEL') logger.info('Writing list of output files: %s'%out_name_list) np.savetxt(out_name_list, out_list, fmt='%s') logger.info('Done!')
def mkAuto(**kwargs): """ """ get_var_from_file(kwargs['config']) maps_ = data.MAPS_LIST masks_ = data.MASKS_LIST fermi_wb_matrix = data.FERMI_WBEAM_MATRIX lss_wb_ = data.LSS_TRACER_WBEAM_LIST out_label = data.OUT_LABEL gamma = data.GAMMA l_max_ = data.MAX_APS_MULTIPOLE_FIT lmax = data.BINNING_MAX_MULTIPOLE lmin = data.BINNING_MIN_MULTIPOLE bin_num = data.BINNING_MULTIPOLE_NBIN bin_alg = data.BINNING_MULTIPOLE_ALGORITHM bin_custom = data.BINNING_CUSTOM fit_function = data.FIT_FUNCTION cn_list = data.FERMI_CN_LIST fit_guess = data.FIT_GUESS def const_fit_function(x, k): return k if type(maps_) == str and maps_.endswith(('.txt','.dat')): maps_ = open(maps_, 'r') maps_ = maps_.read().splitlines() if type(masks_) == str and masks_.endswith(('.txt','.dat')): masks_ = open(masks_, 'r') masks_ = masks_.read().splitlines() logger.info('Starting ...') cl_txt_f = os.path.join(X_OUT,'%s_autocorrelation.txt'%(out_label)) if os.path.exists(cl_txt_f): logger.info('ATT: Output file already exists!') logger.info(cl_txt_f) if not kwargs['overwrite']: sys.exit() else: logger.info('ATT: Overwriting files!') cl_txt = open(cl_txt_f, 'w') emin_, emax_, wl_, fsky_ = [], [], [], [] logger.info('----- AUTO -----') for i, m1_f in enumerate(maps_): l_max = l_max_[i] logger.info('Considering map: %s'%m1_f) m1 = hp.read_map(m1_f) if len(masks_) == len(maps_): mask_f = masks_[i] elif len(masks_) == 1: mask_f = masks_[0] else: logger.info('ERROR: Inconsistent number of masks!'+ 'It should be either 1 or the same number as Fermi maps!') sys.exit() logger.info('Considering Fermi mask: %s'%mask_f) mask = hp.read_map(mask_f) m1_masked = hp.ma(m1) m1_masked.mask = np.logical_not(mask) logger.info('Computing the pixel window function ...') nside = hp.npix2nside(len(m1)) wpix = hp.wpix = hp.sphtfunc.pixwin(nside, lmax=lmax-1) cn = cn_list[i] fsky = np.sum(mask)/len(mask) fsky_.append(fsky) if fermi_wb_matrix is not None: logger.info('Computing the fermi beam window function ...') spec = get_powerlaw_spline(gamma) emin_str = re.search(r'%s'%EMIN_STR, m1_f) emin = float(emin_str.group(0).replace('-','')) emax_str = re.search(r'%s'%EMAX_STR, m1_f) emax = float(emax_str.group(0).replace('.fits', '')) wb_spline = get_1D_wbeam(fermi_wb_matrix, spec, e_min=emin, e_max=emax) wb = wb_spline(np.arange(lmax)) emin_.append(emin) emax_.append(emax) if kwargs['show']: wb_spline.plot(show=False, label='%.2f-%.2f GeV'%(emin/1000, emax/1000), color='0.3') plt.ylabel('W$_{beam}$', size=15) plt.xlabel('$l$', size=15) plt.legend(loc=1, fontsize=14) plt.grid('off') # ------- TO BE DEFINED ------ if lss_wb_ is not None: logger.info('Getting the LSS beam window function ...') lss_wb = np.ones(len(wb)) cl_txt.write('# ********************************\n') cl_txt.write('# AUTOCORR ---> %i x %i\n'%(i, i)) if lss_wb_ is None: wl = wb * wpix wl_.append(wl) else: # ------- TO BE DEFINED ------ wl = lss_wb * wpix wl_.append(wl) out_folder = os.path.join(X_OUT, 'output_pol') if not os.path.exists(out_folder): os.makedirs(out_folder) pol_dict = data.POLCEPICE_DICT for key in pol_dict: if key == 'clfile': pol_dict[key] = os.path.join(out_folder,'%s_%i_cl.txt'%(out_label, i)) if key == 'cl_outmap_file': pol_dict[key] = os.path.join(out_folder,'%s_%i_clraw.txt'%(out_label, i)) # if key == 'covfileout': # pol_dict[key] = os.path.join(out_folder,'%s_%i_cov.fits'%(out_label, i)) if key == 'mapfile': pol_dict[key] = m1_f if key == 'maskfile': pol_dict[key] = mask_f if key == 'mapfile2': pol_dict[key] = 'NO' if key == 'maskfile2': pol_dict[key] = 'NO' config_file_name = os.path.join(out_folder, 'pol_autoconfig_%s_%i.txt'%(out_label, i)) _l, _cl, _cl_err = pol_cl_calculation(pol_dict, config_file_name, cov=False, wl_array=wl, cn=cn, rebin=True, nbin=bin_num, bin_type=bin_alg, lmin=lmin, lmax=lmax, custom_bins=bin_custom) fit_idx = np.where((_l >= 30)&(_l <= l_max))[0] try: popt, pcov = curve_fit(fit_function, _l[fit_idx], _cl[fit_idx], sigma=_cl_err[fit_idx], bounds=([0, 0, -1e-12], [1e-12, 5, 1e-12]), absolute_sigma=True) chi2 = np.sum(((_cl[fit_idx] - fit_function(_l[fit_idx], *popt))/_cl_err[fit_idx])**2) chi2red = chi2/len(_cl[fit_idx]) logger.info('\n') logger.info('********************************') logger.info('Multipole fit range: %i - %i'%(30, l_max)) logger.info('Best fit param: %s'%str(popt)) logger.info('Chi2/dof = %.3f'%chi2red) logger.info('********************************\n') #cl_domain = np.where(_cl[fit_idx] > cn)[0] #if len(cl_domain) == 0: if chi2red < 3: cl_txt.write('Cn : %s\n'%str(cn)) cl_txt.write('Multipole fit range: %i - %i\n'%(30, l_max)) cl_txt.write('Best fit params = %s\n'%str(popt)) cl_txt.write('Chi2/dof = %.3f\n'%chi2red) else: logger.info('ATT: repeating fit with a constant') popt, pcov = curve_fit(const_fit_function, _l[fit_idx], _cl[fit_idx], sigma=_cl_err[fit_idx], bounds=([-1e-12], [1e-12]), absolute_sigma=True) chi2 = np.sum(((_cl[fit_idx] - const_fit_function(_l[fit_idx], *popt))/_cl_err[fit_idx])**2) chi2red_k = chi2/len(_cl[fit_idx]) cl_txt.write('Cn : %s\n'%str(cn)) cl_txt.write('Multipole fit range: %i - %i\n'%(30, l_max)) cl_txt.write('Best fit constant : %s\n'%str(popt)) cl_txt.write('Chi2/dof = %.3f\n'%chi2red_k) plt.figure() plt.errorbar(_l[fit_idx], _cl[fit_idx], yerr=_cl_err[fit_idx], fmt='.', label='%.2f-%.2f GeV'%(emin/1000, emax/1000)) if chi2red < 3.: plt.plot(_l[fit_idx], fit_function(_l[fit_idx], *popt), label='Best fit ($\chi^2_{/dof}$=%.2f)'%chi2red) else: plt.plot(_l[fit_idx], np.full(len(_l[fit_idx]), popt[0]), label='Best fit ($\chi^2_{/dof}$=%.2f)'%chi2red_k) plt.hlines(cn, _l[fit_idx][0], _l[fit_idx][-1], linestyle='--', color='0.3', label='C$_N$') if bin_alg == 'log': plt.xscale('log') plt.xlabel('$\ell$') plt.ylabel('$C_{\ell}$') plt.legend() plt.savefig('output/figs/Autocorr_%ix%i'%(i,i)) if kwargs['show']: plt.show() except RuntimeError: logger.info('\n') logger.info('********************************') logger.info("Error - curve_fit failed") logger.info('********************************\n') cl_txt.write('Cn : %s\n'%str(cn)) cl_txt.write('Error - curve_fit failed\n') plt.figure() plt.errorbar(_l[fit_idx], _cl[fit_idx], yerr=_cl_err[fit_idx], fmt='.') if bin_alg == 'log': plt.xscale('log') plt.show() cl_txt.write('\n\n\n') logger.info('----- CROSS -----') for i, m1_f in enumerate(maps_): wl1 = wl_[i] fsky1 = fsky_[i] l_max1 = l_max_[i] for j in range(i, len(maps_)): wl2 = wl_[j] m2_f = maps_[j] fsky2 = fsky_[j] l_max2 = l_max_[j] if m1_f == m2_f: continue if fsky1 <= fsky2: mask_f = masks_[2] else: mask_f = masks_[2] out_folder = os.path.join(X_OUT, 'output_pol') if not os.path.exists(out_folder): os.makedirs(out_folder) pol_dict = data.POLCEPICE_DICT for key in pol_dict: if key == 'clfile': pol_dict[key] = os.path.join(out_folder,'%s_%i%i_cl.txt'%(out_label, i, j)) if key == 'cl_outmap_file': pol_dict[key] = os.path.join(out_folder,'%s_%i%i_clraw.txt'%(out_label, i, j)) if key == 'mapfile': pol_dict[key] = m1_f if key == 'maskfile': pol_dict[key] = mask_f if key == 'mapfile2': pol_dict[key] = m2_f if key == 'maskfile2': pol_dict[key] = mask_f config_file_name = os.path.join(out_folder, 'pol_autocrossconfig_%s_%i%i.txt'%(out_label, i, j)) wl = np.sqrt(wl1*wl2) _l, _cl, _cl_err = pol_cl_calculation(pol_dict, config_file_name, cov=False, wl_array=wl, rebin=True, nbin=bin_num, bin_type=bin_alg, lmin=lmin, lmax=lmax, custom_bins=bin_custom) cl_txt.write('# ********************************\n') cl_txt.write('# CROSSCORR ---> %i x %i\n'%(i, j)) if l_max1 <= l_max2: l_max = l_max1 else: l_max = l_max2 fit_idx = np.where((_l >= 30)&(_l <= l_max))[0] try: popt, pcov = curve_fit(const_fit_function, _l[fit_idx], _cl[fit_idx], sigma=_cl_err[fit_idx], #bounds=([0, 0, -1e-12], [1e-12, 3, 1e-12]), absolute_sigma=True) bounds=([-1e-15], [1e-15]), absolute_sigma=True) chi2 = np.sum(((_cl[fit_idx] - const_fit_function(_l[fit_idx], *popt))/_cl_err[fit_idx])**2) chi2red = chi2/len(_cl[fit_idx]) logger.info('\n') logger.info('********************************') logger.info('Multipole fit range: %i - %i'%(30, l_max)) logger.info('Best fit param: %s'%str(popt)) logger.info('Chi2/dof = %.3f'%chi2red) logger.info('********************************\n') cl_txt.write('Cn : 0\n') cl_txt.write('Multipole fit range: %i - %i\n'%(30, l_max)) cl_txt.write('Best fit params : %s\n'%str(popt)) #cl_txt.write('Chi2/dof = %.3f\n'%chi2red) plt.figure() plt.errorbar(_l[fit_idx], _cl[fit_idx], yerr=_cl_err[fit_idx], fmt='.', label='(%.2f-%.2f)GeV x (%.2f-%.2f)GeV'%(emin_[i]/1000, emax_[i]/1000, emin_[j]/1000, emax_[j]/1000)) #plt.plot(_l[fit_idx], fit_function(_l[fit_idx], *popt)) plt.plot(_l[fit_idx], np.full(len(_l[fit_idx]), popt[0]), label='Best fit ($\chi^2_{/dof}$=%.2f)'%chi2red_k) if bin_alg == 'log': plt.xscale('log') plt.xlabel('$\ell$') plt.ylabel('$C_{\ell}$') plt.legend() plt.savefig('output/figs/Autocorr_%ix%i'%(i,j)) if kwargs['show']: plt.show() except RuntimeError: logger.info('\n') logger.info('********************************') logger.info("Error - curve_fit failed") logger.info('********************************\n') cl_txt.write('Error - curve_fit failed\n') cl_txt.close() logger.info('Created %s'%cl_txt_f)
def mkSTanalysis(**kwargs): """Science Tools analysis chain """ assert (kwargs['config'].endswith('.py')) get_var_from_file(kwargs['config']) logger.info('Starting ST analysis...') from Xgam.utils.ScienceTools_ import mergeft1 PH, SC = 'photon', 'spacecraft' PH_FOLDER = os.path.join(FT_DATA_FOLDER, PH) SC_FOLDER = os.path.join(FT_DATA_FOLDER, SC) start_week, end_week = data.START_WEEK, data.STOP_WEEK logger.info('Taking data from week %i to week %i' % (start_week, end_week)) FT1_FILE = mergeft1(PH_FOLDER, 'FT1_w%i-%i.txt'%(start_week, end_week), \ start_week, end_week) #FT2_FILE = mergeft2(SC_FOLDER, 'FT2_w%i-%i.txt'%(start_week, end_week), \ # start_week, end_week) out_label = data.OUT_LABEL txt_out_files = open('output/' + out_label + '_outfiles.txt', 'w') from Xgam.utils.ScienceTools_ import gtselect gtselect_dict = data.GTSELECT_DICT if gtselect_dict['infile'] == 'DEFAULT': gtselect_dict['infile'] = FT1_FILE out_gtselect = gtselect(out_label, gtselect_dict) txt_out_files.write(out_gtselect + '\n') from Xgam.utils.ScienceTools_ import gtmktime gtmktime_dict = data.GTMKTIME_DICT if gtmktime_dict['evfile'] == 'DEFAULT': gtmktime_dict['evfile'] = out_gtselect if gtmktime_dict['scfile'] == 'DEFAULT': gtmktime_dict['scfile'] = FT2_FILE out_gtmktime = gtmktime(out_label, gtmktime_dict) txt_out_files.write(out_gtmktime + '\n') from Xgam.utils.ScienceTools_ import gtbin gtbin_dict = data.GTBIN_DICT if gtbin_dict['evfile'] == 'DEFAULT': gtbin_dict['evfile'] = out_gtmktime if gtbin_dict['scfile'] == 'DEFAULT': gtbin_dict['scfile'] = FT2_FILE out_gtbin = gtbin(out_label, gtbin_dict) txt_out_files.write(out_gtbin + '\n') if kwargs['gtltcube'] == True: from Xgam.utils.ScienceTools_ import gtltcube gtltcube_dict = data.GTLTCUBE_DICT if gtltcube_dict['evfile'] == 'DEFAULT': gtltcube_dict['evfile'] = out_gtmktime if gtbin_dict['scfile'] == 'DEFAULT': gtbin_dict['scfile'] = FT2_FILE out_gtltcube = gtltcube(out_label, gtltcube_dict) txt_out_files.write(out_gtltcube + '\n') else: logger.info('Not running gtltcube.') pass from Xgam.utils.ScienceTools_ import gtexpcube2 gtexpcube2_dict = data.GTEXPCUBE2_DICT if gtexpcube2_dict['infile'] == 'DEFAULT': gtexpcube2_dict['infile'] = out_gtltcube if gtexpcube2_dict['cmap'] == 'DEFAULT': gtexpcube2_dict['cmap'] = out_gtbin out_gtexpcube2 = gtexpcube2(out_label, gtexpcube2_dict) txt_out_files.write(out_gtexpcube2 + '\n') txt_out_files.close() logger.info('Created output/' + out_label + '_outfiles.txt') logger.info('Done!')
def aps_view(**kwargs): """ Viewer interface for APS and Covariance matrix """ params = parse_polspice_aps(kwargs['infile']) _emin, _emax = params[0], params[1] _l, _cl, _clerr = params[2], params[3], params[4] _cov_ = params[5] logger.info('Generating APS plots...') for i, cl in enumerate(_cl): sig = cl / _clerr[i] print('-----------------------') print('Detection Significance:') print(sig) print('-----------------------') aps_label = '%.1f-%.1f GeV' % (_emin[i] / 1000, _emax[i] / 1000) fig = plt.figure() ax = fig.add_subplot(111) plt.plot([0, 2000], [0, 0], '--', color='silver') plt.errorbar(_l[i], cl, fmt='o', markersize=5, elinewidth=2, label=aps_label, color='red', yerr=_clerr[i]) plt.xlim(np.amin(_l[i]), np.amax(_l[i]) + 1) plt.xscale(kwargs['xscale']) plt.xlabel('Multipole', size=15) plt.ylabel('C$^{sig}_{\ell}$ [(cm$^{-2}$s$^{-1}$sr$^{-1}$)sr]', size=15) plt.title(kwargs['title']) plt.tight_layout() plt.legend(loc=1, fontsize=16) logger.info('Generating Covariance matrices plots...') for k, cov in enumerate(_cov_): _cov2plotij_ = [] for i in range(0, len(cov) - 1): sigii = cov[i][i] _cov2plotj = [] for j in range(0, len(cov[0]) - 1): sigjj = cov[j][j] sigij = cov[j][i] if sigij < 0: sigij = 1e-100 _cov2plotj.append(np.sqrt(sigij / np.sqrt(sigii * sigjj))) _cov2plotij_.append(_cov2plotj) _cov2plotij_ = np.array(_cov2plotij_) fig = plt.figure() ax = fig.add_subplot(111) cax = ax.matshow(_cov2plotij_, origin='lower', aspect='auto', cmap='viridis', extent=[_l[k][0], _l[k][-1], _l[k][0], _l[k][-1]]) ax.xaxis.set_ticks_position('bottom') plt.title(kwargs['title'] + ' (%.1f-%.1f GeV)' % (_emin[k] / 1000, _emax[k] / 1000)) plt.xlabel('Multipole $\ell_{i}$', size=15) plt.ylabel('Multipole $\ell_{j}$', size=15) cbar = plt.colorbar(cax) cbar.set_label('$\sigma_{ij}/\sqrt{\sigma_{ii}\sigma_{jj}}$', size=15) #plt.tight_layout() plt.grid(False) plt.show()
def mkMask(**kwargs): """Routine to produce sky maps (limited edition) """ logger.info('Starting mask production...') get_var_from_file(kwargs['config']) bad_pix = [] nside = data.NSIDE out_label = data.OUT_LABEL npix = hp.nside2npix(nside) mask = np.ones(npix) if kwargs['srcmask'] == True: from Xgam.utils.mkmask_ import mask_src src_mask_rad = data.SRC_MASK_RAD cat_file = data.SRC_CATALOG flux_th = kwargs['srcfluxthreshold'] bad_pix += mask_src(cat_file, src_mask_rad, nside, FLUX_THRESHOLD=flux_th) if kwargs['galsrcmask'] == True: from Xgam.utils.mkmask_ import mask_galactic_src cat_file = data.SRC_CATALOG bad_pix += mask_galactic_src(cat_file, 2., nside) if kwargs['extsrcmask'] == True: from Xgam.utils.mkmask_ import mask_extsrc src_mask_rad = data.SRC_MASK_RAD cat_file = data.EXTSRC_CATALOG bad_pix += mask_extsrc(cat_file, nside) if kwargs['gpmask'] == 'flat': from Xgam.utils.mkmask_ import mask_gp gp_mask_lat = data.GP_MASK_LAT bad_pix += mask_gp(gp_mask_lat, nside) if kwargs['srcweightedmask'] == True: from Xgam.utils.mkmask_ import mask_src_fluxPSFweighted_1 from Xgam.utils.parsing_ import get_psf_en_univariatespline cat_file = data.SRC_CATALOG ext_cat_file = data.EXTSRC_CATALOG psf_f = data.PSF_FILE energy = data.ENERGY psf_spline = get_psf_en_univariatespline(psf_f) bad_pix += mask_src_fluxPSFweighted_1(cat_file, ext_cat_file, psf_spline, energy, nside) if kwargs['srcweightedmask2'] == True: from Xgam.utils.mkmask_ import mask_src_fluxPSFweighted_2 from Xgam.utils.parsing_ import get_psf_en_univariatespline cat_file = data.SRC_CATALOG ext_cat_file = data.EXTSRC_CATALOG psf_f = data.PSF_FILE e_min = data.E_MIN e_max = data.E_MAX psf_spline = get_psf_en_univariatespline(psf_f) bad_pix += mask_src_fluxPSFweighted_2(cat_file, ext_cat_file, psf_spline, e_min, e_max, nside) if kwargs['northmask'] == True: from Xgam.utils.mkmask_ import mask_north north_lat = data.NORTH_LAT bad_pix += mask_north(north_lat, nside) if kwargs['southmask'] == True: from Xgam.utils.mkmask_ import mask_south south_lat = data.SOUTH_LAT bad_pix += mask_south(south_lat, nside) for bpix in np.unique(bad_pix): mask[bpix] = 0 if not os.path.exists(os.path.join(X_OUT, 'fits')): os.system('mkdir %s' %os.path.join(X_OUT, 'fits')) out_name = os.path.join(X_OUT, 'fits/'+out_label+'_GAL.fits') fsky = 1-(len(np.unique(bad_pix))/float(npix)) logger.info('fsky = %.3f'%fsky) if kwargs['coord']=='CEL': from Xgam.utils.PolSpice_ import change_coord mask = change_coord(mask, ['G','C']) hp.write_map(out_name.replace('GAL', 'CEL'), mask, coord='C') logger.info('Created %s' %out_name.replace('GAL', 'CEL')) else: hp.write_map(out_name, mask, coord='G') logger.info('Created %s' %out_name) if kwargs['show'] == True: import matplotlib.pyplot as plt hp.mollview(mask, cmap='bone') plt.show()
def main(): """Test smodule. """ logger.info('No test module is available at the moment... bye bye!') return 0
def get_fore_integral_flux_map(fore_files_list, e_min, e_max): """ A powerlaw is assumed for the foreground energy spectrum, hence the interpolation between 2 given maps at given energies (given by the model) is done in logarithmic scales. Parameters ---------- fore_files_list: list of str Ordered list of the foreground files (one for each energy) e_min: float the min of the energy bin e_max: float the max of the energy bin Returns ------- array foreground map integrated between e_min and e_max """ fore_en = [] for ff in fore_files_list: m = re.search(FORE_EN, ff) en = int(m.group(0).replace('_', '').replace('.', '')) fore_en.append(en) fore_en = np.array(fore_en) out_name = fore_files_list[0].replace('_%i.fits' % fore_en[0], '_%d-%d.fits' % (e_min, e_max)) if os.path.exists(out_name): logger.info('ATT: file %s already exists and returned...' % out_name) fore_map = hp.read_map(out_name) return fore_map else: logger.info('Computing the integral flux of the foreground model...') logger.info('...between %.2f - %.2f' % (e_min, e_max)) fore_emin_sx, fore_emin_dx = find_outer_energies(e_min, fore_en) fore_emax_sx, fore_emax_dx = find_outer_energies(e_max, fore_en) fore_emin_sx_ind = np.where(fore_en == fore_emin_sx)[0][0] fore_emin_dx_ind = np.where(fore_en == fore_emin_dx)[0][0] fore_emax_sx_ind = np.where(fore_en == fore_emax_sx)[0][0] fore_emax_dx_ind = np.where(fore_en == fore_emax_dx)[0][0] fore_fmin_sx = hp.read_map(fore_files_list[fore_emin_sx_ind]) fore_fmin_dx = hp.read_map(fore_files_list[fore_emin_dx_ind]) fore_fmax_sx = hp.read_map(fore_files_list[fore_emax_sx_ind]) fore_fmax_dx = hp.read_map(fore_files_list[fore_emax_dx_ind]) m1 = (np.log10(fore_fmin_sx)-np.log10(fore_fmin_dx))/ \ (np.log10(fore_emin_sx)-np.log10(fore_emin_dx)) m2 = (np.log10(fore_fmax_sx)-np.log10(fore_fmax_dx))/ \ (np.log10(fore_emax_sx)-np.log10(fore_emax_dx)) logfore1 = m1*(np.log10(e_min)-np.log10(fore_emin_sx))+ \ np.log10(fore_fmin_sx) logfore2 = m2*(np.log10(e_max)-np.log10(fore_emax_sx))+ \ np.log10(fore_fmax_sx) fore1 = 10**(logfore1) fore2 = 10**(logfore2) fore_integ_map = np.sqrt(fore1 * fore2) * (e_max - e_min) hp.write_map(out_name, fore_integ_map) logger.info('Created file %s' % out_name) return fore_integ_map
def fit_foreground_poisson(fore_map, data_map, mask_map=None, n_guess=1., c_guess=0.1, exp=None, smooth=False, show=False): """ Performs the poissonian fit, recursively computing the log likelihood (using poisson_likelihood) for a grid of values of fit parameters around the guess. Returns the values of parameters which minimize the log likelihood, togather to the 1-sigma error Parameters ---------- n_guess : float initial guess for normalization parameter c_guess : float initial guess for constant parameter fore_map : numpy array helapix map of foreground model data_map : numpy array helapix map of data. It could be either a count map or a flux map. If a counts map is given, an exposure map should be given too. See next parameter. exp : numpy array or None helapix map of the exposure. Should be given if the data map is in counts (beacause foreground map is in flux units by default and it needs to be turned to counts to be fitted). While, If data map is in flux units, do not declare this parameter, which is None by default. smooth : bool not implemented yet... show : bool if true it shows some usefull plot to check if the fit is functioning Returns ------- float, float, float, float, float, float In order: best fit N, best fit C, N's right error, N's left error, C's right error, C's left error """ #show=True #mask_map=None logger.info('Performing poissonian fit...') norm_guess = n_guess igrb_guess = c_guess nside_out = 64 mask = 0. logger.info('N guess = %.2f - C guess = %.1e' % (norm_guess, igrb_guess)) if mask_map is None: logger.info('fit outside default mask: 30deg gp, 2 deg srcs.') mask_f = os.path.join(X_CONFIG, 'Mask_hp64_src2_gp30.fits') mask = hp.read_map(mask_f) else: logger.info('fit outside mask given in config file.') mask = mask_map mask = hp.ud_grade(mask, nside_out=nside_out, power=-2) mask[np.where(mask != np.amax(mask))[0]] = 0 mask[np.where(mask == np.amax(mask))[0]] = 1 logger.info('down grade...') fore_repix = np.array(hp.ud_grade(fore_map, nside_out=nside_out)) data_repix = np.array(hp.ud_grade(data_map, nside_out=nside_out, power=-2)) _unmask = np.where(mask > 1e-30)[0] norm_list = np.linspace(norm_guess - 0.8, norm_guess + 0.8, 200) igrb_list = np.logspace(np.log10(igrb_guess * 0.01), np.log10(igrb_guess * 10), 200) logger.info('-------------------------------') logger.info('Minimization likelihood run1...') lh_list = [] combinations = list(product(norm_list, igrb_list)) if exp is not None: exposure = exp exposure = np.array(hp.ud_grade(exposure, nside_out=nside_out)) areapix = 4 * np.pi / (len(data_repix)) for i, j in product(norm_list, igrb_list): lh = poisson_likelihood(i, j, fore_repix[_unmask], data_repix[_unmask], exp=exposure[_unmask], sr=areapix) lh_list.append(lh) else: for i, j in product(norm_list, igrb_list): lh = poisson_likelihood(i, j, fore_repix[_unmask], data_repix[_unmask]) lh_list.append(lh) lh_list = np.array(lh_list) lh_matrix = lh_list.reshape(len(norm_list), len(igrb_list)) prof_lh_norm, prof_lh_igrb = get_2params_profile_likelihood( lh_matrix, norm_list, igrb_list) nn = np.linspace(np.amin(norm_list), np.amax(norm_list), 1000) cc = np.linspace(np.amin(igrb_list), np.amax(igrb_list), 1000) lh_min = np.amin(prof_lh_norm(nn)) logger.info('Minimum -LogL = %s' % lh_min) norm_min = nn[np.argmin(prof_lh_norm(nn))] igrb_min = cc[np.argmin(prof_lh_igrb(cc))] logger.info('Run1 results: n=%.3f c=%e' % (norm_min, igrb_min)) norm_sxerr, norm_dxerr = get_param_error(prof_lh_norm, nn, lh_delta=2.3) logger.info('Norm err: %.4f - %.4f' % (norm_sxerr, norm_dxerr)) igrb_sxerr, igrb_dxerr = get_param_error(prof_lh_igrb, cc, lh_delta=2.3) logger.info('Igrb err: %.2e - %.2e' % (igrb_sxerr, igrb_dxerr)) """ logger.info('-------------------------------') logger.info('Minimization likelihood run2...') norm_list = np.linspace(norm_min-0.3, norm_min+0.3, 100) igrb_list = np.linspace(igrb_min*0.1, igrb_min*10, 200) lh_list = [] combinations = np.array(list(product(norm_list, igrb_list))) if exp is not None: exposure = exp exposure = np.array(hp.ud_grade(exposure, nside_out=nside_out)) areapix = 4*np.pi/(len(data_repix)) for i,j in product(norm_list, igrb_list): lh = poisson_likelihood(i, j, fore_repix[_unmask], data_repix[_unmask], exp=exposure[_unmask], sr=areapix) lh_list.append(lh) else: for i,j in product(norm_list, igrb_list): lh = poisson_likelihood(i, j, fore_repix[_unmask], data_repix[_unmask]) lh_list.append(lh) lh_list = np.array(lh_list) lh_matrix = lh_list.reshape(len(norm_list), len(igrb_list)) prof_lh_norm, prof_lh_igrb = get_2params_profile_likelihood(lh_matrix, norm_list, igrb_list) nn = np.linspace(np.amin(norm_list), np.amax(norm_list), 500) cc = np.linspace(np.amin(igrb_list), np.amax(igrb_list), 1000) lh_min = np.amin(prof_lh_norm(nn)) lh_delta = lh_min+2.3 logger.info('Minimum -LogL = %s'%lh_min) norm_min = nn[np.argmin(prof_lh_norm(nn))] igrb_min = cc[np.argmin(prof_lh_igrb(cc))] logger.info('Run2 results: n=%.3f c=%e'%(norm_min, igrb_min)) norm_sxerr, norm_dxerr = get_param_error(prof_lh_norm, nn, lh_delta) logger.info('Norm err: %.4f - %.4f'%(norm_sxerr, norm_dxerr)) igrb_sxerr, igrb_dxerr = get_param_error(prof_lh_igrb, cc, lh_delta) logger.info('Norm err: %.4f - %.4f'%(igrb_sxerr, igrb_dxerr)) """ if show == True: plt.figure(facecolor='white') plt.plot(nn, prof_lh_norm(nn), '-', color='black') plt.plot([norm_min, norm_min], [lh_min - 10, lh_min + 40], color='red') plt.plot([norm_sxerr, norm_sxerr], [lh_min - 2, lh_min + 40], 'r--', alpha=0.7) plt.plot([norm_dxerr, norm_dxerr], [lh_min - 2, lh_min + 40], 'r--', alpha=0.7) plt.xlabel('Normalization') plt.ylabel('-Log(Likelihood)') plt.ylim(lh_min - 5, lh_min + 30) plt.xlim(norm_min - 0.2, norm_min + 0.2) plt.figure(facecolor='white') plt.plot(cc, prof_lh_igrb(cc), '-', color='black') plt.plot([igrb_min, igrb_min], [lh_min - 10, lh_min + 40], color='red') plt.plot([igrb_sxerr, igrb_sxerr], [lh_min - 2, lh_min + 40], 'r--', alpha=0.7) plt.plot([igrb_dxerr, igrb_dxerr], [lh_min - 2, lh_min + 40], 'r--', alpha=0.7) plt.xlabel('Constant') plt.ylabel('-Log(Likelihood)') plt.ylim(lh_min - 5, lh_min + 30) plt.xlim(igrb_min * 0.9, igrb_min * 1.1) plt.xscale('log') """ fig = plt.figure(facecolor='white') ax = fig.add_subplot(111) x, y = np.mgrid(norm_list, igrb_list) X, Y = np.mgrid(nn, cc) print('---------------', lh_matrix.shape, X.shape, Y.shape) print('---------------', lh_matrix.shape, x.shape, y.shape) Z = griddata((x, y), lh_matrix, (X, Y), method='linear') contours = plt.contour(X, Y, Z, 20, colors='0.4') cax = ax.matshow(Z, origin='lower', cmap='RdGy', extent=[np.amin(norm_list), np.amax(norm_list), np.amin(igrb_list), np.amax(igrb_list)], aspect='auto', alpha=0.5) plt.clabel(contours, inline=True, fontsize=8) plt.ylabel('C [cm$^{-2}$s$^{-1}$sr$^{-1}$]') plt.xlabel('N') ax.xaxis.set_ticks_position('bottom') plt.grid('off') cb = plt.colorbar(cax, format='$%.1e$') cb.set_label('-Log(Likelihood)', rotation=90) """ plt.show() return norm_min, igrb_min, norm_sxerr, norm_dxerr, igrb_sxerr, igrb_dxerr
def mkCross(**kwargs): """ """ get_var_from_file(kwargs['config']) fermi_maps_ = data.FERMI_MAPS_LIST fermi_masks_ = data.FERMI_MASKS_LIST fermi_wb_matrix = data.FERMI_WBEAM_MATRIX lss_maps_ = data.LSS_TRACER_MAPS_LIST lss_masks_ = data.LSS_TRACER_MASK_LIST lss_wb_ = data.LSS_TRACER_WBEAM_LIST out_label = data.OUT_LABEL bin_label = data.BINNING_LABEL gamma = data.GAMMA l_max = data.MAX_APS_MULTIPOLE lmax = data.BINNING_MAX_MULTIPOLE lmin = data.BINNING_MIN_MULTIPOLE bin_num = data.BINNING_MULTIPOLE_NBIN bin_alg = data.BINNING_MULTIPOLE_ALGORITHM bin_custom = data.BINNING_CUSTOM if type(fermi_maps_) == str and fermi_maps_.endswith(('.txt', '.dat')): fermi_maps_ = open(fermi_maps_, 'r') fermi_maps_ = fermi_maps_.read().splitlines() if type(fermi_masks_) == str and fermi_masks_.endswith(('.txt', '.dat')): fermi_masks_ = open(fermi_masks_, 'r') fermi_masks_ = fermi_masks_.read().splitlines() if type(lss_maps_) == str and lss_maps_.endswith(('.txt', '.dat')): lss_maps_ = open(lss_maps_, 'r') lss_maps_ = lss_maps_.read().splitlines() if type(lss_masks_) == str and lss_masks_.endswith(('.txt', '.dat')): lss_masks_ = open(lss_masks_, 'r') lss_masks_ = lss_masks_.read().splitlines() logger.info('Starting Cross-Correlation analysis...') cl_txt_f = os.path.join( X_OUT, '%s_%s_crosscorrelation.txt' % (out_label, bin_label)) if os.path.exists(cl_txt_f): logger.info('ATT: Output file already exists!') logger.info(cl_txt_f) if not kwargs['overwrite']: sys.exit() else: logger.info('ATT: Overwriting files!') cl_txt = open(cl_txt_f, 'w') for i, m1_f in enumerate(fermi_maps_): logger.info('Considering Fermi map: %s' % m1_f) fermi_map = hp.read_map(m1_f) if len(fermi_masks_) == len(fermi_maps_): fermi_mask_f = fermi_masks_[i] elif len(fermi_masks_) == 1: fermi_mask_f = fermi_masks_[0] else: logger.info( 'ERROR: Inconsistent number of masks!' + 'It should be either 1 or the same number as Fermi maps!') sys.exit() logger.info('Considering Fermi mask: %s' % fermi_mask_f) fermi_mask = hp.read_map(fermi_mask_f) if len(lss_maps_) == len(fermi_maps_): m2_f = lss_maps_[i] elif len(lss_maps_) == 1: m2_f = lss_maps_[0] else: logger.info( 'ERROR: Inconsistent number of LSS maps!' + 'It should be either 1 or the same number as Fermi maps!') sys.exit() logger.info('Considering LSS map: %s' % m2_f) lss_map = hp.read_map(m2_f) if len(lss_masks_) == len(fermi_maps_): lss_mask_f = lss_masks_[i] elif len(lss_masks_) == 1: lss_mask_f = lss_masks_[0] else: logger.info( 'ERROR: Inconsistent number of LSS masks!' + 'It should be either 1 or the same number as Fermi maps!') sys.exit() logger.info('Considering LSS mask: %s' % lss_mask_f) lss_mask = hp.read_map(lss_mask_f) logger.info('Computing the pixel window function ...') if not len(fermi_map) == len(lss_map): logger.info('ERROR: Fermi and LSS maps have not the same NSIDE!') sys.exit() nside = hp.npix2nside(len(fermi_map)) wpix = hp.wpix = hp.sphtfunc.pixwin(nside, lmax=l_max - 1) if len(wpix) < l_max: logger.info('-----------------------------') logger.info('ATT: Setting new l_max=%i ...' % len(wpix)) logger.info('-----------------------------') l_max = len(wpix) logger.info('Computing the fermi beam window function ...') spec = get_powerlaw_spline(gamma) emin_str = re.search(r'%s' % EMIN_STR, m1_f) emin = float(emin_str.group(0).replace('-', '')) emax_str = re.search(r'%s' % EMAX_STR, m1_f) emax = float(emax_str.group(0).replace('.fits', '')) if fermi_wb_matrix: wb_spline = get_1D_wbeam(fermi_wb_matrix, spec, e_min=emin, e_max=emax) wb = wb_spline(np.arange(l_max)) else: wb = np.ones(l_max) if kwargs['show']: wb_spline.plot(show=False, label='%.2f-%.2f GeV' % (emin / 1000, emax / 1000), color='0.3') plt.ylabel('W$_{beam}$', size=15) plt.xlabel('$l$', size=15) plt.legend(loc=1, fontsize=14) plt.grid('off') plt.show() # ------- TO BE DEFINED ------ if lss_wb_ is not None: logger.info('Getting the LSS beam window function ...') lss_wb = lss_wb_[i][:l_max] else: lss_wb = np.ones(l_max) cl_txt.write('MAP1 ---> %s\n' % (m1_f)) cl_txt.write('MAP2 ---> %s\n' % (m2_f)) cl_txt.write('ENERGY\t %.2f %.2f \n' % (emin, emax)) out_folder = os.path.join(X_OUT, 'output_pol') if not os.path.exists(out_folder): os.makedirs(out_folder) pol_dict = data.POLCEPICE_DICT for key in pol_dict: if key == 'clfile': pol_dict[key] = os.path.join(out_folder, '%s_%i_cl.txt' % (out_label, i)) if key == 'corfile': pol_dict[key] = os.path.join(out_folder, '%s_%i_ccf.txt' % (out_label, i)) if key == 'cl_outmap_file': pol_dict[key] = os.path.join( out_folder, '%s_%i_clraw.txt' % (out_label, i)) if key == 'covfileout': pol_dict[key] = os.path.join(out_folder, '%s_%i_cov.fits' % (out_label, i)) if key == 'mapfile': pol_dict[key] = m1_f if key == 'mapfile2': pol_dict[key] = m2_f if key == 'maskfile': pol_dict[key] = fermi_mask_f if key == 'maskfile2': pol_dict[key] = lss_mask_f config_file_name = os.path.join( out_folder, 'pol_config_%s_%i.txt' % (out_label, i)) if lss_wb_ is None: wl = np.sqrt(wb * wpix * wpix) else: # ------- TO BE DEFINED ------ wl = np.sqrt(wb * lss_wb * wpix * wpix) if os.path.exists( os.path.join(out_folder, '%s_%i_cl.txt' % (out_label, i))): logger.info('Retrivnig APS and Covariance matrix ...') _l, _cl, _cl_err = pol_cl_parse( os.path.join(out_folder, '%s_%i_cl.txt' % (out_label, i)), os.path.join(out_folder, '%s_%i_cov.fits' % (out_label, i)), wl_array=wl, rebin=True, lmin=lmin, lmax=lmax, nbin=bin_num, bin_type=bin_alg, custom_bins=bin_custom, show=kwargs['show']) _cov = pol_cov_parse(os.path.join( out_folder, '%s_%i_cov.fits' % (out_label, i)), wl_array=wl, rebin=True, nbin=bin_num, bin_type=bin_alg, lmin=lmin, lmax=lmax, custom_bins=bin_custom, show=kwargs['show']) else: _l, _cl, _cl_err, _cov = pol_cl_calculation(pol_dict, config_file_name, wl_array=wl, rebin=True, nbin=bin_num, bin_type=bin_alg, lmin=lmin, lmax=lmax, custom_bins=bin_custom, show=kwargs['show']) cl_txt.write( 'multipole\t%s\n' % str(list(_l)).replace('[', '').replace(']', '').replace(', ', ' ')) cl_txt.write('Cl\t%s\n' % str(list(_cl)).replace('[', '').replace( ']', '').replace(', ', ' ')) cl_txt.write('Cl_ERR\t%s\n' % str(list(_cl_err)).replace( '[', '').replace(']', '').replace(', ', ' ')) cl_txt.write('COV_FILE ---> %s\n\n\n' % (os.path.join(out_folder, '%s_%i_cov.pkl' % (out_label, i)))) cl_txt.close() logger.info('Created %s' % cl_txt_f)
def foreground_map_convert(**kwargs): """Viewer interface for healpix maps """ input_file = kwargs['infile'] nside_out = kwargs['nsideout'] if not os.path.exists(input_file): abort("Map %s not found!" % input_file) frmaps = pf.open(input_file) maps_slices = frmaps[0].data energy = np.array([x[0] for x in frmaps['ENERGIES'].data]) nside = 2048 npix = hp.nside2npix(nside) iii = np.arange(npix) x, y, z = hp.pix2vec(nside, iii) lon_hp, lat_hp = hp.rotator.vec2dir(x, y, z, lonlat=True) hp_frmap = np.arange(npix, dtype=np.float64) lon_fits = np.arange(len(maps_slices[0][0])) nresx = 360. / len(lon_fits) lon_fits_1 = np.flip(lon_fits[1440:] * nresx - 180, 0) lon_fits = np.append(lon_fits_1, np.flip(lon_fits[:1440] * nresx + 180, 0)) lat_fits = np.arange(len(maps_slices[0])) lat_fits = lat_fits * nresx - 90 fr_e = [] out_list = [] i_start = 8 for i, en in enumerate(energy[i_start:]): i = i + i_start out_name = os.path.basename(input_file).replace( '.fits', '_hp%i_%d.fits' % (nside_out, en)) out_path = os.path.join(X_OUT, 'fits', out_name) if os.path.exists(out_path): logger.info('Running map conversion for energy %.2f MeV...' % en) logger.info('Retrieving %s' % out_path) else: logger.info('Running map conversion for energy %.2f MeV...' % en) frmap = maps_slices[i] fmt = dict(xname='$l$', xunits='deg', yname='$b$', yunits='deg', zname='Flux [cm$^{-2}$s$^{-1}$sr$^{-1}$]') lon, _indexx = np.unique(lon_fits, return_index=True) lat, _indexy = np.unique(lat_fits, return_index=True) frmap = frmap[:, _indexx] frspline = xInterpolatedBivariateSplineLinear( lon, lat, frmap.T, **fmt) for i, pix in enumerate(hp_frmap): hp_frmap[i] = frspline((lon_hp[i] + 360) % 360, lat_hp[i]) fr_e.append(hp_frmap[12426]) hp_frmap_out = hp.pixelfunc.ud_grade(hp_frmap, nside_out, pess=True) if kwargs['coord'] == 'CEL': from Xgam.utils.PolSpice_ import change_coord hp_frmap_out = change_coord(hp_frmap_out, ['G', 'C']) logger.info('Changing coordinate system to celestial') hp.write_map(out_path, hp_frmap_out, coord='G') logger.info('Created map %s' % out_path) out_list.append(out_path) out_name_list = os.path.basename(input_file).replace( '.fits', '_hp%i_list.txt' % nside_out) out_name_list = os.path.join(X_OUT, 'fits', out_name_list) if kwargs['coord'] == 'CEL': out_name_list = out_name_list.replace('GAL', 'CEL') logger.info('Writing list of output files: %s' % out_name_list) np.savetxt(out_name_list, out_list, fmt='%s') if kwargs['show']: import matplotlib.pyplot as plt plt.figure() plt.plot(energy, fr_e, 'o--') plt.xlabel('Energy [MeV]') plt.xscale('log') plt.ylabel('Flux [cm$^{-2}$s$^{-1}$sr$^{-1}$]') plt.show() frmaps.close() logger.info('Done!')
def aps_fit(**kwargs): """ Viewer interface for APS and Covariance matrix """ params = parse_polspice_aps(kwargs['infile']) _emin, _emax = params[0], params[1] _l, _cl, _clerr = params[2], params[3], params[4] _cov_ = params[5] logger.info('Generating APS plots...') for i, cl in enumerate(_cl): valid = ~(np.isnan(cl)) l = _l[i][valid] cl = cl[valid] clerr = _clerr[i][valid] fitrange = np.where((l > int(kwargs['lminfit'])) & (l < int(kwargs['lmaxfit'])))[0] fig = plt.figure() plt.plot([0, 2000], [0, 0], '--', color='silver') aps_label = '%.1f-%.1f GeV' % (_emin[i] / 1000, _emax[i] / 1000) plt.errorbar(l, cl, fmt='o', markersize=5, elinewidth=2, label='Data', color='0.3', yerr=clerr) if kwargs['model'] == '1h': popt, pcov = curve_fit(onehalo_model, l[fitrange], cl[fitrange], sigma=clerr[fitrange], absolute_sigma=True) print('-----------------------') print('Fit range: %i - %i' % (kwargs['lminfit'], kwargs['lmaxfit'])) print('Best-fit Cp = %.2e+-%2e' % (popt[0], np.sqrt(pcov[0][0]))) print('Detection Significance: %.3f' % (popt[0] / np.sqrt(pcov[0][0]))) print('-----------------------') plt.fill_between(l[fitrange], np.full(len(l[fitrange]), popt[0] - np.sqrt(pcov[0][0])), np.full(len(l[fitrange]), popt[0] + np.sqrt(pcov[0][0])), color='lightcoral', alpha=0.5) plt.plot([l[fitrange][0], kwargs['lmaxfit']], [popt[0], popt[0]], '--', color='red', label='C$_{p}$ = %.1e' % popt[0]) else: popt, pcov = curve_fit(twohalo_model, l[fitrange], cl[fitrange], sigma=clerr[fitrange], absolute_sigma=True) chi2 = np.sum(((cl[fitrange] - twohalo_model(l[fitrange], *popt)) / clerr[fitrange])**2) chi2red = chi2 / len(fitrange) print('-----------------------') print('Fit range: %i - %i' % (kwargs['lminfit'], kwargs['lmaxfit'])) print('Best-fit params = %s' % (popt)) print('Chi2red: %.3f' % (chi2red)) print('-----------------------') plt.plot(l[fitrange], twohalo_model(l[fitrange], *popt), '--', color='red', label='Best fit: %.1e $\ell^{-%.1f}$ + (%.1e)' % (popt[0], popt[1], popt[2])) plt.xlim(kwargs['lminfit'] - 10, kwargs['lmaxfit'] + 5) #plt.ylim(-1e-11,1e-11) plt.xscale(kwargs['xscale']) plt.xlabel('Multipole', size=15) plt.ylabel('C$^{sig}_{\ell}$', size=15) #[(cm$^{-2}$s$^{-1}$sr$^{-1}$)sr] plt.title(kwargs['title']) plt.tight_layout() plt.legend(loc=1, fontsize=16) plt.savefig('output/figs/%s_fit_%s.png' % (kwargs['outflabel'], kwargs['model'])) plt.show()
# (at your option) any later version. # # # #------------------------------------------------------------------------------# """Remake of some of the Fermi Science Tools """ import os import time import gt_apps as my_apps from Xgam.utils.logging_ import logger from Xgam import X_OUT from Xgam import FT_DATA_FOLDER FT_DATA_OUT = os.path.join(FT_DATA_FOLDER, 'output') if not os.path.exists(FT_DATA_OUT): logger.info('Creating output folder of selected data (%s)' % FT_DATA_OUT) os.makedirs(os.path.join(FT_DATA_OUT)) def gtselect(label, filter_dict): """ Calls gtselect from Science Tools. Parameters ---------- label: str To automatically set the name of the output file filter_dict: python dict To define all the parameters Returns