Exemplo n.º 1
0
def main():
    # Define basic vars
    maps_dir = '/zfs/bsafdi/data/'
    fermi_data_dir = '/zfs/tslatyer/fermimaps/allsky/'
    work_dir = '/zfs/nrodd/NPTFWorking'
    emin=0
    emax=1
    nside=256
    eventclass=5
    eventtype=3
    newstyle=1
    ps_file = '/zfs/nrodd/NPTFWorking/data/ps_data/ps_lists/3FGL_0to15_tiny.txt'
    n_ps_run=10
    indeg=True

    loadforpsf = fp.fermi_plugin(maps_dir,fermi_data_dir=fermi_data_dir,work_dir=work_dir,CTB_en_min = emin,CTB_en_max=emax,nside=nside,eventclass=eventclass,eventtype=eventtype,newstyle=newstyle)
    loadforpsf.load_psf(data_name='p8',fits_file_path = 'False',eventclass=eventclass,eventtype=eventtype)
    sigma_PSF_deg = loadforpsf.sigma_PSF_deg[0:-1]

    #print "exp map:",loadforpsf.CTB_exposure_maps
    #print "len(loadforpsf.CTB_exposure_maps)",len(loadforpsf.CTB_exposure_maps)
    #print "len(loadforpsf.CTB_exposure_maps[0])",len(loadforpsf.CTB_exposure_maps[0])
    #print "mean(loadforpsf.CTB_exposure_maps[0])",np.mean(loadforpsf.CTB_exposure_maps[0])
    #print "sum(loadforpsf.CTB_exposure_maps[0])",np.sum(loadforpsf.CTB_exposure_maps[0],axis=0)

    #print "PSF_deg:",sigma_PSF_deg

    larr,barr,n_ps,n_ps_border = trimorderpslist(ps_file,indeg,sigma_PSF_deg)
    
    #print "n_ps:",n_ps
    #print "n_ps_border:",n_ps_border
    #print "l:",larr*180/np.pi
    #print "b:",barr*180/np.pi

    ps_norms=np.array([1,1,1,1])
    loadforpsf.add_multiple_ps_king(larr,barr,rescale=ps_norms,comp='ps_comb')

    print "MADE IT OUT"

    n_groups = int(np.ceil(float(n_ps+n_ps_border)/float(n_ps_run)))
    n_last_group = n_ps - (n_groups-1)*n_ps_run
Exemplo n.º 2
0
    def setup_fermi(self):
        """ Setup the Fermi plugin """
        eventclass=5 # 2 (Source) or 5 (UltracleanVeto)
        eventtype=0 # 0 (all), 3 (bestpsf) or 5 (top3 quartiles)
        mask_type='top300'
        force_mask_at_bin_number=8

        self.f1 = fp.fermi_plugin(maps_dir,fermi_data_dir=fermi_data_dir,work_dir=work_dir,CTB_en_min=0,CTB_en_max=40,nside=self.nside,eventclass=eventclass,eventtype=eventtype,newstyle=1,data_July16=True)

        if mask_type != 'False':
            self.f1.make_ps_mask(mask_type = mask_type,force_energy = True,energy_bin = force_mask_at_bin_number)
        self.f1.add_diffuse_newstyle(comp = 'p7', eventclass = eventclass, eventtype = eventtype)
        self.f1.add_bubbles(comp='bubs') #bubbles
        self.f1.add_iso(comp='iso')  #iso
        self.f1.add_ps_model(comp='ps_model')

        # Exposure correct J_map_arr
        self.J_map_arr *= self.f1.CTB_exposure_maps

        # Add J-factor map with mean 1 in each energy bin
        self.f1.add_template_by_hand('J_map',np.array([self.J_map_arr[i]/np.mean(self.J_map_arr[i]) for i in range(40)]))
Exemplo n.º 3
0
def setup_for_scan():
    global f, b, new_template_dict, n_ps, newstyle
    # Load Fermi Plugin and its basic functionality
    f = fp.fermi_plugin(maps_dir,fermi_data_dir=fermi_data_dir,work_dir=work_dir,CTB_en_min = emin,CTB_en_max=emax,nside=nside,eventclass=eventclass,eventtype=eventtype,newstyle=newstyle)

    if mask_type!='False':
        f.make_ps_mask(mask_type=mask_type,force_energy=force_ps_mask,energy_bin=force_ps_mask_bin)
    # Add appropriate templates
    f.add_diffuse_newstyle(comp = diff, eventclass = eventclass, eventtype = eventtype)
    if extraicstemp!='False':
        f.add_diffuse_newstyle(comp = extraicstemp, eventclass = eventclass, eventtype = eventtype)
    f.add_bubbles(comp = 'bubs')
    f.add_iso(comp = 'iso')
    if add_ps_model:
        f.add_ps_model(comp = 'ps_model')
    if nfw_dm:
        f.add_nfw(comp = 'nfw')
    f.add_template_from_file('disk',disk_file_name) # always add the disk here even if don't use as often needed for NPTF
    if norm_file!='False':
        if len(add_norm_file_for_comps) > 0 and add_norm_file != 'False':
            print 'using first normalization file: ', norm_file
            f.use_template_normalization_file(norm_file,key_suffix='-0',dont_use_keys=add_norm_file_for_comps)
            print 'using second normalization file: ', add_norm_file
            f.use_template_normalization_file(add_norm_file,key_suffix='-0',use_keys=add_norm_file_for_comps)
        else:
            f.use_template_normalization_file(norm_file,key_suffix='-0')

    #### For now, combine diff, bubs, iso, ps_model, IC to reduce number of parameters
    new_template_dict = {}
    new_template_dict['back']=np.zeros(np.shape(f.template_dict['bubs']))
    for key in f.template_dict.keys():
        new_template_dict[key] = f.template_dict[key]
        if key not in not_in_simplified_template_list: #key != 'nfw' and key != 'disk' and
            print 'Including template', key, 'in background template'
            new_template_dict['back']+=f.template_dict[key]
        # else:
        #     new_template_dict[key] = f.template_dict[key]

    # Load PSF - this is only required for NPTF scans
    # This now uses a King function
    if not poiss:
        f.load_psf_kings()
        f.make_f_ary_kings(psf_model,energy_averaged=True,psf_dir=psf_dir,psf_save_tag=run_tag_energy)
    # Setup Bayesian scan for fermi
    b = bsm.bayesian_scan_NPTF(tag=tag,work_dir = work_dir,psf_dir = psf_dir,nside=nside,nlive=nlive,k_max=k_max)
    if fake_data:
        data = np.loadtxt(fake_data_path)
    else:
        data = f.CTB_count_maps

    b.load_external_data(f.CTB_en_bins,data,f.CTB_exposure_maps)
    if use_simplified_templates:
        b.add_new_template(new_template_dict)
        if fixed_background:
            b.add_fixed_templates({'back':new_template_dict['back']})
    else:
        b.add_new_template(f.template_dict)
    if mask_type!='False':
        b.make_mask_total(plane_mask=plane_mask, band_mask_range = [-pmval,pmval], lcut=lcut, lmin=lmin, lmax=lmax, bcut=bcut, bmin=bmin, bmax=bmax, mask_ring=mask_ring, inner=inner, outer=outer, ps_mask_array = f.ps_mask_array)
    else:
        b.make_mask_total(plane_mask=plane_mask, band_mask_range = [-pmval,pmval], lcut=lcut, lmin=lmin, lmax=lmax, bcut=bcut, bmin=bmin, bmax=bmax, mask_ring=mask_ring, inner=inner, outer=outer)
    b.rebin_external_data(n_ebins)
    b.compress_templates()

    ### Add in the Templates
    if method != 'minuit':
        if not min_prior_range:
            b.add_poiss_model(diff,'$A_{diff}$',[-10,10],False)
            if extraicstemp!='False':
                b.add_poiss_model(extraicstemp,'$A_{ics}$',[-10,10],False)
            b.add_poiss_model('iso','$A_{iso}$',[-10,10],False)
            b.add_poiss_model('bubs','$A_{bubs}$',[-10,10],False)
        else: # If already have priors, don't scan over such a large range
            b.add_poiss_model(diff,'$A_{diff}$',[0.5,1.5],False)
            if extraicstemp!='False':
                b.add_poiss_model(extraicstemp,'$A_{ics}$',[0.5,1.5],False)
            if high_lat:
                b.add_poiss_model('iso','$A_{iso}$',[0.5,1.5],False)
            else:
                b.add_poiss_model('iso','$A_{iso}$',[0.8,1.2],False)
            b.add_poiss_model('bubs','$A_{bubs}$',[0.5,1.5],False)
    else:
        b.add_poiss_model(diff,'$A_{diff}$',[0,2],False)
        if extraicstemp!='False':
            b.add_poiss_model(extraicstemp,'$A_{ics}$',[-2,2],False)
        b.add_poiss_model('iso','$A_{iso}$',[0,2],False)
        b.add_poiss_model('bubs','$A_{bubs}$',[0,4],False)
    if add_ps_model:
        if not min_prior_range:
            b.add_poiss_model('ps_model','$A_{ps-model}$',[0,6],False)
        else:
            b.add_poiss_model('ps_model','$A_{ps-model}$',[0.5,1.5],False)
    if nfw_dm: # leave this large as NFW struggles to converge at high E
        b.add_poiss_model('nfw','$l10A_{nfw}$',[-6,6],True)

    ### Configure final details
    def sb_string_mod(mod):
        return ['${S_b^{' + mod + '}}^{'+str(i) + '}$' for i in range(n_ebins)]

    if not poiss:
        sb_string = ['$S_b^{'+str(i) + '}$' for i in range(n_ebins)]
        sb_string_disk = ['${S_b^{disk}}^{'+str(i) + '}$' for i in range(n_ebins)]
        sb_prior = [ [-3.,3.] for i in range(n_ebins)]
        sb_prior_log = [True for i in range(n_ebins)]
        if len(ps_fixed_filename_list) > 0:
            for comp,filename in map(None,ps_fixed_list,ps_fixed_filename_list):
                b.load_fixed_ps_model(filename,comp)
            n_ps += len(ps_fixed_filename_list)
            print 'n_ps changed to ', n_ps, ' because of fixed templates'

        for mod in ps_list:
            b.add_non_poiss_model(mod,['$A_{' +mod+'}$' ,'$n_1^{' +mod+'}$','$n_2^{' +mod+'}$']+sb_string_mod(mod),[[-6,6],[2.05,30],[-2,1.95]] + sb_prior, [True,False,False] + sb_prior_log)
        if n_ps==1:
            b.initiate_1_ps_edep_new_from_f_ary(f.f_ary_list,f.df_rho_div_f_ary_list)
        elif n_ps==2:
            b.initiate_2_ps_edep_new_from_f_ary(f.f_ary_list,f.df_rho_div_f_ary_list)
        elif n_ps==3:
            b.initiate_3_ps_edep_new_from_f_ary(f.f_ary_list,f.df_rho_div_f_ary_list)

        print 'Performing an NPTF ...'
    else:
        b.initiate_poissonian_edep()
        print 'Performing a standard template fit ...'
Exemplo n.º 4
0
import argparse

nsim = 100
outstring = 'allhalos'

nside = 128
eventclass = 5  # 2 (Source) or 5 (UltracleanVeto)
eventtype = 0  # 0 (all), 3 (bestpsf) or 5 (top3 quartiles)
emin_bin = 0
emax_bin = 40  # Must match the norm file!

f_global = fp.fermi_plugin(maps_dir,
                           fermi_data_dir=fermi_data_dir,
                           work_dir=work_dir,
                           CTB_en_min=emin_bin,
                           CTB_en_max=emax_bin,
                           nside=nside,
                           eventclass=eventclass,
                           eventtype=eventtype,
                           newstyle=1,
                           data_July16=True)

# Set up J_map
J_map = hp.ud_grade(np.load(
    '/tigress/smsharma/public/GenMaps/GenMapsJumpAround/Jfactor_DS_true_map_100.0_100.0_100.0b2e+20_a3.16e+17.npy'
),
                    nside,
                    power=-2)
J_map /= GeV**2 * Centimeter**-5

# Exposure correct then smooth J_map latter must be done first
J_map_arr_ps = np.zeros(shape=(emax_bin - emin_bin, len(J_map)))
Exemplo n.º 5
0
    def scan(self):

        ################
        # Fermi plugin #
        ################

        # Load the Fermi plugin - always load all energy bins, extract what is needed
        f_global = fp.fermi_plugin(maps_dir,
                                   fermi_data_dir=fermi_data_dir,
                                   work_dir=work_dir,
                                   CTB_en_min=0,
                                   CTB_en_max=40,
                                   nside=self.nside,
                                   eventclass=self.eventclass,
                                   eventtype=self.eventtype,
                                   newstyle=1,
                                   data_July16=True)

        # Load necessary templates
        f_global.add_diffuse_newstyle(comp=self.diff,
                                      eventclass=self.eventclass,
                                      eventtype=self.eventtype)
        f_global.add_iso()
        ps_temp = np.load(work_dir + '/DataFiles/PS-Maps/ps_map.npy')
        f_global.add_template_by_hand(comp='ps_model', template=ps_temp)

        ###################
        # Get DM halo map #
        ###################

        l = self.catalog.l.values[self.iobj]
        b = self.catalog.b.values[self.iobj]

        rs = self.catalog.rs.values[self.iobj] * 1e-3
        if self.boost:
            J0 = 10**self.catalog.mulog10J_inf.values[self.iobj]
        else:
            J0 = 10**self.catalog.mulog10Jnb_inf.values[self.iobj]
        mk = mkDMMaps.mkDMMaps(z=self.catalog.z[self.iobj],
                               r_s=rs,
                               J_0=J0,
                               ell=l * np.pi / 180,
                               b=b * np.pi / 180,
                               nside=self.nside,
                               use_boost=self.use_boost,
                               Burkert=self.Burkert)
        DM_template_base = mk.map

        #########################################
        # Loop over energy bins to get spectrum #
        #########################################

        # ROI where we will normalise our templates
        ROI_mask = cm.make_mask_total(mask_ring=True,
                                      inner=0,
                                      outer=10,
                                      ring_b=b,
                                      ring_l=l)
        ROI = np.where(ROI_mask == 0)[0]

        # Setup output
        output_cube = np.zeros((self.emax + 1 - self.emin, 5, len(ROI)))

        for iebin, ebin in tqdm(enumerate(np.arange(self.emin, self.emax + 1)),
                                disable=1 - self.verbose):

            ######################
            # Templates and maps #
            ######################

            if self.verbose:
                print "At bin", ebin

            fermi_exposure = f_global.CTB_exposure_maps[ebin]

            DM_template = DM_template_base * fermi_exposure / np.sum(
                DM_template_base * fermi_exposure)
            ksi = ks.king_smooth(maps_dir,
                                 ebin,
                                 self.eventclass,
                                 self.eventtype,
                                 threads=1)
            DM_template_smoothed = ksi.smooth_the_map(DM_template)
            DM_intensity_base = np.sum(DM_template_smoothed / fermi_exposure)

            dif = f_global.template_dict[self.diff][ebin]
            iso = f_global.template_dict['iso'][ebin]
            psc = f_global.template_dict['ps_model'][ebin]

            output_cube[iebin, 0] = ROI
            output_cube[iebin, 1] = dif[ROI]
            output_cube[iebin, 2] = iso[ROI]
            output_cube[iebin, 3] = psc[ROI]
            output_cube[iebin, 4] = DM_template_smoothed[ROI]

        np.save(self.save_dir + 'cube_o' + str(self.iobj) + self.mc_tag,
                output_cube)
Exemplo n.º 6
0
def main():

    keyfile = 'nptf/IG_NDI/FD_key_1.txt.gz' 
    jetbase = '/tigress/nrodd/FindPSOutput/psdata_2-12-15-m5-b1_roi/psdata_2-12-15-m5-b1_roi_ca_PT_R0p'
    jetfiles = [jetbase+'15.txt.gz',jetbase+'2.txt.gz',jetbase+'25.txt.gz',jetbase+'3.txt.gz',jetbase+'4.txt.gz',jetbase+'5.txt.gz',jetbase+'6.txt.gz',jetbase+'7.txt.gz',jetbase+'8.txt.gz',jetbase+'9.txt.gz']
    jetlabel = ['Jet R0p15','Jet R0p2','Jet R0p25','Jet R0p3','Jet R0p4','Jet R0p5','Jet R0p6','Jet R0p7','Jet R0p8','Jet R0p9']
    jetrad = [0.15,0.2,0.25,0.3,0.4,0.5,0.6,0.7,0.8,0.9]

    outname = '2-12-15-m5_b1'

    fake_data_key_path = '/tigress/nrodd/NPTFWorking/FindPS/plots/' + keyfile

    CTB_start_bin=8
    CTB_end_bin=16
    nside=512
    data_type='p8'
    npix = hp.nside2npix(nside)
    theta, phi = hp.pix2ang(nside,range(npix))
    larr_full = phi*180/np.pi
    larr_full = ((larr_full + 180) % 360)-180
    larr_full *= np.pi/180
    barr_full = np.pi/2 - theta

    band_mask_range_plot = [-1,1]
    mask_ring_plot = True
    outer_plot = 10

    f = fp.fermi_plugin(maps_dir,CTB_en_min=CTB_start_bin,CTB_en_max=CTB_end_bin,nside=nside,data_name=data_type)

    # Now calculate dndF from the sim key
    fake_data_key_load = np.loadtxt(fake_data_key_path)
    fake_data_key = np.zeros(shape=(len(fake_data_key_load),10))
    fake_data_key[::,0:2] = fake_data_key_load[::,0:2]
    fake_data_key[::,2:10] = fake_data_key_load[::,CTB_start_bin+2:CTB_end_bin+2]

    # Now pick out point sources within the ROI we want to analyse
    # NB: cuts in degrees, larr and barr in radians
    pmfocus=3
    ringfocus=10

    barr = np.pi/2-fake_data_key[::,0]
    larr = fake_data_key[::,1]*180/np.pi
    larr = ((larr + 180) % 360)-180
    larr *= np.pi/180
    print np.min(larr)*180/np.pi
    print np.max(larr)*180/np.pi
    print np.min(barr)*180/np.pi
    print np.max(barr)*180/np.pi
    thetaarr = np.arccos(np.cos(larr)*np.cos(barr))
    print np.min(thetaarr)*180/np.pi
    print np.max(thetaarr)*180/np.pi
    roi = np.where((np.abs(barr) > pmfocus*np.pi/180) & (thetaarr < ringfocus*np.pi/180))[0]
    bigroi = np.where((np.abs(barr) > (pmfocus-0.9)*np.pi/180) & (thetaarr < (ringfocus+0.9)*np.pi/180))[0]
    fake_data_keyroi = fake_data_key[roi,::]
    key_bigroi = fake_data_key[bigroi,::]
    larr_key = larr[bigroi]
    barr_key = barr[bigroi]
    print np.min(thetaarr[roi])*180/np.pi
    print np.max(thetaarr[roi])*180/np.pi
    print np.min(barr[roi])*180/np.pi
    print np.min(thetaarr[bigroi])*180/np.pi
    print np.max(thetaarr[bigroi])*180/np.pi
    print np.min(barr[bigroi])*180/np.pi

    #np.load('FAKE')

    print "len(roi):",len(roi)
    print "len(bigroi):",len(bigroi)

    pfake3FGL = make_flux_histogram_local(fake_data_keyroi,f.CTB_exposure_maps,band_mask_range = band_mask_range_plot, mask_ring = mask_ring_plot, outer = outer_plot)
    pfake3FGL.make_fake_data_flux_histogram(0.1,5000,10)
    pfake3FGL.plot_fake_data_histogram(fmt = 'o', color='black',markersize=5,label='Sim PS')

    # Now read in Jet data and create dndF plots from that
    # First load the data and background model as we need these

    jetcolors = ['red','orange','yellow','olive','green','blue','indigo','violet','deeppink','pink']
    # Loop through the files
    #for i in range(10):
    for i in range(1):
        print "At i =",i
        jetload = np.loadtxt(jetfiles[i])
        # extract (l,b) from array
        larr = jetload[::,0]
        phi = larr*180/np.pi
        larr *= 180/np.pi
        larr = ((larr + 180) % 360)-180
        larr *= np.pi/180
        barr = jetload[::,1]
        theta = np.pi/2-barr
        print np.min(larr)*180/np.pi
        print np.max(larr)*180/np.pi
        print np.min(larr_key)*180/np.pi
        print np.max(larr_key)*180/np.pi
        print np.min(barr)*180/np.pi
        print np.max(barr)*180/np.pi
        print np.min(barr_key)*180/np.pi
        print np.max(barr_key)*180/np.pi
        # Determine which are in the ROI
        thetaarr = np.arccos(np.cos(larr)*np.cos(barr))
        roi = np.where((np.abs(barr) > pmfocus*np.pi/180) & (thetaarr < ringfocus*np.pi/180))[0]
        # Now build up the key for each ps in the ROI
        jet_data_key = np.zeros(shape=(len(roi),10))
        #print "len(larr):",len(larr)
        #print "len(larr_key):",len(larr_key)
        #print "len(roi):",len(roi)
        count=0
        for j in range(len(roi)):
            print "j =",j
            # First put theta and phi in
            jet_data_key[j,0] = theta[roi[j]]
            jet_data_key[j,1] = phi[roi[j]]
            # Now input the counts - determine this by adding counts for sim PS within jetrad
            thetaps = np.arccos(np.cos(larr[roi[j]]-larr_key)*np.cos(barr[roi[j]]-barr_key))
            print np.min(thetaps)*180/np.pi
            print np.max(thetaps)*180/np.pi
            print len(thetaps)
            if j==20:
                np.load('Fake')
            pstoadd = np.where(thetaps <= jetrad[i]*np.pi/180)[0]
            #print "len(pstoadd)",len(pstoadd)
            if len(pstoadd) > 0:
                count += 1
                print "count =",count
            for k in range(8):
                for m in range(len(pstoadd)):
                    print "key_bigroi[pstoadd[m],k+2]=",key_bigroi[pstoadd[m],k+2]
                    jet_data_key[j,k+2] += key_bigroi[pstoadd[m],k+2]
        print "count:",count
        # Now plot
        pfake3FGL = make_flux_histogram_local(jet_data_key,f.CTB_exposure_maps,band_mask_range = band_mask_range_plot, mask_ring = mask_ring_plot, outer = outer_plot)
        pfake3FGL.make_fake_data_flux_histogram(0.1,5000,10)
        pfake3FGL.plot_fake_data_histogram(fmt = 'o', color=jetcolors[i],markersize=5,label=jetlabel[i])

    plt.yscale('log')
    plt.xscale('log')
    plt.xlim([1e-12,1e-6])
    plt.ylim([1e3,1e11])

    plt.tick_params(axis='x', length=5,width=2,labelsize=18)
    plt.tick_params(axis='y',length=5,width=2,labelsize=18)
    plt.xlabel('$F$  [photons / cm$^2$ / s]', fontsize=18)
    plt.ylabel('$dN/dF$  [photons$^{-1}$ cm$^2$ s deg$^{-2}$]', fontsize=18)

    plt.legend(fontsize=16)

    plt.savefig('./Plots/' + outname + '.pdf')

    plt.close()
Exemplo n.º 7
0
    def scan(self):

        ################
        # Fermi plugin #
        ################

        # Load the Fermi plugin - always load all energy bins, extract what is needed
        f_global = fp.fermi_plugin(maps_dir,
                                   fermi_data_dir=fermi_data_dir,
                                   work_dir=work_dir,
                                   CTB_en_min=0,
                                   CTB_en_max=40,
                                   nside=self.nside,
                                   eventclass=self.eventclass,
                                   eventtype=self.eventtype,
                                   newstyle=1,
                                   data_July16=True)

        # Load necessary templates
        f_global.add_diffuse_newstyle(comp=self.diff,
                                      eventclass=self.eventclass,
                                      eventtype=self.eventtype)
        f_global.add_iso()
        ps_temp = np.load(work_dir + '/DataFiles/PS-Maps/ps_map.npy')
        f_global.add_template_by_hand(comp='ps_model', template=ps_temp)

        ###################
        # Get DM halo map #
        ###################

        l = self.catalog.l.values[self.iobj]
        b = self.catalog.b.values[self.iobj]

        rs = self.catalog.rs.values[self.iobj] * 1e-3
        if self.boost:
            J0 = 10**self.catalog.mulog10J_inf.values[self.iobj]
        else:
            J0 = 10**self.catalog.mulog10Jnb_inf.values[self.iobj]
        mk = mkDMMaps.mkDMMaps(z=self.catalog.z[self.iobj],
                               r_s=rs,
                               J_0=J0,
                               ell=l * np.pi / 180,
                               b=b * np.pi / 180,
                               nside=self.nside,
                               use_boost=self.use_boost,
                               Burkert=self.Burkert)
        DM_template_base = mk.map

        #########################################
        # Loop over energy bins to get spectrum #
        #########################################

        # 10 deg mask for the analysis
        analysis_mask_base = cm.make_mask_total(mask_ring=True,
                                                inner=0,
                                                outer=10,
                                                ring_b=b,
                                                ring_l=l)

        # ROI where we will normalise our templates
        ROI_mask = cm.make_mask_total(mask_ring=True,
                                      inner=0,
                                      outer=2,
                                      ring_b=b,
                                      ring_l=l)
        ROI = np.where(ROI_mask == 0)[0]

        # Setup output
        output_norms = np.zeros((self.emax + 1 - self.emin, 4, 2))

        for iebin, ebin in tqdm(enumerate(np.arange(self.emin, self.emax + 1)),
                                disable=1 - self.verbose):

            ######################
            # Templates and maps #
            ######################

            if self.verbose:
                print "At bin", ebin

            data = f_global.CTB_count_maps[ebin].astype(np.float64)
            # Add large scale mask to analysis mask
            els_str = [
                '0.20000000', '0.25178508', '0.31697864', '0.39905246',
                '0.50237729', '0.63245553', '0.79621434', '1.0023745',
                '1.2619147', '1.5886565', '2.0000000', '2.5178508',
                '3.1697864', '3.9905246', '5.0237729', '6.3245553',
                '7.9621434', '10.023745', '12.619147', '15.886565',
                '20.000000', '25.178508', '31.697864', '39.905246',
                '50.237729', '63.245553', '79.621434', '100.23745',
                '126.19147', '158.86565', '200.00000', '251.78508',
                '316.97864', '399.05246', '502.37729', '632.45553',
                '796.21434', '1002.3745', '1261.9147', '1588.6565'
            ]
            ls_mask_load = fits.open(
                '/tigress/nrodd/LargeObjMask/Allpscmask_3FGL-energy' +
                els_str[ebin] + 'large-obj.fits')
            ls_mask = np.array([
                np.round(val) for val in hp.ud_grade(
                    ls_mask_load[0].data, self.nside, power=0)
            ])
            analysis_mask = np.vectorize(bool)(analysis_mask_base + ls_mask)

            fermi_exposure = f_global.CTB_exposure_maps[ebin]

            DM_template = DM_template_base * fermi_exposure / np.sum(
                DM_template_base * fermi_exposure)
            ksi = ks.king_smooth(maps_dir,
                                 ebin,
                                 self.eventclass,
                                 self.eventtype,
                                 threads=1)
            DM_template_smoothed = ksi.smooth_the_map(DM_template)
            DM_intensity_base = np.sum(DM_template_smoothed / fermi_exposure)

            dif = f_global.template_dict[self.diff][ebin]
            iso = f_global.template_dict['iso'][ebin]
            psc = f_global.template_dict['ps_model'][ebin]

            # Get mean values in ROI
            dif_mu = np.mean(dif[ROI])
            iso_mu = np.mean(iso[ROI])
            psc_mu = np.mean(psc[ROI])
            DM_mu = np.mean(DM_template_smoothed[ROI])
            exp_mu = np.mean(fermi_exposure[ROI])

            ####################
            # NPTFit norm scan #
            ####################

            n = nptfit.NPTF(tag='norm_o' + str(self.iobj) + '_E' + str(ebin) +
                            self.mc_tag)
            n.load_data(data, fermi_exposure)

            n.load_mask(analysis_mask)

            n.add_template(dif, self.diff)
            n.add_template(iso, 'iso')
            n.add_template(psc, 'psc')
            n.add_template(DM_template_smoothed, 'DM')

            n.add_poiss_model(self.diff, '$A_\mathrm{dif}$', [0, 10], False)
            n.add_poiss_model('iso', '$A_\mathrm{iso}$', [0, 20], False)
            n.add_poiss_model('psc', '$A_\mathrm{psc}$', [0, 10], False)
            n.add_poiss_model('DM', '$A_\mathrm{DM}$', [0, 1000], False)

            n.configure_for_scan()

            ##########
            # Minuit #
            ##########

            keys = n.poiss_model_keys
            limit_dict = {}
            init_val_dict = {}
            step_size_dict = {}
            for key in keys:
                if key == 'DM':
                    limit_dict['limit_' + key] = (0, 1000)
                else:
                    limit_dict['limit_' + key] = (0, 50)
                init_val_dict[key] = 0.0
                step_size_dict['error_' + key] = 1.0
            other_kwargs = {'print_level': self.verbose, 'errordef': 1}
            z = limit_dict.copy()
            z.update(other_kwargs)
            z.update(limit_dict)
            z.update(init_val_dict)
            z.update(step_size_dict)
            f = call_ll(len(keys), n.ll, keys)
            m = Minuit(f, **z)
            m.migrad(ncall=30000, precision=1e-14)

            # Output spectra in E^2 dN/dE, in units [GeV/cm^2/s/sr] as mean in 2 degrees
            output_norms[iebin, 0, 0] = m.values[
                'p8'] * dif_mu / exp_mu * self.emid[iebin]**2 / self.de[iebin]
            output_norms[iebin, 0, 1] = m.errors[
                'p8'] * dif_mu / exp_mu * self.emid[iebin]**2 / self.de[iebin]

            output_norms[iebin, 1, 0] = m.values[
                'iso'] * iso_mu / exp_mu * self.emid[iebin]**2 / self.de[iebin]
            output_norms[iebin, 1, 1] = m.errors[
                'iso'] * iso_mu / exp_mu * self.emid[iebin]**2 / self.de[iebin]

            output_norms[iebin, 2, 0] = m.values[
                'psc'] * psc_mu / exp_mu * self.emid[iebin]**2 / self.de[iebin]
            output_norms[iebin, 2, 1] = m.errors[
                'psc'] * psc_mu / exp_mu * self.emid[iebin]**2 / self.de[iebin]

            output_norms[iebin, 3, 0] = m.values[
                'DM'] * DM_mu / exp_mu * self.emid[iebin]**2 / self.de[iebin]
            output_norms[iebin, 3, 1] = m.errors[
                'DM'] * DM_mu / exp_mu * self.emid[iebin]**2 / self.de[iebin]

            ###################################
            # NPTFit fixed DM and bkg profile #
            ###################################

            # Make background sum and initiate second scan
            # If was no data leave bkg_sum as 0
            bkg_sum = np.zeros(len(data))
            if np.sum(data * np.logical_not(analysis_mask)) != 0:
                for key in keys:
                    if key != 'DM':  # Don't add DM in here
                        if m.values[key] != 0:
                            bkg_sum += n.templates_dict[key] * m.values[key]
                        else:  # If zero, use ~parabolic error
                            bkg_sum += n.templates_dict[key] * m.errors[
                                key] / 2.

            nDM = nptfit.NPTF(tag='dm_o' + str(self.iobj) + '_E' + str(ebin) +
                              self.mc_tag)
            nDM.load_data(data, fermi_exposure)
            nDM.add_template(bkg_sum, 'bkg_sum')

            # If there is no data, only go over pixels where DM is non-zero
            if np.sum(data * np.logical_not(analysis_mask)) != 0:
                nDM.load_mask(analysis_mask)
            else:
                nodata_mask = DM_template_smoothed == 0
                nDM.load_mask(nodata_mask)
            nDM.add_poiss_model('bkg_sum',
                                '$A_\mathrm{bkg}$',
                                fixed=True,
                                fixed_norm=1.0)

        np.save(self.save_dir + 'spec_o' + str(self.iobj) + self.mc_tag,
                output_norms)
Exemplo n.º 8
0
n_flux_bins=15
error_range=0.68 #for plotting uncertanties



######disk filename
disk_file_name=  'thindiskmodel_ec.fits' #'simplediskmodel_ec.fits'


####################
##########Internal code


###################
##Fermi plugin instance
f = fp.fermi_plugin(maps_dir,fermi_data_dir=fermi_data_dir,work_dir=work_dir,CTB_en_min=CTB_start_bin,CTB_en_max=CTB_end_bin+1,nside=nside,eventclass=eventclass,eventtype=eventtype,newstyle=newstyle)

#f.make_ps_mask(mask_type = mask_type,energy_bin = energy_bin_mask,force_energy=force_energy)

f.add_diffuse_newstyle(comp = 'p6', eventclass = eventclass, eventtype = eventtype)
f.add_bubbles() #bubbles
f.add_iso()  #iso
f.add_nfw()  #NFW-DM
f.add_template_from_file('disk',disk_file_name) #we will call template 'disk'

if mask_type != 'False':
    f.make_ps_mask(mask_type = mask_type,energy_bin = energy_bin_mask,force_energy=force_energy)


f.use_template_normalization_file(norm_file_path,key_suffix='-0')
Exemplo n.º 9
0
def main():
    global plot_ll_profile, eachps_dict, eachts_dict, eachps_En_center, TSbkg, TS, ps_norms_loop1, ps_norms

    # Determine PSF using fermi plugin, for use in the ps ordering
    loadforpsf = fp.fermi_plugin(maps_dir,fermi_data_dir=fermi_data_dir,work_dir=work_dir,CTB_en_min = emin,CTB_en_max=emax,nside=nside,eventclass=eventclass,eventtype=eventtype,newstyle=newstyle)
    loadforpsf.load_psf(data_name='p8',fits_file_path = 'False')
    sigma_PSF_deg = loadforpsf.sigma_PSF_deg[0:-1]
    
    # Get an ordered list of the l and b values by ranking - cutting those outside of region
    # End of list contains those sources outside region but within 1 PSF of the border
    larr,barr,n_ps,n_ps_border = trimorderpslist(ps_file,indeg,sigma_PSF_deg)
    n_groups = int(np.ceil(float(n_ps+n_ps_border)/float(n_ps_run)))
    n_last_group = n_ps+n_ps_border - (n_groups-1)*n_ps_run

    # Establish array of norms for the point sources - starting at 1 and adjusted throughout the run
    ps_norms_loop1 = np.ones(n_ps+n_ps_border)
    ps_norms = np.ones(n_ps)

    # The strategy from here is as follows:
    #   Break the point source lists up into groups of n_ps_run, in order of ranking
    #   For each group we float each point source individually and extract its normalisation
    #   Next we create a template combining each of the point sources just fitted
    #   This is done at the analysis step
    #   Then we repeat this for the next group, but add in a template of all the point sources
    #   already run, and repeat this process till all point sources have been run
    #   After this we perform a run with the full ps map to get its spectrum
    #   Then we rerun each ps one by one to get its TS while fixing the rest

    print 'Determining initial value for each point source...'
    for i in range(n_groups):
        if i+1 == n_groups:
            n_ps_groupi = n_last_group
        else:
            n_ps_groupi = n_ps_run

        # Setup for scan
        if method=='minuit' and run==False:
            pass
        else:
            print 'setting up the scan.  the method is', method
            setup_for_scan(i=i,n_ps_groupi=n_ps_groupi,larr=larr,barr=barr,
                           psloop1=True)
            print 'finished setting up the scan.'

        # Perform scan / load scan
        if run:
            print 'The nside for this scan is ', b.nside
            if method=='multinest':
                b.perform_scan(run_tag = run_tag_energy)
                do_analysis(i=i,n_ps_groupi=n_ps_groupi,minuit_new=False,psloop1=True)
            elif method=='minuit':
                b.perform_scan_minuit(run_tag = run_tag_energy)
                b.save_minuit()
                do_analysis(i=i,n_ps_groupi=n_ps_groupi,minuit_new=True,psloop1=True)

    # Now perform run to extract to spectrum of all point sources combined
    print 'Determining spectrum of combined point source template...'
    # Setup for scan
    if method=='minuit' and run==False:
        pass
    else:
        print 'setting up the scan.  the method is', method
        setup_for_scan(larr=larr,barr=barr,pscomball=True)
        print 'finished setting up the scan.'

    # Perform scan / load scan
    if run:
        print 'The nside for this scan is ', b.nside
        if method=='multinest':
            b.perform_scan(run_tag = run_tag_energy)
            do_analysis(pscomball=True,minuit_new=False)
        elif method=='minuit':
            b.perform_scan_minuit(run_tag = run_tag_energy)
            b.save_minuit()
            do_analysis(pscomball=True,minuit_new=True)

    # Now loop over all point sources, floating one at a time with the others fixed
    print 'Calculating spectrum and significance of each point source in ROI...'
    # From this we want to extract their TS and spectrum

    # Initialise empty dictionary to put the spectra in
    eachps_dict = {}
    eachts_dict = {}

    # Now run through loop - need to do this twice for each, once with and once without the point source, in order to determine the TS
    for i in range(n_ps):
        TSbkg=0.
        TS=0.
        # Setup for scan
        if method=='minuit' and run==False:
            pass
        else:
            print 'setting up the scan.  the method is', method
            setup_for_scan(i=i,larr=larr,barr=barr,psloop2bkg=True)
            print 'finished setting up the scan.'

        # Perform scan / load scan
        if run:
            print 'The nside for this scan is ', b.nside
            if method=='multinest':
                b.perform_scan(run_tag = run_tag_energy)
                do_analysis(i=i,minuit_new=False,psloop2bkg=True)
            elif method=='minuit':
                b.perform_scan_minuit(run_tag = run_tag_energy)
                b.save_minuit()
                print "MINUIT doesn't currently save TS - need to add this in if want minuit"
                do_analysis(i=i,minuit_new=True,psloop2bkg=True)
        # Setup for scan
        if method=='minuit' and run==False:
            pass
        else:
            print 'setting up the scan.  the method is', method
            setup_for_scan(i=i,larr=larr,barr=barr,psloop2=True)
            print 'finished setting up the scan.'

        # Perform scan / load scan
        if run:
            print 'The nside for this scan is ', b.nside
            if method=='multinest':
                b.perform_scan(run_tag = run_tag_energy)
                do_analysis(i=i,minuit_new=False,psloop2=True)
            elif method=='minuit':
                b.perform_scan_minuit(run_tag = run_tag_energy)
                b.save_minuit()
                print "MINUIT doesn't currently save TS - need to add this in if want minuit"
                do_analysis(i=i,minuit_new=True,psloop2=True)

    # Finally save the spectra, norm and ts details
    # Create norm dictionary and a dictionary where we convert this to a spectrum
    eachnormloop1_dict={}
    eachnorm_dict={}
    for i in range(n_ps+n_ps_border):
        eachnormloop1_dict['ps_' + str(i+1)] = ps_norms_loop1[i]
    for i in range(n_ps):
        eachnorm_dict['ps_' + str(i+1)] = ps_norms[i]*ps_norms_loop1[i]
    # NB: norm is from the initial scan, spectra and ts from the final scan
    eachps_savefile = ps_spec_dir + save_spect_label_ps
    eachnormloop1_savefile = ps_spec_dir + save_norm_loop1_label_ps
    eachnorm_savefile = ps_spec_dir + save_norm_label_ps
    eachts_savefile = ps_spec_dir + save_ts_label
    print 'saving spectra, norm and ts spectra'
    spect = [[ eachps_En_center, eachps_dict]]
    np.save(eachps_savefile,np.array(spect))
    normloop1 = [[ eachps_En_center, eachnormloop1_dict]]
    np.save(eachnormloop1_savefile,np.array(normloop1))
    norm = [[ eachps_En_center, eachnorm_dict]]
    np.save(eachnorm_savefile,np.array(norm))
    outts = [[ eachps_En_center, eachts_dict]]
    np.save(eachts_savefile,np.array(outts))
Exemplo n.º 10
0
band_mask_range = [-band_mask, band_mask]  #measured from the Galactic plane
mask_ring = False

mask_type = 'top300'  #can also be '0.99', 'top300', or 'False'
force_energy = True  #we will force the PS mask from a specific energy bin
energy_bin_mask = 10

norm_file_path = '/tigress/nrodd/2mass2furious/MakeMC/P8UCVA_norm'
spect_file_path = '/tigress/nrodd/2mass2furious/MakeMC/P8UCVA_spec'

f_total = fp.fermi_plugin(maps_dir,
                          fermi_data_dir=fermi_data_dir,
                          CTB_en_min=CTB_start_bin,
                          CTB_en_max=CTB_end_bin + 1,
                          nside=nside,
                          eventclass=eventclass,
                          eventtype=eventtype,
                          newstyle=newstyle,
                          data_July16=data_July16)
#f_total.make_ps_mask(mask_type = mask_type,energy_bin = energy_bin_mask,force_energy=force_energy)
f_total.make_ps_mask(mask_type=mask_type,
                     energy_bin=energy_bin_mask,
                     force_energy=force_energy)

f_total.add_diffuse_newstyle(comp='p7',
                             eventclass=eventclass,
                             eventtype=eventtype)  #diffuse
f_total.add_bubbles()  #bubbles
f_total.add_iso()  #iso
f_total.add_ps_model()
Exemplo n.º 11
0
parser.add_argument('-d', action='store', dest='tag',type=str)
parser.add_argument('-t', action='store', dest='run_tag',type=str)
parser.add_argument('-m', action='store', dest='maps_dir',type=str)

results = parser.parse_args()
run=results.run
analysis=results.analysis
tag = results.tag
run_tag = results.run_tag
maps_dir = results.maps_dir

print 'maps_dir is ', maps_dir

#########################
#configure for fermi
f = fp.fermi_plugin(maps_dir)

f.make_ps_mask()
f.add_diffuse(comp = 'p6')
f.add_bubbles()
f.add_iso()
f.add_nfw()
f.add_ps(0,0)


#########################
#setup bayesian scan for fermi
b = bsm.bayesian_scan_NPTF(tag=tag)
b.load_external_data(f.CTB_en_bins,f.CTB_count_maps,f.CTB_exposure_maps)
b.add_new_template(f.template_dict)
b.make_mask_total(ps_mask_array = f.ps_mask_array)
Exemplo n.º 12
0
def main():

    keyfile = 'nptf/IG_NDI/FD_key_1.txt.gz' 
    datafile = 'nptf/IG_NDI/FD_1.txt.gz'
    jetbase = '/tigress/nrodd/FindPSOutput/psdata_29-11-15-m4-b2_roi/psdata_29-11-15-m4-b2_roi_ca_PT_R0p'
    jetfiles = [jetbase+'2.txt.gz',jetbase+'3.txt.gz',jetbase+'4.txt.gz',jetbase+'5.txt.gz',jetbase+'6.txt.gz',jetbase+'7.txt.gz',jetbase+'8.txt.gz',jetbase+'9.txt.gz']

    outname = '29-11-15-m4_b2'

    fake_data_key_path = '/tigress/nrodd/NPTFWorking/FindPS/plots/' + keyfile

    CTB_start_bin=8
    CTB_end_bin=16
    nside=512
    data_type='p8'
    npix = hp.nside2npix(nside)
    theta, phi = hp.pix2ang(nside,range(npix))
    larr_full = phi*180/np.pi
    larr_full = ((larr_full + 180) % 360)-180
    larr_full *= np.pi/180
    barr_full = np.pi/2 - theta

    band_mask_range_plot = [-1,1]
    mask_ring_plot = True
    outer_plot = 10

    f = fp.fermi_plugin(maps_dir,CTB_en_min=CTB_start_bin,CTB_en_max=CTB_end_bin,nside=nside,data_name=data_type)
    f.add_diffuse(comp = 'p6') #diffuse
    f.add_bubbles() #bubbles
    f.add_iso()  #iso
    f.add_nfw()
    f.load_psf()
    sigma_PSF_deg = f.sigma_PSF_deg[0:-1]

    # Create background model in each energy bin
    norm_file='/tigress/nrodd/NPTFWorking/FindPS/data/spect/findps_norm.npy'
    loadnorm = np.load(norm_file)
    bkg = np.zeros(shape=(CTB_end_bin-CTB_start_bin,npix))
    for i in range(CTB_start_bin,CTB_end_bin):
        comb  = f.template_dict['p6'][i-CTB_start_bin]*loadnorm[i][1]['p6-0']
        comb += f.template_dict['iso'][i-CTB_start_bin]*loadnorm[i][1]['iso-0']
        comb += f.template_dict['bubs'][i-CTB_start_bin]*loadnorm[i][1]['bubs-0']
        comb += f.template_dict['nfw'][i-CTB_start_bin]*(10**(loadnorm[i][1]['nfw-0']))
        bkg[i-CTB_start_bin,::] = comb
    
    # Load the fake data map
    load = np.loadtxt('/tigress/nrodd/NPTFWorking/FindPS/plots/' + datafile)

    fakemap = load[CTB_start_bin:CTB_end_bin,::] 

    # Now calculate dndF from the sim key
    fake_data_key_load = np.loadtxt(fake_data_key_path)
    fake_data_key = np.zeros(shape=(len(fake_data_key_load),10))
    fake_data_key[::,0:2] = fake_data_key_load[::,0:2]
    fake_data_key[::,2:10] = fake_data_key_load[::,CTB_start_bin+2:CTB_end_bin+2]

    # Now pick out point sources within the ROI we want to analyse
    # NB: cuts in degrees, larr and barr in radians
    pmfocus=3
    ringfocus=10

    barr = np.pi/2-fake_data_key[::,0]

    larr = fake_data_key[::,1]*180/np.pi
    larr = ((larr + 180) % 360)-180
    larr *= np.pi/180
    thetaarr = np.arccos(np.cos(larr)*np.cos(barr))

    roi = np.where((np.abs(barr) > pmfocus*np.pi/180) & (thetaarr < ringfocus*np.pi/180))[0]

    fake_data_keyroi = fake_data_key[roi,::]

    pfake3FGL = make_flux_histogram_local(fake_data_keyroi,f.CTB_exposure_maps,band_mask_range = band_mask_range_plot, mask_ring = mask_ring_plot, outer = outer_plot)
    pfake3FGL.make_fake_data_flux_histogram(0.1,5000,50)
    pfake3FGL.plot_fake_data_histogram(fmt = 'o', color='black',markersize=5,label='Sim PS')

    # Now read in Jet data and create dndF plots from that
    # First load the data and background model as we need these

    jetcolors = ['red','orange','yellow','green','blue','indigo','violet','pink']
    # Loop through the files
    for i in range(8):
        print "At i =",i
        jetload = np.loadtxt(jetfiles[i])
        # extract (l,b) from array
        larr = jetload[::,0]
        phi = larr*180/np.pi
        larr = ((larr + 180) % 360)-180
        larr *= np.pi/180
        barr = jetload[::,1]
        theta = np.pi/2-barr
        # Determine which are in the ROI
        thetaarr = np.arccos(np.cos(larr)*np.cos(barr))
        roi = np.where((np.abs(barr) > pmfocus*np.pi/180) & (thetaarr < ringfocus*np.pi/180))[0]
        # Now build up the key for each ps in the ROI
        jet_data_key = np.zeros(shape=(len(roi),10))
        for j in range(len(roi)):
            # First put theta and phi in
            jet_data_key[j,0] = theta[roi[j]]
            jet_data_key[j,1] = phi[roi[j]]
            # Now input the counts - determine this from data-bkg in within 1 PSF of the source
            # Then rescale up as this is just the 68% containment radius
            thetaps = np.arccos(np.cos(larr[roi[j]]-larr_full)*np.cos(barr[roi[j]]-barr_full))
            for k in range(8):
                PSF = sigma_PSF_deg[k]
                psroi = np.where(thetaps < PSF*np.pi/180)[0]
                jet_data_key[j,k+2] = np.sum(bkg[k,psroi]-fakemap[k,psroi])/0.68
        # Now plot
        pfake3FGL = make_flux_histogram_local(jet_data_key,f.CTB_exposure_maps,band_mask_range = band_mask_range_plot, mask_ring = mask_ring_plot, outer = outer_plot)
        pfake3FGL.make_fake_data_flux_histogram(0.1,5000,50)
        pfake3FGL.plot_fake_data_histogram(fmt = 'o', color=jetcolors[i],markersize=5,label='Jet R0p'+str(i+2))

    plt.yscale('log')
    plt.xscale('log')
    plt.xlim([1e-12,1e-6])
    plt.ylim([1e3,1e11])

    plt.tick_params(axis='x', length=5,width=2,labelsize=18)
    plt.tick_params(axis='y',length=5,width=2,labelsize=18)
    plt.xlabel('$F$  [photons / cm$^2$ / s]', fontsize=18)
    plt.ylabel('$dN/dF$  [photons$^{-1}$ cm$^2$ s deg$^{-2}$]', fontsize=18)

    plt.legend(fontsize=16)

    plt.savefig('./Plots/' + outname + '.pdf')

    plt.close()
Exemplo n.º 13
0
def setup_for_scan(larr=[0],barr=[0],add_group_ps=False,ps_number=0,fdn=True,fdrun=False):
    global f, b, new_template_dict, sigma_PSF_deg, sigma_PSF_deg_red, n_ps, newstyle, ps_norms, diffnormfix
    # Load Fermi Plugin and its basic functionality
    f = fp.fermi_plugin(maps_dir,fermi_data_dir=fermi_data_dir,work_dir=work_dir,CTB_en_min = emin,CTB_en_max=emax,nside=nside,eventclass=eventclass,eventtype=eventtype,newstyle=newstyle)

    if mask_type!='False':
        f.make_ps_mask(mask_type=mask_type,force_energy=force_ps_mask,energy_bin=force_ps_mask_bin)
    # Add appropriate templates
    f.add_diffuse_newstyle(comp = diff, eventclass = eventclass, eventtype = eventtype)
    if extraicstemp!='False':
        f.add_diffuse_newstyle(comp = extraicstemp, eventclass = eventclass, eventtype = eventtype)
    f.add_bubbles(comp = 'bubs')
    f.add_iso(comp = 'iso')
    if add_ps_model:
        f.add_ps_model(comp = 'ps_model')
    if fdn:
        f.add_nfw(comp = 'nfw')
    # Throughout we use a king function or Gaussian for the point sources
    if add_group_ps:
        if use_king:
            f.add_multiple_ps_king_fast(larr[0:ps_number],barr[0:ps_number],rescale=ps_norms[0:ps_number],comp='ps_comb')
        else:
            # Add in Gaussian point source - need the PSF for this
            f.load_psf(data_name='p8',fits_file_path = 'False')
            sigma_PSF_deg = f.sigma_PSF_deg[0:-1]
            f.add_multiple_ps(larr[0:ps_number],barr[0:ps_number],sigma_PSF_deg[0],rescale=ps_norms[0:ps_number],comp='ps_comb')
    if norm_file!='False':
        if len(add_norm_file_for_comps) > 0 and add_norm_file != 'False':
            print 'using first normalization file: ', norm_file
            f.use_template_normalization_file(norm_file,key_suffix='-0',dont_use_keys=add_norm_file_for_comps)
            print 'using second normalization file: ', add_norm_file
            f.use_template_normalization_file(add_norm_file,key_suffix='-0',use_keys=add_norm_file_for_comps)
        else:
            f.use_template_normalization_file(norm_file,key_suffix='-0')

    # Setup Bayesian scan for fermi
    b = bsm.bayesian_scan_NPTF(tag=tag,work_dir = work_dir,psf_dir = psf_dir,nside=nside,nlive=nlive,k_max=k_max)
    if fake_data_file=='False':
        print 'Using real data'
        count_maps=f.CTB_count_maps
        new_count_maps = f.CTB_count_maps
    else:
        print 'Using fake data from the file', fake_data_file
        count_maps=np.loadtxt(fake_data_file)[fake_data_emin:fake_data_emax]
        new_count_maps = np.zeros( (len(count_maps),hp.nside2npix(nside) ) )
        for i in range(len(count_maps)):
            new_count_maps[i] = hp.ud_grade(count_maps[i],nside,power=-2)

    b.load_external_data(f.CTB_en_bins,new_count_maps,f.CTB_exposure_maps)
    if use_simplified_templates:
        b.add_new_template(new_template_dict)
        if fixed_background:
            b.add_fixed_templates({'back':new_template_dict['back']})
    else:
        b.add_new_template(f.template_dict)
    if mask_type!='False':
        b.make_mask_total(plane_mask=plane_mask, band_mask_range = [-pmval,pmval], lcut=lcut, lmin=lmin, lmax=lmax, bcut=bcut, bmin=bmin, bmax=bmax, mask_ring=mask_ring, inner=inner, outer=outer, ps_mask_array = f.ps_mask_array)
    else:
        b.make_mask_total(plane_mask=plane_mask, band_mask_range = [-pmval,pmval], lcut=lcut, lmin=lmin, lmax=lmax, bcut=bcut, bmin=bmin, bmax=bmax, mask_ring=mask_ring, inner=inner, outer=outer)
    b.rebin_external_data(1)
    b.compress_templates()

    ### Add in the Templates
    if method != 'minuit':
        if not min_prior_range:
            if not fdrun:
                b.add_fixed_templates({diff:[f.template_dict[diff][0]*diffnormfix]})
            else:
                b.add_poiss_model(diff,'$A_{diff}$',[-5,5],False)
            if extraicstemp!='False':
                b.add_poiss_model(extraicstemp,'$A_{ics}$',[-5,5],False)
            b.add_poiss_model('iso','$A_{iso}$',[-3,3],False)
            b.add_poiss_model('bubs','$A_{bubs}$',[-3,3],False)
        else: # If already have priors, don't scan over such a large range
            if not fdrun:
                b.add_fixed_templates({diff:f.template_dict[diff]*diffnormfix})
            else:
                b.add_poiss_model(diff,'$A_{diff}$',[0.5,1.5],False)
            if extraicstemp!='False':
                b.add_poiss_model(extraicstemp,'$A_{ics}$',[0.5,1.5],False)
            if high_lat:
                b.add_poiss_model('iso','$A_{iso}$',[0.5,1.5],False)
            else:
                b.add_poiss_model('iso','$A_{iso}$',[0.8,1.2],False)
            b.add_poiss_model('bubs','$A_{bubs}$',[0.5,1.5],False)
    else:
        if not fdrun:
            b.add_fixed_templates({diff:f.template_dict[diff]*diffnormfix})
        else:
            b.add_poiss_model(diff,'$A_{diff}$',[0,2],False)
        if extraicstemp!='False':
            b.add_poiss_model(extraicstemp,'$A_{ics}$',[-2,2],False)
        b.add_poiss_model('iso','$A_{iso}$',[0,2],False)
        b.add_poiss_model('bubs','$A_{bubs}$',[0,4],False)
    if add_ps_model:
        if not min_prior_range:
            b.add_poiss_model('ps_model','$A_{ps-model}$',[0,6],False)
        else:
            b.add_poiss_model('ps_model','$A_{ps-model}$',[0.5,1.5],False)
    if fdn:
        b.add_poiss_model('nfw','$l10A_{nfw}$',[-6,6],True)
    if add_group_ps:
        b.add_poiss_model('ps_comb','$A_{ps-comb}$',[-5,5],False)

    ### Configure final details
    def sb_string_mod(mod):
        return ['${S_b^{' + mod + '}}^{'+str(i) + '}$' for i in range(1)]

    b.initiate_poissonian_edep()
    print 'Performing a standard template fit ...'
Exemplo n.º 14
0
def main():
    global plot_ll_profile, full_dict, eachps_En_center, n_ps, ps_norms, diffnormfix

    diffnormfix=1.

    # Determine PSF using fermi plugin, for use in the ps ordering
    loadforpsf = fp.fermi_plugin(maps_dir,fermi_data_dir=fermi_data_dir,work_dir=work_dir,CTB_en_min = emin,CTB_en_max=emax,nside=nside,eventclass=eventclass,eventtype=eventtype,newstyle=newstyle)
    loadforpsf.load_psf(data_name='p8',fits_file_path = 'False')
    sigma_PSF_deg = loadforpsf.sigma_PSF_deg[0:-1]
    
    # Get an ordered list of the l and b values by ranking - cutting those outside of region
    # End of list contains those sources outside region but within 1 PSF of the border
    larr,barr,n_ps,n_ps_border = trimorderpslist(ps_file,indeg,sigma_PSF_deg)

    # Define empty dictionary
    full_dict={}

    # First run to get diff norm

    # Setup for scan
    if method=='minuit' and run==False:
        pass
    else:
        print 'setting up the scan.  the method is', method
        setup_for_scan(larr=larr,barr=barr,add_group_ps=True,ps_number=n_ps,fdn=fixdiffnfw,fdrun=True)
        print 'finished setting up the scan.'

    # Perform scan / load scan
    if run:
        print 'The nside for this scan is ', b.nside
        if method=='multinest':
            b.perform_scan(run_tag = run_tag_energy)
            do_analysis(minuit_new=False,add_group_ps=False,ps_number=0,fdn=fixdiffnfw,fdrun=True)
        elif method=='minuit':
            b.perform_scan_minuit(run_tag = run_tag_energy)
            b.save_minuit()
            do_analysis(minuit_new=True,add_group_ps=False,ps_number=0,fdn=fixdiffnfw,fdrun=True)


    # Setup for scan
    if method=='minuit' and run==False:
        pass
    else:
        print 'setting up the scan.  the method is', method
        setup_for_scan(larr=larr,barr=barr,add_group_ps=False,ps_number=0)
        print 'finished setting up the scan.'

    # Perform scan / load scan
    if run:
        print 'The nside for this scan is ', b.nside
        if method=='multinest':
            b.perform_scan(run_tag = run_tag_energy)
            do_analysis(minuit_new=False,add_group_ps=False,ps_number=0)
        elif method=='minuit':
            b.perform_scan_minuit(run_tag = run_tag_energy)
            b.save_minuit()
            do_analysis(minuit_new=True,add_group_ps=False,ps_number=0)

    # Setup for scan
    if method=='minuit' and run==False:
        pass
    else:
        print 'setting up the scan.  the method is', method
        setup_for_scan(larr=larr,barr=barr,add_group_ps=True,ps_number=10)
        print 'finished setting up the scan.'
        #hp.mollview(np.sum(f.template_dict['ps_comb'],axis=0),max=1)
        #plt.show()
        

    # Perform scan / load scan
    if run:
        print 'The nside for this scan is ', b.nside
        if method=='multinest':
            b.perform_scan(run_tag = run_tag_energy)
            do_analysis(minuit_new=False,add_group_ps=True,ps_number=10)
        elif method=='minuit':
            b.perform_scan_minuit(run_tag = run_tag_energy)
            b.save_minuit()
            do_analysis(minuit_new=True,add_group_ps=True,ps_number=10)

    # Setup for scan
    if method=='minuit' and run==False:
        pass
    else:
        print 'setting up the scan.  the method is', method
        setup_for_scan(larr=larr,barr=barr,add_group_ps=True,ps_number=100)
        print 'finished setting up the scan.'

    # Perform scan / load scan
    if run:
        print 'The nside for this scan is ', b.nside
        if method=='multinest':
            b.perform_scan(run_tag = run_tag_energy)
            do_analysis(minuit_new=False,add_group_ps=True,ps_number=100)
        elif method=='minuit':
            b.perform_scan_minuit(run_tag = run_tag_energy)
            b.save_minuit()
            do_analysis(minuit_new=True,add_group_ps=True,ps_number=100)

    # Setup for scan
    if method=='minuit' and run==False:
        pass
    else:
        print 'setting up the scan.  the method is', method
        setup_for_scan(larr=larr,barr=barr,add_group_ps=True,ps_number=n_ps)
        print 'finished setting up the scan.'

    # Perform scan / load scan
    if run:
        print 'The nside for this scan is ', b.nside
        if method=='multinest':
            b.perform_scan(run_tag = run_tag_energy)
            do_analysis(minuit_new=False,add_group_ps=True,ps_number=n_ps)
        elif method=='minuit':
            b.perform_scan_minuit(run_tag = run_tag_energy)
            b.save_minuit()
            do_analysis(minuit_new=True,add_group_ps=True,ps_number=n_ps)

    # Finally save the spectra, norm and ts details
    # Create norm dictionary and a dictionary where we convert this to a spectrum
    nfwps_savefile = psnfw_spec_dir + save_nfwps_label
    spect = [[ eachps_En_center, full_dict]]
    np.save(nfwps_savefile,np.array(spect))
Exemplo n.º 15
0
band_mask_range=[-1.,1.]
mask_ring=True
outer=30
mask_type='top300' # If don't want to include this, make it 'False'
force_energy=True
energy_bin_mask=8

# Setup npix, l and b
npix = hp.nside2npix(nside)

theta, phi = hp.pix2ang(nside,range(npix))
larr = phi
barr = np.pi/2 - theta

# Setup Fermi module which we need to extract data and determine the background model
f = fp.fermi_plugin('/tigress/smsharma/public/CTBCORE/',CTB_en_min=CTB_start_bin,CTB_en_max=CTB_end_bin,nside=nside,data_name='p8')
f.add_diffuse(comp = 'p6') #diffuse
f.add_bubbles() #bubbles
f.add_iso()  #iso
f.add_nfw()

# Load the real data map
realdata = np.sum(f.CTB_count_maps,axis=0)

# Create the masks
if mask_type != 'False':
    f.make_ps_mask(mask_type = mask_type,energy_bin = energy_bin_mask,force_energy=force_energy)
b = bsm.bayesian_scan_NPTF(nside=nside)
b.load_external_data(f.CTB_en_bins,f.CTB_count_maps,f.CTB_exposure_maps)
b2 = copy.deepcopy(b)
b.make_mask_total(band_mask_range=band_mask_range,mask_ring=mask_ring,outer=outer)
Exemplo n.º 16
0
def setup_for_scan(i=0,n_ps_groupi=0,larr=[0],barr=[0],psloop1=False,pscomball=False,psloop2bkg=False,psloop2=False):
    global f, b, new_template_dict, sigma_PSF_deg, sigma_PSF_deg_red, n_ps, newstyle, ps_norms_loop1, ps_norms
    # Load Fermi Plugin and its basic functionality
    f = fp.fermi_plugin(maps_dir,fermi_data_dir=fermi_data_dir,work_dir=work_dir,CTB_en_min = emin,CTB_en_max=emax,nside=nside,eventclass=eventclass,eventtype=eventtype,newstyle=newstyle)

    if mask_type!='False':
        f.make_ps_mask(mask_type=mask_type,force_energy=force_ps_mask,energy_bin=force_ps_mask_bin)
    # Add appropriate templates
    f.add_diffuse_newstyle(comp = diff, eventclass = eventclass, eventtype = eventtype)
    if extraicstemp!='False':
        f.add_diffuse_newstyle(comp = extraicstemp, eventclass = eventclass, eventtype = eventtype)
    f.add_bubbles(comp = 'bubs')
    f.add_iso(comp = 'iso')
    if add_ps_model:
        f.add_ps_model(comp = 'ps_model')
    if nfw_dm:
        f.add_nfw(comp = 'nfw')
    if psloop1:
        # Throughout we use a king function or Gaussian for the point sources
        if use_king:
            for j in range(n_ps_groupi):
                f.add_ps_king_fast(larr[i*n_ps_run+j],barr[i*n_ps_run+j],comp ='ps_' + str(i*n_ps_run+j+1))
            if i != 0:
                f.add_multiple_ps_king_fast(larr[0:i*n_ps_run],barr[0:i*n_ps_run],rescale=ps_norms_loop1[0:i*n_ps_run],comp='ps_comb')
        else:
            # Add in Gaussian point source - need the PSF for this
            f.load_psf(data_name='p8',fits_file_path = 'False')
            sigma_PSF_deg = f.sigma_PSF_deg[0:-1]
            for j in range(n_ps_groupi):
                f.add_ps(larr[i*n_ps_run+j],barr[i*n_ps_run+j],sigma_PSF_deg[0],comp ='ps_' + str(i*n_ps_run+j+1))
            if i != 0:
                f.add_multiple_ps(larr[0:i*n_ps_run],barr[0:i*n_ps_run],sigma_PSF_deg[0],rescale=ps_norms_loop1[0:i*n_ps_run],comp='ps_comb')
    if pscomball:
        if use_king:
            f.add_multiple_ps_king_fast(larr,barr,rescale=ps_norms_loop1,comp='ps_comb')
        else:
            f.load_psf(data_name='p8',fits_file_path = 'False')
            sigma_PSF_deg = f.sigma_PSF_deg[0:-1]
            f.add_multiple_ps(larr,barr,sigma_PSF_deg[0],rescale=ps_norms_loop1,comp='ps_comb')
    if psloop2bkg:
        if use_king:
            f.add_multiple_ps_king_fast(larr,barr,rescale=ps_norms_loop1,comp='ps_comb',excluded=i)
        else:
            f.load_psf(data_name='p8',fits_file_path = 'False')
            sigma_PSF_deg = f.sigma_PSF_deg[0:-1]
            f.add_multiple_ps(larr,barr,sigma_PSF_deg[0],rescale=ps_norms_loop1,comp='ps_comb',excluded=i)
    if psloop2:
        if use_king:
            f.add_ps_king_fast(larr[i],barr[i],rescale=ps_norms_loop1[i],comp ='ps_' + str(i+1))
            f.add_multiple_ps_king_fast(larr,barr,rescale=ps_norms_loop1,comp='ps_comb',excluded=i)
        else:
            f.load_psf(data_name='p8',fits_file_path = 'False')
            sigma_PSF_deg = f.sigma_PSF_deg[0:-1]
            f.add_ps(larr[i],barr[i],sigma_PSF_deg[0],rescale=ps_norms_loop1[i],comp ='ps_' + str(i+1))
            f.add_multiple_ps(larr,barr,sigma_PSF_deg[0],rescale=ps_norms_loop1,comp='ps_comb',excluded=i)
    if norm_file!='False':
        if len(add_norm_file_for_comps) > 0 and add_norm_file != 'False':
            print 'using first normalization file: ', norm_file
            f.use_template_normalization_file(norm_file,key_suffix='-0',dont_use_keys=add_norm_file_for_comps)
            print 'using second normalization file: ', add_norm_file
            f.use_template_normalization_file(add_norm_file,key_suffix='-0',use_keys=add_norm_file_for_comps)
        else:
            f.use_template_normalization_file(norm_file,key_suffix='-0')

    # Setup Bayesian scan for fermi
    b = bsm.bayesian_scan_NPTF(tag=tag,work_dir = work_dir,psf_dir = psf_dir,nside=nside,nlive=nlive,k_max=k_max)
    if fake_data:
        data = np.loadtxt(fake_data_path)
    else:
        data = f.CTB_count_maps
    b.load_external_data(f.CTB_en_bins,data,f.CTB_exposure_maps)
    if use_simplified_templates:
        b.add_new_template(new_template_dict)
        if fixed_background:
            b.add_fixed_templates({'back':new_template_dict['back']})
    else:
        b.add_new_template(f.template_dict)
    if mask_type!='False':
        b.make_mask_total(plane_mask=plane_mask, band_mask_range = [-pmval,pmval], lcut=lcut, lmin=lmin, lmax=lmax, bcut=bcut, bmin=bmin, bmax=bmax, mask_ring=mask_ring, inner=inner, outer=outer, ps_mask_array = f.ps_mask_array)
    else:
        b.make_mask_total(plane_mask=plane_mask, band_mask_range = [-pmval,pmval], lcut=lcut, lmin=lmin, lmax=lmax, bcut=bcut, bmin=bmin, bmax=bmax, mask_ring=mask_ring, inner=inner, outer=outer)
    b.rebin_external_data(1)
    b.compress_templates()

    ### Add in the Templates
    if method != 'minuit':
        if not min_prior_range:
            b.add_poiss_model(diff,'$A_{diff}$',[-5,5],False)
            if extraicstemp!='False':
                b.add_poiss_model(extraicstemp,'$A_{ics}$',[-5,5],False)
            b.add_poiss_model('iso','$A_{iso}$',[-3,3],False)
            b.add_poiss_model('bubs','$A_{bubs}$',[-3,3],False)
        else: # If already have priors, don't scan over such a large range
            b.add_poiss_model(diff,'$A_{diff}$',[0.5,1.5],False)
            if extraicstemp!='False':
                b.add_poiss_model(extraicstemp,'$A_{ics}$',[0.5,1.5],False)
            if high_lat:
                b.add_poiss_model('iso','$A_{iso}$',[0.5,1.5],False)
            else:
                b.add_poiss_model('iso','$A_{iso}$',[0.8,1.2],False)
            b.add_poiss_model('bubs','$A_{bubs}$',[0.5,1.5],False)
    else:
        b.add_poiss_model(diff,'$A_{diff}$',[0,2],False)
        if extraicstemp!='False':
            b.add_poiss_model(extraicstemp,'$A_{ics}$',[-2,2],False)
        b.add_poiss_model('iso','$A_{iso}$',[0,2],False)
        b.add_poiss_model('bubs','$A_{bubs}$',[0,4],False)
    if add_ps_model:
        if not min_prior_range:
            b.add_poiss_model('ps_model','$A_{ps-model}$',[0,6],False)
        else:
            b.add_poiss_model('ps_model','$A_{ps-model}$',[0.5,1.5],False)
    if nfw_dm: # leave this large as NFW struggles to converge at high E
        b.add_poiss_model('nfw','$l10A_{nfw}$',[-6,6],True)
    if psloop1:
        for j in range(n_ps_groupi):
            b.add_poiss_model('ps_' + str(i*n_ps_run+j+1),'$l10A_{ps' + str(i*n_ps_run+j+1) + '}$',[-10,10],True)
        if i != 0:
            b.add_poiss_model('ps_comb','$A_{ps-comb}$',[0.5,1.5],False)
    if pscomball:
        b.add_poiss_model('ps_comb','$A_{ps-comb}$',[0.5,1.5],False)
    if psloop2bkg:
        b.add_poiss_model('ps_comb','$A_{ps-comb}$',[0.5,1.5],False)
    if psloop2:
        b.add_poiss_model('ps_' + str(i+1),'$A_{ps' + str(i+1) + '}$',[0.5,1.5],False)
        b.add_poiss_model('ps_comb','$A_{ps-comb}$',[0,3],False)
        # Ideally want to basically fix this component, but if make too small minuit crashes

    ### Configure final details
    def sb_string_mod(mod):
        return ['${S_b^{' + mod + '}}^{'+str(i) + '}$' for i in range(1)]

    b.initiate_poissonian_edep()
    print 'Performing a standard template fit ...'
Exemplo n.º 17
0
n_flux_bins=15
error_range=0.68 #for plotting uncertanties



######disk filename
disk_file_name=  'thindiskmodel_ec.fits' #'simplediskmodel_ec.fits'


####################
##########Internal code


###################
##Fermi plugin instance
f = fp.fermi_plugin(maps_dir,CTB_en_min=CTB_start_bin,CTB_en_max=CTB_end_bin,nside=nside,data_name=data_type)
#f.make_ps_mask(mask_type = mask_type,energy_bin = energy_bin_mask,force_energy=force_energy)

f.add_diffuse(comp = 'p6') #diffuse
f.add_bubbles() #bubbles
f.add_iso()  #iso
f.add_nfw()  #NFW-DM
f.add_template_from_file('disk',disk_file_name) #we will call template 'disk'

if mask_type != 'False':
    f.make_ps_mask(mask_type = mask_type,energy_bin = energy_bin_mask,force_energy=force_energy)


f.use_template_normalization_file(norm_file_path,key_suffix='-0')

Exemplo n.º 18
0
    def __init__(self,Emin,eventclass=5,eventtype=3,fermi_data_dir = '/mnt/hepheno/FermiData/', maps_dir = '/mnt/hepheno/CTBCORE/',nside=128,mask_type='top300',force_energy=False,newstyle=1,diff='p8',data_July16=True):
        self.f = fp.fermi_plugin(maps_dir,fermi_data_dir=fermi_data_dir,CTB_en_min=Emin,CTB_en_max=Emin+1,nside=nside,eventclass=eventclass,eventtype=eventtype,newstyle=newstyle,data_July16=data_July16)

        self._setup_f(mask_type,Emin,force_energy,eventclass,eventtype,diff)
        self.extract()
Exemplo n.º 19
0
ps_string = ['ps-l-'+str(round(ell_i,3)) + '-b-'+str(round(b_i,3)) for ell_i, b_i in map(None,ell_0,b_0)]
inner=0


##################
#################
####figure out the mask
if mask_string!='False':
    mask = hp.ud_grade( np.array(np.loadtxt(mask_string)), nside)




#########################
#configure for fermi
f = fp.fermi_plugin(maps_dir,work_dir=work_dir,CTB_en_min = emin,CTB_en_max=emax,nside=nside)

if mask_type!='False':
    f.make_ps_mask(mask_type = mask_type,force_energy = False) #
f.add_diffuse(comp = diff)
f.add_bubbles(comp='bubs')
f.add_iso(comp='iso')
######Need to figure out the PSF
f.load_psf(data_name='p8',fits_file_path = 'False')
sigma_PSF_deg = f.sigma_PSF_deg[0]
print 'The psf is', sigma_PSF_deg
######
for ell_i, b_i,ps_string_i in map(None,ell_0,b_0,ps_string):
    f.add_ps(ell_i,b_i,f.sigma_PSF_deg[0],comp = ps_string_i) 
############
Exemplo n.º 20
0
    def scan(self):

        print("Getting into scan")

        ################
        # Fermi plugin #
        ################
        
        print("Loading Fermi plugin...")
        # Load the Fermi plugin - always load all energy bins, extract what is needed
        f_global = fp.fermi_plugin(maps_dir,fermi_data_dir=fermi_data_dir,work_dir=work_dir,CTB_en_min=0,CTB_en_max=40,nside=self.nside,eventclass=self.eventclass,eventtype=self.eventtype,newstyle=1,data_July16=True)
        print("... done")

        # Load necessary templates
        f_global.add_diffuse_newstyle(comp = self.diff,eventclass = self.eventclass, eventtype = self.eventtype) 
        f_global.add_iso()  
        ps_temp = np.load(work_dir + '/DataFiles/PS-Maps/ps_map.npy')
        f_global.add_template_by_hand(comp='ps_model',template=ps_temp)
        f_global.add_bubbles()

        # If Asimov normalize the templates and create a summed map
        if self.Asimov:
            norm_file = work_dir + '/DataFiles/Misc/P8UCVA_norm.npy' 
            f_global.use_template_normalization_file(norm_file,key_suffix='-0')
            Asimov_data = np.zeros((40,hp.nside2npix(self.nside)))
            for key in f_global.template_dict.keys():
                Asimov_data += np.array(f_global.template_dict[key]) 

        ###################
        # Get DM halo map #
        ###################

        print("Getting halo map...")
        if not self.randlocs: # If doing random locations
            l = self.catalog.l.values[self.iobj]
            b = self.catalog.b.values[self.iobj]
        else:
            badval = True
            while (badval):
                test_ell = np.random.uniform(0.,2*np.pi)
                test_b = np.arccos(np.random.uniform(-1.,1.))-np.pi/2.
                test_pixval = hp.ang2pix(self.nside, test_b+np.pi/2, test_ell)
                ps0p5_mask = np.load(work_dir + '/DataFiles/Misc/mask0p5_3FGL.npy') > 0

                # Check if not masked with plan or PS mask
                if ( (np.abs(test_b)*180./np.pi > 20. ) & (ps0p5_mask[test_pixval] == 0)):
                    badval = False
                    l = test_ell*180./np.pi
                    b = test_b*180./np.pi
            np.savetxt(self.save_dir + "/lb_obj"+str(self.iobj) + ".dat", np.array([l, b]))

        rs = self.catalog.rs.values[self.iobj]*1e-3
        if self.boost:
            J0 = 10**self.catalog.mulog10J_inf.values[self.iobj]
        else:
            J0 = 10**self.catalog.mulog10Jnb_inf.values[self.iobj]
        mk = mkDMMaps.mkDMMaps(z = self.catalog.z[self.iobj], r_s = rs , J_0 = J0, ell = l*np.pi/180, b = b*np.pi/180, nside=self.nside, use_boost=self.use_boost, Burkert=self.Burkert)
        DM_template_base = mk.map
        print("...done")

        #########################################
        # Loop over energy bins to get xsec LLs #
        #########################################

        A_ary = 10**np.linspace(-6,6,200)
        LL_inten_ary = np.zeros((len(self.ebins)-1,len(A_ary)))
        inten_ary = np.zeros((len(self.ebins)-1,len(A_ary)))

        # 10 deg mask for the analysis
        analysis_mask = cm.make_mask_total(mask_ring = True, inner = 0, outer = 10, ring_b = b, ring_l = l)

        for iebin, ebin in tqdm(enumerate(np.arange(self.emin,self.emax+1)), disable = 1 - self.verbose):
            
            ######################
            # Templates and maps #
            ######################

            if self.verbose:
                print "At bin", ebin

            if self.imc != -1:
                data = np.load(mc_dir + 'MC_allhalos_p7_' + self.dm_string + '_v' + str(self.imc)+'.npy')[ebin].astype(np.float64)
            else:
                data = f_global.CTB_count_maps[ebin].astype(np.float64)

            fermi_exposure = f_global.CTB_exposure_maps[ebin]

            DM_template = DM_template_base*fermi_exposure/np.sum(DM_template_base*fermi_exposure)
            print("Loading smoothing class...")
            ksi = ks.king_smooth(maps_dir, ebin, self.eventclass, self.eventtype, threads=1)
            print("...done!")
            print("Beginning to smooth...")
            DM_template_smoothed = ksi.smooth_the_map(DM_template)
            print("...done!")
            DM_intensity_base = np.sum(DM_template_smoothed/fermi_exposure)
            
            dif = f_global.template_dict[self.diff][ebin]
            iso = f_global.template_dict['iso'][ebin]
            psc = f_global.template_dict['ps_model'][ebin]
            bub = f_global.template_dict['bubs'][ebin]

            # If doing Asimov this first scan is irrelevant, but takes no time so run
            
            ####################
            # NPTFit norm scan #
            ####################
            
            n = nptfit.NPTF(tag='norm_o'+str(self.iobj)+'_E'+str(ebin)+self.mc_tag)
            n.load_data(data, fermi_exposure)

            n.load_mask(analysis_mask)

            n.add_template(dif, self.diff)
            n.add_template(iso, 'iso')
            n.add_template(psc, 'psc')
            n.add_template(bub, 'bub')

            n.add_poiss_model(self.diff, '$A_\mathrm{dif}$', [0,10], False)
            n.add_poiss_model('iso', '$A_\mathrm{iso}$', [0,20], False)
            
            if (np.sum(bub*np.logical_not(analysis_mask)) != 0):
                n.add_poiss_model('bub', '$A_\mathrm{bub}$', [0,10], False)

            # # Add PS at halo location
            # ps_halo_map = np.zeros(hp.nside2npix(self.nside))
            # ps_halo_idx = hp.ang2pix(self.nside, np.pi/2. - b*np.pi/180., l*np.pi/180.) # ell and b are in rad
            # ps_halo_map[ps_halo_idx] = 1.
            # ps_halo_map_smoothed = ksi.smooth_the_map(ps_halo_map) # smooth it
            # n.add_template(ps_halo_map_smoothed,'ps_halo')
            # n.add_poiss_model('ps_halo', 'ps_halo', [0,100], False)

            if self.floatDM:
                if ebin >= 7: 
                    # Don't float DM in initial scan for < 1 GeV. Below here
                    # Fermi PSF is so large that we find the DM often picks up
                    # spurious excesses in MC.
                    n.add_template(DM_template_smoothed, 'DM')
                    n.add_poiss_model('DM', '$A_\mathrm{DM}$', [0,1000], False)

            if self.float_ps_together:
                n.add_poiss_model('psc', '$A_\mathrm{psc}$', [0,10], False)
            else:
                # Astropy-formatted coordinates of cluster
                c2 = SkyCoord("galactic", l=[l]*u.deg, b=[b]*u.deg)
                idx3fgl_10, _, _, _ = c2.search_around_sky(self.c3, 10*u.deg)
                idx3fgl_18, _, _, _ = c2.search_around_sky(self.c3, 18*u.deg)
                
                ps_map_outer = np.zeros(hp.nside2npix(self.nside))
                for i3fgl in idx3fgl_18:
                    ps_file = np.load(ps_indiv_dir + '/ps_temp_128_5_'+str(self.eventtype)+'_'+str(i3fgl)+'.npy')
                    ps_map = np.zeros(hp.nside2npix(self.nside))
                    ps_map[np.vectorize(int)(ps_file[::,ebin,0])] = ps_file[::,ebin,1]
                    if i3fgl in idx3fgl_10: # If within 10 degrees, float individually
                        n.add_template(ps_map, 'ps_'+str(i3fgl))
                        n.add_poiss_model('ps_'+str(i3fgl), '$A_\mathrm{ps'+str(i3fgl)+'}$', [0,10], False)
                    else: # Otherwise, add to be floated together
                        ps_map_outer += ps_map

                if np.sum(ps_map_outer) != 0:
                    n.add_template(ps_map_outer, 'ps_outer')
                    n.add_poiss_model('ps_outer', '$A_\mathrm{ps_outer}$', [0,10], False)
                
            n.configure_for_scan()

            ##########
            # Minuit #
            ##########

            # Skip this step if there is 0 data (higher energy bins)
            if np.sum(data*np.logical_not(analysis_mask)) != 0: 
                keys = n.poiss_model_keys
                limit_dict = {}
                init_val_dict = {}
                step_size_dict = {}
                for key in keys:
                    if key == 'DM':
                        limit_dict['limit_'+key] = (0,1000)
                    else:
                        limit_dict['limit_'+key] = (0,50)
                    init_val_dict[key] = 0.0
                    step_size_dict['error_'+key] = 1.0
                other_kwargs = {'print_level': self.verbose, 'errordef': 1}
                z = limit_dict.copy()
                z.update(other_kwargs)
                z.update(limit_dict)
                z.update(init_val_dict)
                z.update(step_size_dict)
                f = call_ll(len(keys),n.ll,keys)
                m = Minuit(f,**z)
                m.migrad(ncall=30000, precision=1e-14)
                
            ###################################
            # NPTFit fixed DM and bkg profile #
            ###################################
            
            # Make background sum and initiate second scan
            # If was no data leave bkg_sum as 0
            bkg_sum = np.zeros(len(data))
            if np.sum(data*np.logical_not(analysis_mask)) != 0:
                for key in keys:
                    if key != 'DM': # Don't add DM in here
                        if m.values[key] != 0:
                            bkg_sum += n.templates_dict[key]*m.values[key]
                        else: # If zero, use ~parabolic error
                            bkg_sum += n.templates_dict[key]*m.errors[key]/2.
            
            
            nDM = nptfit.NPTF(tag='dm_o'+str(self.iobj)+'_E'+str(ebin)+self.mc_tag)
            if self.Asimov: # Use background expectation for the data
                nDM.load_data(Asimov_data[ebin], fermi_exposure)
                nDM.add_template(Asimov_data[ebin], 'bkg_sum')
            else:
                nDM.load_data(data, fermi_exposure)
                nDM.add_template(bkg_sum, 'bkg_sum')
            
            # If there is no data, only go over pixels where DM is non-zero
            if np.sum(data*np.logical_not(analysis_mask)) != 0:
                nDM.load_mask(analysis_mask)
            else:
                nodata_mask = DM_template_smoothed == 0
                nDM.load_mask(nodata_mask)
            nDM.add_poiss_model('bkg_sum', '$A_\mathrm{bkg}$', fixed=True, fixed_norm=1.0)
            
            #####################
            # Get intensity LLs #
            #####################
                               
            for iA, A in enumerate(A_ary):
                new_n2 = copy.deepcopy(nDM)
                new_n2.add_template(A*DM_template_smoothed,'DM')
                new_n2.add_poiss_model('DM','DM',False,fixed=True,fixed_norm=1.0)
                new_n2.configure_for_scan()
                max_LL = new_n2.ll([])
                
                LL_inten_ary[iebin, iA] = max_LL
                inten_ary[iebin, iA] = DM_intensity_base*A

        np.savez(self.save_dir + 'LL_inten_o'+str(self.iobj)+self.mc_tag, LL=LL_inten_ary, intens=inten_ary)
xsec=results.xsec

#IC file name
force_mask_at_bin_number = emin #hard-coded for now


#for the scan
run_tag_energy = run_tag #+ '-' +str(emin) + '-' + str(emax)

print 'maps_dir is ', maps_dir

newstyle=1 # This is a keyword to activate some of my newstyle codes whilst we keep the old around for legacy reasons

#########################
#configure for fermi
f = fp.fermi_plugin(maps_dir,fermi_data_dir=fermi_data_dir,work_dir=work_dir,CTB_en_min = emin,CTB_en_max=emax,nside=nside,eventclass=eventclass,eventtype=eventtype,newstyle=newstyle)

if mask_type!='False':
    f.make_ps_mask(mask_type = mask_type,force_energy = True,energy_bin = force_mask_at_bin_number) #
f.add_diffuse_newstyle(comp = diff, eventclass = eventclass, eventtype = eventtype)
f.add_bubbles(comp='bubs')
f.add_iso(comp='iso')
if ps_model:
    f.add_ps_model(comp = 'ps_model')
# f.add_ps(0,0,0.15)
if norm_file!='False':
    f.use_template_normalization_file(norm_file)

#######################################
###PSF
f.load_psf(data_name='p8',fits_file_path = 'False',eventclass=eventclass,eventtype=eventtype)
Exemplo n.º 22
0
def main():
    global plot_ll_profile, eachps_dict, eachps_En_center

    # Need the PSF a number of times in this calculation. Rather than continually calculating it, do it once and for all here using the fermi plugin
    # NB: will later want to compute the King function parameters here too
    # Determine PSF using fermi plugin
    loadforpsf = fp.fermi_plugin(maps_dir,fermi_data_dir=fermi_data_dir,work_dir=work_dir,CTB_en_min = emin,CTB_en_max=emax,nside=nside,eventclass=eventclass,eventtype=eventtype,newstyle=newstyle)
    loadforpsf.load_psf(data_name='p8',fits_file_path = 'False',eventclass=eventclass,eventtype=eventtype)
    sigma_PSF_deg = loadforpsf.sigma_PSF_deg[0:-1]

    # The strategy from here is as follows:
    #   Break the point source lists up into groups of n_ps_run, in order of ranking
    #   For each group we float each point source individually and extract its normalisation
    #   Next we create a template combining each of the point sources just fitted
    #   This is done at the analysis step
    #   Then we repeat this for the next group, but add in a template of all the point sources
    #   already run, and repeat this process till all point sources have been run
    #   After this we perform a run with the full ps map to get its spectrum
    #   Then we rerun each ps one by one to get its TS while fixing the rest

    for i in range(n_groups):
        if i+1 == n_groups:
            n_ps_groupi = n_last_group
        else:
            n_ps_groupi = n_ps_run

        # Setup for scan
        if method=='minuit' and run==False:
            pass
        else:
            print 'setting up the scan.  the method is', method
            setup_for_scan(i=i,n_ps_groupi=n_ps_groupi,larr=larr,barr=barr,
                           psloop1=True)
            print 'finished setting up the scan.'

        # Perform scan / load scan
        if run:
            print 'The nside for this scan is ', b.nside
            if method=='multinest':
                b.perform_scan(run_tag = run_tag_energy)
                do_analysis(i=i,n_ps_groupi=n_ps_groupi,minuit_new=False,psloop1=True)
            elif method=='minuit':
                b.perform_scan_minuit(run_tag = run_tag_energy)
                b.save_minuit()
                do_analysis(i=i,n_ps_groupi=n_ps_groupi,minuit_new=True,psloop1=True)

    # Now perform run to extract to spectrum of all point sources combined
    # Setup for scan
    if method=='minuit' and run==False:
        pass
    else:
        print 'setting up the scan.  the method is', method
        setup_for_scan(pscomball=True)
        print 'finished setting up the scan.'

     # Perform scan / load scan
    if run:
        print 'The nside for this scan is ', b.nside
        if method=='multinest':
            b.perform_scan(run_tag = run_tag_energy)
            do_analysis(pscomball=True,minuit_new=False)
        elif method=='minuit':
            b.perform_scan_minuit(run_tag = run_tag_energy)
            b.save_minuit()
            do_analysis(pscomball=True,minuit_new=True)

    # Now loop over all point sources, floating one at a time with the others fixed
    # From this we want to extract their TS and spectrum

    # Initialise empty dictionary to put the spectra in
    eachps_dict = {}

    # Now run through loop
    for i in range(n_ps):
        # Setup for scan
        if method=='minuit' and run==False:
            pass
        else:
            print 'setting up the scan.  the method is', method
            setup_for_scan(i=i,larr=larr,barr=barr,psloop2=True)
            print 'finished setting up the scan.'

        # Perform scan / load scan
        if run:
            print 'The nside for this scan is ', b.nside
            if method=='multinest':
                b.perform_scan(run_tag = run_tag_energy)
                do_analysis(i=i,minuit_new=False,psloop2=True)
            elif method=='minuit':
                b.perform_scan_minuit(run_tag = run_tag_energy)
                b.save_minuit()
                do_analysis(i=i,minuit_new=True,psloop2=True)

    # Finally save the spectra dictionary
    eachps_savefile = ps_spec_dir + save_spect_label_ps
    if os.path.isfile(eachps_savefile + '.npy'):
        print 'appending to eachps spectrum ...'
        spect = list(np.load(eachps_savefile + '.npy'))
        spect += [[ eachps_En_center, eachps_dict]]
        np.save(eachps_savefile,np.array(spect))
    else:
        print 'saving eachps spectra for first time'
        spect = [[ eachps_En_center, eachps_dict]]
        np.save(eachps_savefile,np.array(spect))