示例#1
0
def init(Nexp, NMC, energy=True, **kwargs):
    Nsrc = kwargs.pop("Nsrc", 0)

    arr_exp = exp(Nexp - Nsrc)
    arr_mc = MC(NMC)

    if Nsrc > 0:
        inj = PointSourceInjector(2, sinDec_bandwidth=1, seed=0)
        inj.fill(0., arr_mc, 333.)

        source = inj.sample(Nsrc, poisson=False).next()[1]

        arr_exp = np.append(arr_exp, source)

    if energy:
        llh_model = PowerLawLLH(["logE"], min(50, Nexp // 50),
                                range=[[0.9 * arr_mc["logE"].min(),
                                        1.1 * arr_mc["logE"].max()]],
                                sinDec_bins=min(50, Nexp // 50),
                                sinDec_range=[-1., 1.],
                                bounds=(0, 5))
    else:
        llh_model = UniformLLH(sinDec_bins=max(3, Nexp // 200),
                               sinDec_range=[-1., 1.])

    llh = PointSourceLLH(arr_exp, arr_mc, 365., llh_model=llh_model,
                         mode="all", hemispheres=dict(Full=[-np.inf, np.inf]),
                         nsource=25, scramble=False,
                         nsource_bounds=(-Nexp / 2., Nexp / 2.)
                                        if not energy else (0., Nexp / 2.),
                         seed=np.random.randint(2**32),
                         **kwargs)

    return llh
示例#2
0
 def initialize_injector(self, e_range=(0., np.inf)):
     inj = PointSourceInjector(
         gamma = self.index, 
         E0 = 1000., 
         e_range=e_range)
     inj.fill(
         self.dec,
         self.llh.exp,
         self.llh.mc,
         self.llh.livetime,
         temporal_model=self.llh.temporal_model)
     self.inj = inj
示例#3
0
文件: data.py 项目: mhuber89/skylab
def init(Nexp, NMC, energy=True, **kwargs):
    Nsrc = kwargs.pop("Nsrc", 0)

    arr_exp = exp(Nexp - Nsrc)
    arr_mc = MC(NMC)

    if Nsrc > 0:
        inj = PointSourceInjector(2, sinDec_bandwidth=1, seed=0)
        inj.fill(0., arr_mc, 333.)

        source = inj.sample(Nsrc, poisson=False).next()[1]

        arr_exp = np.append(arr_exp, source)

    if energy:
        llh_model = PowerLawLLH(
            ["logE"],
            min(50, Nexp // 50),
            range=[[0.9 * arr_mc["logE"].min(), 1.1 * arr_mc["logE"].max()]],
            sinDec_bins=min(50, Nexp // 50),
            sinDec_range=[-1., 1.],
            bounds=(0, 5))
    else:
        llh_model = UniformLLH(sinDec_bins=max(3, Nexp // 200),
                               sinDec_range=[-1., 1.])

    llh = PointSourceLLH(arr_exp,
                         arr_mc,
                         365.,
                         llh_model=llh_model,
                         mode="all",
                         hemispheres=dict(Full=[-np.inf, np.inf]),
                         nsource=25,
                         scramble=False,
                         nsource_bounds=(-Nexp / 2.,
                                         Nexp / 2.) if not energy else
                         (0., Nexp / 2.),
                         seed=np.random.randint(2**32),
                         **kwargs)

    return llh
def sensitivity_skylab(Gamma=2, src_dec=0, n_iter=1000, n_bckg=100000):
    inj = PointSourceInjector(Gamma,
                              sinDec_bandwidth=.1,
                              src_dec=src_dec,
                              seed=0)
    return PointSourceLLH.weighted_sensitivity(llh,
                                               src_ra=0.0,
                                               src_dec=src_dec,
                                               alpha=.5,
                                               beta=.9,
                                               inj=inj,
                                               mc=mc,
                                               n_iter=n_iter)
# create classic likelihood model
llh_model = ClassicLLH(sinDec_bins=sinDec_bins,
                       sinDec_range=[sinDec_min, sinDec_max],
                       MCbackground=MCbackground)

# specify a point source likelihood based on classicLLH
psllh = PointSourceLLH(exp, mc, livetime,
                       scramble=True, seed=args.seed,
                       llh_model=llh_model,
                       mode = "box",
                       delta_ang=numpy.radians(10.*1.0),
                       nside=128)

# make an injector to model point sources
print ""
inj = PointSourceInjector(gamma=args.index,E0=args.E0,seed=args.seed)
inj.fill(src_dec, mc, livetime)

################
# SKYLAB SETUP #
################

###############################################################################

##################
# 5 SIGMA SEARCH #
##################

print "\nSearching for 5 sigma ... "
ns_min = args.ns_bounds[0]
ns_max = args.ns_bounds[1]
示例#6
0
    ax_p.set_xlabel("Sigma / $1^\circ$")
    ax_p.set_ylabel("Probability Density")

    fig_E.savefig("figures/energy.pdf")
    fig_p.savefig("figures/mrs.pdf")
    plt.show()
    plt.close("all")

    ### LLH SCAN ###

    fig, ax = plt.subplots()

    for mu, Gamma in zip([20, 40, 30], gamma):
        print("\tgamma =", Gamma)
        # init a injector class sampling events at a point source
        inj = PointSourceInjector(Gamma, sinDec_bandwidth=1., seed=0)
        inj.fill(0., mc, 333.)

        n = 25
        gamma = np.linspace(*llh.par_bounds[1], num=n)

        ntrials = 100
        T = list()

        nsources = np.linspace(0.5 * mu, 2. * mu, 2 * n)

        for i in range(ntrials):
            # Inject always the same number of events for this plot
            n_inj, inject = inj.sample(mu, poisson=False).next()

            TS, xmin = llh.fit_source(np.pi, 0., inject=inject)
示例#7
0
def config(seasons,
           seed=1,
           scramble=True,
           e_range=(0, np.inf),
           verbose=True,
           gamma=2.0,
           dec=0.,
           remove=False,
           src_w=None):
    r""" Configure multi season point source likelihood and injector. 

  Parameters
  ----------
  seasons : list
    List of season names
  seed : int
    Seed for random number generator

  Returns
  -------
  multillh : MultiPointSourceLLH
    Multi year point source likelihood object
  inj : PointSourceInjector
     Point source injector object
  """

    print("Scramble is %s" % str(scramble))

    # store individual llh as lists to prevent pointer over-writing
    llh = []

    multillh = MultiPointSourceLLH(seed=seed, ncpu=25)

    # setup likelihoods
    if verbose: print("\n seasons:")
    for season in np.atleast_1d(seasons):

        sample = season[0]
        name = season[1]

        exp, mc, livetime = Datasets[sample].season(name)
        sinDec_bins = Datasets[sample].sinDec_bins(name)
        energy_bins = Datasets[sample].energy_bins(name)

        if sample == "GFU" and remove:
            exp = Datasets['GFU'].remove_ev(
                exp, 58018.87118560489)  # remove EHE 170922A

        mc = mc[mc["logE"] > 1.]

        if verbose:
            print("   - % 15s : % 15s" % (sample, name))
            vals = (livetime, exp.size, min(exp['time']), max(exp['time']))
            print(
                "     (livetime %7.2f days, %6d events, mjd0 %.2f, mjd1 %.2f)"
                % vals)

        llh_model = EnergyLLH(twodim_bins=[energy_bins, sinDec_bins],
                              allow_empty=True,
                              bounds=[1., 4.],
                              seed=2.,
                              kernel=1)

        llh.append(
            StackingPointSourceLLH(exp,
                                   mc,
                                   livetime,
                                   mode="box",
                                   scramble=scramble,
                                   llh_model=llh_model,
                                   nsource_bounds=(0., 1e3),
                                   nsource=15.))

        multillh.add_sample(sample + " : " + name, llh[-1])

        # save a little RAM by removing items copied into LLHs
        del exp, mc

    # END for (season)

    #######
    # LLH #
    #######

    #############################################################################

    ############
    # INJECTOR #
    ############

    inj = PointSourceInjector(gamma=gamma,
                              E0=1 * TeV,
                              seed=seed,
                              e_range=e_range)
    inj.fill(dec, multillh.exp, multillh.mc, multillh.livetime, src_w)

    ############
    # INJECTOR #
    ############

    #############################################################################

    if verbose:
        print("\n fitted spectrum:")
        vals = (inj.E0 / TeV)
        print("   - dN/dE = A (E / %.1f TeV)^-index TeV^-1cm^-2s^-1" % vals)
        print("   - index is *fit*")

        print("\n injected spectrum:")
        vals = (inj.E0 / TeV, inj.gamma)
        print("   - dN/dE = A (E / %.1f TeV)^-%.2f TeV^-1cm^-2s^-1" % vals)

    return (multillh, inj)
示例#8
0
elif catalog == 'Milagro17':
    llh = datascript.init86I(mode='box')
else:
    if years == 7:
        if mese:
            llh = datascript.load7yr_mese(mode='box', sirin=sirin)
        else:
            llh = datascript.load7yr(mode='box', sirin=sirin)
    elif years == 4:
        llh = datascript.load4yr(mode='box', sirin=True, nopull=True)
    elif years == 1:
        print("Using IC86")
        llh = datascript.init86I(mode='box')

llhmodel, exp, MC = llh[0], llh[1], llh[2]
inj = PointSourceInjector(Gamma, seed=0)
inj.fill(src_dec, exp, MC, livetime=llhmodel.livetime)

if disc:
    print("Calculating Discovery Potential...")
    alpha = norm.sf(5)
    beta = 0.5
    TSval = TSval5sig
    calctype = "disc"
else:
    print("Calculating Sensitivity...")
    alpha = 0.5
    beta = 0.9
    TSval = TSval_median
    calctype = "sens"
示例#9
0
        l = "w/"
        if not energy:
            l += "o"

            llh.llh_model = (UniformLLH(sinDec_bins=max(
                3,
                len(llh.exp) // 200),
                                        sinDec_range=[-1., 1.]), mc)

        props = dict()
        sens = list()
        disc = list()
        for j, gamma in enumerate(Gamma):
            # init a injector class sampling events at a point source
            inj = PointSourceInjector(gamma, sinDec_bandwidth=1.)

            # start calculation for dec = 0
            result = llh.weighted_sensitivity(0., [0.5, 2.87e-7], [0.9, 0.5],
                                              inj,
                                              mc,
                                              n_bckg=10000,
                                              n_iter=1000,
                                              eps=1.e-2,
                                              **props)

            props["TSval"] = result["TSval"]

            sens.append(result["mu"][0])
            disc.append(result["mu"][1])
示例#10
0
##########
# SKYLAB #
##########

#llh and inj#

import load_j7yr_npz as datascript
if n == 7:
    llh, exp, mc = datascript.load7yr()
elif n == 4:
    llh, exp, mc = datascript.load4yr()
elif n == 3:
    llh, exp, mc = datascript.load3yr()

inj = PointSourceInjector(gamma=gamma,
                          E0=1 * TeV,
                          seed=args.seed,
                          e_range=(0, np.inf))
inj.fill(src_dec, exp, mc, llh.livetime, src_w)

##########
# SKYLAB #
##########

outputfolder = '/data/user/brelethford/Output/npz/'
sens_dir = misc.ensure_dir(
    outputfolder +
    'stacking_sensitivity/{0}yr/{1}/{2}/sig/gamma_{3}/{4}/'.format(
        n, cat, weight, gamma, n_inj))

###############################################################################
示例#11
0
        l = "w/"
        if not energy:
            l += "o"

            model = UniformLLH(sinDec_bins=max(3,
                                               len(llh.exp) // 200),
                               sinDec_range=[-1., 1.])

            llh.set_llh_model(model, mc)

        ts = None
        sens = list()
        disc = list()
        for j, gamma in enumerate(Gamma):
            # init a injector class sampling events at a point source
            inj = PointSourceInjector(gamma, sinDec_bandwidth=1.)
            inj.fill(0., mc, llh.livetime)

            # start calculation for dec = 0
            result = llh.weighted_sensitivity(np.pi,
                                              0., [0.5, 2.87e-7], [0.9, 0.5],
                                              inj,
                                              TSval=ts,
                                              n_iter=1000,
                                              n_bckg=10000,
                                              eps=1e-2)[0]

            ts = result["TS"]
            sens.append(result["mu"][0])
            disc.append(result["mu"][1])
示例#12
0
        llh = datascript.load7yr()
elif years == 4:
    llh = datascript.load4yr()
elif years == 3:
    llh = datascript.load3yr()
elif years == 1:
    if catalog == 'Milagro17':
        print("Using IC40")
        llh = datascript.loadIC40()
    else:
        print("Using IC86")
        llh = datascript.load1yr()

#Set up Injector:
TeV = 1000
inj = PointSourceInjector(gamma=2., E0=1 * TeV, seed=0)
inj.fill(src_dec, llh[0].exp, llh[0].mc, llh[0].livetime)

#inj.fill(src_dec, exp, MC, livetime = llhmodel.livetime)

if disc:
    print("Calculating Discovery Potential...")
    alpha = norm.sf(5)
    beta = 0.5
    TSval = TSval5sig
    calctype = "disc"
else:
    print("Calculating Sensitivity...")
    alpha = 0.5
    beta = 0.9
    TSval = TSval_median
示例#13
0
###############################################################################

##########
# SKYLAB #
##########

import load_j7yr_npz as datascript
if n == 7:
  llh, exp, mc = datascript.load7yr()
elif n == 4:
  llh, exp, mc = datascript.load4yr()
elif n == 3:
  llh, exp, mc = datascript.load3yr()

inj = PointSourceInjector(gamma = gamma, E0 = 1*TeV, e_range=(0,np.inf))
inj.fill(src_dec, exp, mc, llh.livetime, src_w)


##########
# SKYLAB #
##########

outputfolder = '/data/user/brelethford/Output/npz/'
sens_dir = misc.ensure_dir (outputfolder+'stacking_sensitivity/{0}yr/{1}/{2}/'.format(n,cat,weight))
bg_dir = sens_dir+'bg/'
sig_dir = misc.ensure_dir(sens_dir+'sig/gamma_{}/'.format(gamma))

#For Plots:
dir_name = misc.ensure_dir("/data/user/brelethford/AGN_Core/Plots/npz/plots/stacking/{}yr/{}/{}/{}/".format(n,cat,weight,gamma))
subprocess.call(['mkdir', '-p', '{0}'.format(dir_name)])