def Calclims(): # We are now working in distributions as a function of s1 mlist = np.logspace(1, 3.9, 100) # GeV ULlist_Xenon100T = [] Bdipolenorm = 1e-10 b_dict = load_bkgs() obsT = np.ones_like(s1means) * 35636. obsT2 = np.ones_like(s1means) * 35636. * 100 b = np.array(b_dict[bkgs[0]] / obsT) B = [ b_dict[bkgs[0]] / obsT, b_dict[bkgs[1]] / obsT, b_dict[bkgs[2]] / obsT, b_dict[bkgs[3]] / obsT, b_dict[bkgs[4]] / obsT, b_dict[bkgs[5]] / obsT ] SF = sf.Swordfish(B, T=[0.01, 0.01, 0.01, 0.01, 0.01, 0.01], E=obsT) SF2 = sf.Swordfish(B, T=[0.01, 0.01, 0.01, 0.01, 0.01, 0.01], E=obsT2) ULlist_Xenon1T_milli = [] ULlist_Xenon100T_milli = [] for m in mlist: dRdS = np.array( dRdS1(s1means, m, mu_x=Bdipolenorm, m_dipole=True) * s1width) UL1T = SF.upperlimit(dRdS, 0.1) UL100T = SF2.upperlimit(dRdS, 0.1) ULlist_Xenon1T_milli.append(UL1T * Bdipolenorm**2) ULlist_Xenon100T_milli.append(UL100T * Bdipolenorm**2) ULlist_Xenon1T_milli = np.array(np.sqrt(ULlist_Xenon1T_milli)) ULlist_Xenon100T_milli = np.array(np.sqrt(ULlist_Xenon100T_milli)) return interp1d(mlist, ULlist_Xenon1T_milli), interp1d(mlist, ULlist_Xenon100T_milli)
def plt_lims(): mlist = np.logspace(1, 4., 100) # GeV ULlist_Xenon100T = [] norm01 = 9.756e-10 cp1 = np.zeros(11) cp1[0] = norm01 cn1 = cp1 b_dict = load_bkgs() obsT = np.ones_like(s1means) * 35636. obsT2 = np.ones_like(s1means) * 35636. * 100 b = np.array(b_dict[bkgs[0]] / obsT) B = [ b_dict[bkgs[0]] / obsT, b_dict[bkgs[1]] / obsT, b_dict[bkgs[2]] / obsT, b_dict[bkgs[3]] / obsT, b_dict[bkgs[4]] / obsT, b_dict[bkgs[5]] / obsT ] SF = sf.Swordfish(B, T=[0.01, 0.01, 0.01, 0.01, 0.01, 0.01], E=obsT) SF2 = sf.Swordfish(B, T=[0.01, 0.01, 0.01, 0.01, 0.01, 0.01], E=obsT2) ULlist_Xenon1T = [] ULlist_Xenon100T = [] for m in mlist: dRdS = np.array(dRdS1(s1means, m, cp1, cn1) * s1width) UL1T = SF.upperlimit(dRdS, 0.1) UL100T = SF2.upperlimit(dRdS, 0.1) ULlist_Xenon1T.append(UL1T * norm01**2) ULlist_Xenon100T.append(UL100T * norm01**2) ULlist_Xenon1T = np.sqrt(np.array(ULlist_Xenon1T)) ULlist_Xenon100T = np.sqrt(np.array(ULlist_Xenon100T)) mp = 0.938 # GeV mu = mlist * mp / (mlist + mp) sig_SI_X1T = (ULlist_Xenon1T)**2 * (mu**2 / np.pi) * (1.98e-14**2) sig_SI_X100T = (ULlist_Xenon100T)**2 * (mu**2 / np.pi) * (1.98e-14**2) plt.loglog(mlist, sig_SI_X1T, label=r"UL XENON1T (2017)") plt.loglog(mlist, sig_SI_X100T, label=r"UL XENONnT") plt.scatter(mlist[np.argmax(ULlist_Xenon1T)], np.max(ULlist_Xenon1T)) temp = interp1d(mlist, sig_SI_X1T) return temp(10**3.9)
def getSwordfish(self, E=None, ignore_cov=False): if E is not None and type(E) != float: E = E.flatten() B = self.__call__().flatten() if not ignore_cov: K = self.cov() else: K = None SF = sf.Swordfish([B], K=K, E=E) return SF
def Calclims(): # We are now working in distributions as a function of s1 norm01 = 9.756e-10 mlist = np.logspace(1, 3.9, 100) # GeV cp = np.random.randn(11) cp[:] = 0. cp[0] = norm01 cn = cp ULlist = [] b_dict = load_bkgs() obsT = np.ones_like(s1means)*35636. obsT2 = np.ones_like(s1means)*35636.*100 b = np.array(b_dict[bkgs[0]]/obsT) B = [b_dict[bkgs[0]]/obsT, b_dict[bkgs[1]]/obsT, b_dict[bkgs[2]]/obsT, b_dict[bkgs[3]]/obsT, b_dict[bkgs[4]]/obsT, b_dict[bkgs[5]]/obsT] SF = sf.Swordfish(B, T=[0.01,0.01,0.01,0.01,0.01,0.01], E=obsT) SF2 = sf.Swordfish(B, T=[0.01,0.01,0.01,0.01,0.01,0.01], E=obsT2) norm01 = 9.756e-10 mlist = np.logspace(1, 3.9, 100) # GeV cp = np.random.randn(11) cp[:] = 0. cp[0] = norm01 cn = cp ULlist = [] ULlist_Xenon100T = [] for i, m in enumerate(mlist): dRdS = dRdS1(s1means, m, cp, cn)*s1width UL = SF.upperlimit(dRdS, 0.1) UL100 = SF2.upperlimit(dRdS, 0.1) ULlist_Xenon100T.append(UL100*norm01**2) ULlist.append(UL*norm01**2) ULlist = np.array(np.sqrt(ULlist)) ULlist_Xenon100T = np.array(np.sqrt(ULlist_Xenon100T)) # plt.loglog(mlist, ULlist) # plt.loglog(mlist, ULlist_Xenon100T) # plt.show() return interp1d(mlist, ULlist), interp1d(mlist, ULlist_Xenon100T)
def lnL(): x = np.linspace(1, 10, 20) flux = [x**2.4, x / 2] noise = np.ones_like(flux[0]) exposure = np.ones_like(flux[0]) * 0.1 systematics = np.ones((20, 20)) * 1. #systematics = None s = sf.Swordfish(flux, noise, systematics, exposure) #syst = noise.copy() #syst[1] *= 2.000 print s.profile_lnL(np.array([0.25, 1.0]), np.array([0.23, 1.0]), free_thetas=np.array([False, True]))
def test_MW_dSph(): nside = 32 def plot_harp(h, filename): m = h.get_healpix(128) vmax = np.log10(m).max() vmin = vmax - 2 hp.mollview(np.log10(m), nest=True, min=vmin, max=vmax) plt.savefig(filename) dims = () # Signal definition spec = 1. MW = harp.HARPix(dims=dims).add_iso(2).add_singularity((0, 0), 0.1, 2., n=10) MW.add_func(lambda d: spec / (1 + d)**2, mode='dist', center=(0, 0)) pos = (50, 40) # dSph = harp.HARPix(dims = dims).add_singularity(pos, 0.1, 20, n = 10) # dSph.add_func(lambda d: 0.1*spec/(.1+d)**2, mode = 'dist', center=pos) sig = MW #+ dSph sig.data += .001 # EGBG plot_harp(sig, 'sig.eps') # Background definition bg = harp.HARPix(dims=dims).add_iso(64) bg.add_func(lambda l, b: 1 / (b + 1)**2) plot_harp(bg, 'bg.eps') # Covariance matrix definition cov = harpix_Sigma(sig) cov.add_systematics(err=bg * 0.1, sigma=10., Sigma=None, nside=0) # Set up swordfish fluxes = [sig.data.flatten()] noise = bg.get_formatted_like(sig).data.flatten() systematics = cov exposure = np.ones_like(noise) * 0.001 m = sf.Swordfish(fluxes, noise, systematics, exposure, solver='direct') F = m.effectiveinfoflux(0) f = harp.HARPix.from_data(sig, F) plot_harp(f, 'test.eps')
def test(): H = harp.HARPix().add_iso(4).add_disc((80, 00), 40, 16).add_disc((-80, 00), 40, 16) H.data += 1. # Covariance matrix definition cov = harpix_Sigma(H) flat = harp.HARPix().add_iso(16, fill=1.) cov.add_systematics(err=flat * .1, sigma=3, Sigma=None, nside=128) # Set up swordfish fluxes = [H.get_data(mul_sr=True)] noise = fluxes[0] expmap = noise * 0. + 1e5 systematics = cov m = sf.Swordfish(fluxes, noise, systematics, expmap, solver='cg') F = m.effectiveinfoflux(0) f = harp.HARPix.from_data(H, F, div_sr=True) print min(f.data), max(f.data) m = f.get_healpix(128) hp.mollview(m, nest=True) plt.savefig("MW.eps")
def Euclideanizemilli(nsamples=100000): Limit1, Limit2 = Calclims() b_dict = load_bkgs() obsT = np.ones_like(s1means) * 35636. * 100 b = np.array(b_dict[bkgs[0]] / obsT) B = [ b_dict[bkgs[0]] / obsT, b_dict[bkgs[1]] / obsT, b_dict[bkgs[2]] / obsT, b_dict[bkgs[3]] / obsT, b_dict[bkgs[4]] / obsT, b_dict[bkgs[5]] / obsT ] couplings = [] ESXe = [] ESAr = [] NXe = [] NAr = [] NuisanceES = [] ms = np.logspace(1, 3.9, nsamples / 1000) sigmav_mean = 156.0 err_sigv = 13. vesc_mean = 533.0 err_vesc = 54. vlag_mean = 242.0 err_vlag = 10. from random import randint sigmav = np.random.uniform(sigmav_mean - (2. * err_sigv), sigmav_mean + (2. * err_sigv), int(nsamples)) vesc = np.random.uniform(vesc_mean - (2. * err_vesc), vesc_mean + (2. * err_vesc), int(nsamples)) vlag = np.random.uniform(vlag_mean - (2. * err_vlag), vlag_mean + (2. * err_vlag), int(nsamples)) random_points = np.unique( [randint(0, vlag.shape[0] - 1) for _ in range(int(nsamples * 0.2))]) sigmav[random_points] = sigmav_mean vesc[random_points] = vesc_mean vlag[random_points] = vlag_mean for m in tqdm(ms, desc="Euclideanizing Xenon-nT"): i = 0 coupling_temp = np.logspace(np.log10(Limit1(m)), np.log10(Limit2(m)), nsamples / 100) for mu_x in coupling_temp: couplings.append([m, 0., mu_x]) dRdS, Nsig = np.array( dRdS1(s1means, m, mu_x=mu_x, m_dipole=True, Nevents=True, sigmav=sigmav[i], vesc=vesc[i], vlag=vlag[i])) SF = sf.Swordfish(B, T=[0.01, 0.01, 0.01, 0.01, 0.01, 0.01], E=obsT) NXe.append(Nsig * obsT[0]) ES_temp = SF.euclideanizedsignal(dRdS * s1width) NuisanceES_temp = [(sigmav[i] - sigmav_mean) / err_sigv] NuisanceES_temp.append((vesc[i] - vesc_mean) / err_vesc) NuisanceES_temp.append((vlag[i] - vlag_mean) / err_vlag) NuisanceES.append(NuisanceES_temp) ESXe.append(ES_temp) i += 1 couplings = np.array(couplings) obsT = np.ones_like(ER_c) * 1422. obsT2 = np.ones_like(ER_c) * 1422. * 100. * 50. b = np.zeros_like(ER_c) + 0.1 / obsT2 / len(ER_c) SFAr = sf.Swordfish([b], T=[0.01], E=obsT2) eff_temp = load_efficiency() for i, m in enumerate(tqdm(couplings[:, 0], desc="Euclideanizing DS20k")): m = couplings[i, 0] mu_x = couplings[i, 2] dRdE = dRdEAr(m, ER_c, eff_temp, mu_x=mu_x, m_dipole=True, sigmav=sigmav[i], vesc=vesc[i], vlag=vlag[i]) ES_temp = SFAr.euclideanizedsignal(dRdE * ER_width) ESAr.append(ES_temp) ####################### ESXe = np.array(ESXe) ESAr = np.array(ESAr) NXe = np.array(NXe) NuisanceES = np.array(NuisanceES) # Output to new hdf5 outfile = "../hdf5/Xenon100T_DS20k_gridscanBdipole_HaloTrue.hdf5" hf = h5py.File(outfile, 'w') hf.create_dataset('ESAr', data=ESAr) hf.create_dataset('ESXe', data=ESXe) hf.create_dataset('NuisanceES', data=NuisanceES) hf.create_dataset('c', data=couplings) hf.create_dataset('NXe', data=NXe) # hf.create_dataset('NAr', data=NAr) hf.close() return None
def DD(m_DM, UL=True): """ This routine will try to recreate the limits from 1708.08571 for the CRESST-III Experiment, a future version of CRESST""" c_kms = c * 1.e-3 # in km s^-1 GeV_kg = 1.8e-27 sGeV = 1 / 6.58e-25 mGeV = 1 / 0.197e-15 kgs = sGeV / GeV_kg # = kg * s in natural units h = 4.135667662e-15 # eV s h_MeVs = h / 1.e6 m_DM *= 1.e3 # conversion to MeV rho_0 = 0.3 # GeV/cm3 rho_0 *= 1e3 * 1e2**3 / mGeV**3 * 1e3**3 # GeV/cm3 --> MeV^4 xi_T = 1. # FIXME: Need real values m_T = 68. * 1.e3 # MeV FIXME: Need real values, currently set to Germanium m_med = 10. # MeV muT = m_DM * m_T / (m_DM + m_T) # Define energy range in MeV E = np.linspace(0.1 * 1e-3, 2. * 1e-3, num=19) Ewidth = E[1] - E[0] Emeans = E[0:-1] + Ewidth / 2. def eta_F(): v, gave = np.loadtxt("DD_files/gave.dat", unpack=True, dtype=float) f = interp1d(v, gave) # Natural units return f def dRdE(E_R): """Return differential recoil rate in 1/s/keV/kg.""" # g is the parameter we wish to set a limit on so is left out # Form factor taken from eq4.4 of http://pa.brown.edu/articles/Lewin_Smith_DM_Review.pdf # TODO: Z,A,theta dependence missing # FIXME: Should correct for realistic form factor F_T = lambda E_R: np.sqrt(np.exp(-(1. / 3.) * (E_R**2.))) vmin = lambda E_R: np.sqrt(m_T * E_R / 2 / (muT**2.)) eta = eta_F() signal = rho_0 * xi_T * g2 * F_T(E_R)**2 * eta( vmin(E_R)) / 2. / np.pi / m_DM / ((2 * m_T * E_R + m_med**2)**2) signal *= kgs # 1/MeV --> 1/s/MeV/kg return signal def ScatterProb(q, E1, E2): # CRESST definitions # Energy resoultion is set by a Gaussian at 20 eV # FIXME: Check energy resolution implementation # var = lambda x: np.exp(((x-muCRESST)**2.)/2./(sigmaCRESST**2))/2./np.pi E_R = q**2. / 2. / m_T # var = 20.*1.e-6 # MeV var = 1. # MeV # print erf((E1-E_R)/np.sqrt(2)/var) prob = (erf((E2 - E_R) / np.sqrt(2) / var) - erf( (E1 - E_R) / np.sqrt(2) / var)) / 2. # prob = 1. # print "Probability", prob return prob Eth = 100 * 1e-6 # threshold energy [MeV] Vesc = 544. / c_kms Vobs = 232. / c_kms qmin = np.sqrt(2. * m_T * Eth) # MeV qmax = 2. * muT * (Vesc + Vobs) # MeV E_Rmin = qmin**2. / 2. / m_T E_Rmax = qmax**2. / 2. / m_T if qmin > qmax: print "Skip m_DM [GeV]", m_DM * 1e-3 return None # sig = np.zeros(len(Emeans)) # sig_dif = lambda ER, x1, x2: ScatterProb(ER, x1, x2)*dRdE(ER) # # for i in range(len(Emeans)): # sig[i] = quad(sig_dif, E_Rmin, E_Rmax, args=(E[i],E[i+1]))[0] sig = dRdE(Emeans) * Ewidth # print dRdE_A, qdiff # print Emeans, sig # plt.loglog(Emeans, sig) # plt.xlabel(r'$E_R (MeV)$') # plt.ylabel(r'$dR/dE_R$') # plt.show() # quit() ################################### Background definitions # Backgrounds # For CREST-III we assume 1000kg days of exposure with energy threshold of 100eV. There are 19 bins between 0.1 and 2 keV # Background level assumed to be 3.5e-2 keV^-1 kg^-1 day^-1 #bkg = np.zeros(len(E)) #bkg += 3.5 bkg = np.ones_like(sig) * 3.5e-2 * (Ewidth * 1e3) / (3600. * 24) # Covariance matrix for energy spectrum uncertainty (ad hoc) # Sigma = get_sigma(Emeans, lambda x, y: np.exp(-(x-y)**2/2/(x*y)/0.5**2)) # Set up the swordfish unc = 0.01 # 1% bkg uncertainty corr_length = 1 # 10 deg correlation length of bkg uncertainty ################################### Exposure Goes here obsT = np.ones_like(sig) * 100 * 3600 # 100 hours of observation in s if UL: systematics = None m = sf.Swordfish(sig, bkg, systematics, obsT, solver='cg', verbose=True) # Calculate upper limits with effective counts method ec = sf.EffectiveCounts(m) UL = ec.upperlimit(0.05, 0, gaussian=True) s, b = ec.effectivecounts(0, 1.) print "DM mass [GeV]:", m_DM * 1e-3 print "Total signal counts (theta = 1):", ec.counts(0, 1.0) print "Eff. signal counts (theta = 1):", s print "Eff. bkg counts (theta = 1) :", b print "Upper limit on theta :", UL #F = m.effectiveinfoflux(0) #f = harp.HARPix.from_data(sig, F, div_sr = True) #m = f.get_healpix(512, idxs=(3,)) #hp.mollview(m, nest = True) #plt.savefig('test.eps') return UL else: # fluxes, noise, systematics, exposure = get_model_input([sig, dsig], bkg, # [dict(err = bkg*unc, sigma = corr_length, Sigma = None, nside = # 0)], expo) # systematics = None m = sf.Swordfish(fluxes, noise, systematics, exposure, solver='cg', verbose=False) F = m.fishermatrix() return F
def CTA(m_DM, UL=True, syst_flag=True, Tobs=100.): # Parameters E = Logbins(1.0, 3.0, 50) # GeV 10 GeV - 10 TeV unc = 0.01 # 1% bkg uncertainty corr_length = 1 # 10 deg correlation length of bkg uncertainty Sigma = get_sigma(E.means, lambda x, y: np.exp(-(x - y)**2 / 2 / (x * y) / 0.5**2)) sv0 = 1e-26 # Get J-value map J = get_Jmap() # Define signal spectrum t = sf.func_to_templates(lambda x, y: get_sig_spec(x * sv0, y, E), [1., m_DM], dx=[.01, m_DM * 0.01]) # Get signal maps S = J.expand(t[0]) dS = J.expand(t[1]) # Get background (instr.) B = get_instr_bkg(E) # FIXME? # plt.loglog(E.means, B.get_integral()/4./np.pi) # plt.loglog(E.means, S.get_integral()/4./np.pi) # plt.show() # quit() # Get exposure expo = get_exposure(E, Tobs) flux = [ S, ] if UL else [dS, S] fluxes, noise, systematics, exposure = get_model_input( flux, B, [dict(err=B * unc, sigma=corr_length, Sigma=Sigma, nside=0)], expo) if not syst_flag: systematics = None m = sf.Swordfish(fluxes, noise, systematics, exposure, solver='direct', verbose=False) if UL: # Calculate upper limits with effective counts method ec = sf.EffectiveCounts(m) x_UL = ec.upperlimit(0.05, 0, gaussian=True) sv_UL = x_UL * sv0 s, b = ec.effectivecounts(0, 1.) # print "Total signal counts (theta = 1):", ec.counts(0, 1.0) # print "Eff. signal counts (theta = 1):", s # print "Eff. bkg counts (theta = 1) :", b # print "Upper limit on theta :", sv_UL return sv_UL else: F = m.fishermatrix() # w.r.t. (x,m) F[1, 1] /= sv0**2 F[0, 1] /= sv0 F[1, 0] /= sv0 return F
def MW_dSph(): nside = 32 bg_hpx, exposure_hpx = get_BG() dims = () J = get_Jmap() Jex = get_extragalactic() J = J + Jex # Signal definition spec = 1. dSph = harp.HARPix(dims=dims).add_iso(1, fill=1.) pos_list = [(50, 40), (-20, 30), (80, -80), (42, -15)] Jlist = [3e21, 3e21, 6e21, 2e21] for J0, pos in zip(Jlist, pos_list): dSph = dSph.add_singularity(pos, 0.1, 5, n=10) #dSph = harp.HARPix(dims = dims).add_disc(pos, 10, 62).add_disc((50,-40), 10, 32) dSph.add_func(lambda d: J0 / (.1 + d)**2, mode='dist', center=pos) sig = J + dSph #sig.data += 1e21 # EGBG plot_harp(sig, 'sig.eps', maxfac=1.0) # Background definition #bg = harp.HARPix(dims = dims).add_iso(64) bg = harp.HARPix.from_healpix(bg_hpx, nest=False) plot_harp(bg, 'bg.eps', maxfac=0.01) exposure = harp.HARPix.from_healpix(exposure_hpx, nest=False) # Covariance matrix definition cov = harpix_Sigma(sig) bg_flat = deepcopy(bg) bg_flat.data *= 0 bg_flat.data += 1e-8 # cov.add_systematics(err = bg_flat*0.1, sigma = .25, Sigma = None, nside =64) # cov.add_systematics(err = bg_flat*0.1, sigma = .5, Sigma = None, nside =16) # cov.add_systematics(err = bg_flat*0.1, sigma = 1., Sigma = None, nside =16) # cov.add_systematics(err = bg_flat*0.1, sigma = 2., Sigma = None, nside =64) # cov.add_systematics(err = bg_flat*0.1, sigma = 3., Sigma = None, nside =64) # cov.add_systematics(err = bg_flat*0.1, sigma = 4., Sigma = None, nside =64) # cov.add_systematics(err = bg_flat*0.1, sigma = 7., Sigma = None, nside =64) cov.add_systematics(err=bg_flat * 0.1, sigma=10., Sigma=None, nside=64) cov.add_systematics(err=bg_flat * 0.3, sigma=1e10, Sigma=None, nside=8) cov.add_systematics(err=bg_flat * 0.1, sigma=20., Sigma=None, nside=64) #cov.add_systematics(err = bg_flat*0.1, sigma = 25., Sigma = None, nside = 1) #cov.add_systematics(err = bg_flat*0.1, sigma = 30., Sigma = None, nside = 1) #cov.add_systematics(err = bg_flat*0.1, sigma = 35., Sigma = None, nside = 1) #cov.add_systematics(err = bg_flat*0.1, sigma = 40., Sigma = None, nside = 1) # Set up swordfish fluxes = [sig.get_data(mul_sr=True)] noise = bg.get_formatted_like(sig).get_data(mul_sr=True) expmap = exposure.get_formatted_like(sig).get_data() * 1e-4 systematics = cov #systematics = None m = sf.Swordfish(fluxes, noise, systematics, expmap, solver='cg') F = m.effectiveinfoflux(0) f = harp.HARPix.from_data(sig, F, div_sr=True) plot_harp(f, 'MW.eps', maxfac=0.1)
def load_bkgs(): b = dict() for i in range(len(bkgs)): S1, temp = np.loadtxt("../DD_files/" + bkgs[i] + ".txt", unpack=True) interp = interp1d(S1, temp, bounds_error=False, fill_value=0.0) b[bkgs[i]] = interp(s1means) return b mlist = np.logspace(1, 3.9, 100) # GeV b_dict = load_bkgs() obsT = np.ones_like(s1means)*35636. obsT2 = np.ones_like(s1means)*35636.*100 B = [b_dict[bkgs[0]]/obsT, b_dict[bkgs[1]]/obsT, b_dict[bkgs[2]]/obsT, b_dict[bkgs[3]]/obsT, b_dict[bkgs[4]]/obsT, b_dict[bkgs[5]]/obsT] SF1 = sf.Swordfish(B, T=[0.01,0.01,0.01,0.01,0.01,0.01], E=obsT) SF2 = sf.Swordfish(B, T=[0.01,0.01,0.01,0.01,0.01,0.01], E=obsT2) def genO1(Euclideanize=False): norm01 = 9.756e-10 cp = np.zeros([11]) cp[0] = norm01 cn = cp ULlist = [] ULlist_Xenon100T = [] for i, m in enumerate(mlist): dRdS = dRdS1(s1means, m, cp, cn)*s1width UL1 = SF1.upperlimit(dRdS, 0.1) ULlist.append(UL1*norm01**2)
eff2 = np.append(eff2 / 100., eff2_extra) return interp1d(eff1, eff2) def dRdE(m, E, c, eff): s = eff(E) * DMU.dRdE_NREFT(E, m, c, c, "Ar40") + 1.e-30 return s eff_temp = load_eff() obsT = np.ones_like(ER_c) * 1422. obsT2 = np.ones_like(ER_c) * 1422. * 100. * 50. #BJK: Changed this from obsT to obsT2 b = np.zeros_like(ER_c) + 0.1 / obsT2 / len(ER_c) SF2 = sf.Swordfish(b, T=[0.01], E=obsT2) #print(obsT2) #print(b) ################## root01 = h5py.File('../hdf5/Xenon100T_gridscan01_Euclideanized_dRdS1.hdf5') couplings01 = np.array(root01['c']) ES01 = np.array(root01['ES']) mass01 = np.array(root01['mass']) ESAr = [] for i in tqdm(range(0, len(mass01)), desc="Euclideanizing"): cp = couplings01[i, :11] signal = dRdE(mass01[i], ER_c, cp, eff_temp) * ER_width
def main(): E = np.linspace(0, 11, 100) m = np.linspace(2, 10, 20) # mass (peak position) n = np.linspace(1, 10, 20) # flux strength (normalization) I = np.zeros( (len(n), len(m), 2, 2)) # Fisher metric (cartesian coordinates) UL = np.zeros(len(m)) for i, m0 in enumerate(m): for j, n0 in enumerate(n): sigma = 0.7 flux = sf.func_to_templates( lambda m, n: 1 / sigma * n * np.exp(-0.5 * (m - E)**2 / sigma**2), [m0, n0]) noise = E**2 + 10 exposure = np.ones_like(E) * 1.0 mysf = sf.Swordfish(flux, noise, None, exposure) I[j, i] = mysf.fishermatrix() flux = sf.func_to_templates( lambda n: 1 / sigma * n * np.exp(-0.5 * (m0 - E)**2 / sigma**2), [1]) mysf = sf.Swordfish(flux, noise, None, exposure) ef = sf.EffectiveCounts(mysf) UL[i] = ef.upperlimit(0.95, 0) tf = mp.TensorField(m, n, I) # tf.quiver() vf1, vf2 = tf.get_VectorFields() mask = lambda x, y: y > np.interp(x, m, UL) lines = vf1.get_streamlines([5, 3], Nmax=200, mask=mask) for line in lines: plt.plot(line.T[0], line.T[1], '0.5', lw=1.0) lines = vf2.get_streamlines([5, 3], Nmax=200, mask=mask) for line in lines: plt.plot(line.T[0], line.T[1], '0.5', lw=1.0) contour = tf.get_contour([8, 4.0], 1, Npoints=328) plt.plot(contour.T[0], contour.T[1], 'b') contour = tf.get_contour([8, 4.0], 2, Npoints=328) plt.plot(contour.T[0], contour.T[1], 'b--') contour = tf.get_contour([8, 4.0], 3, Npoints=1000) plt.plot(contour.T[0], contour.T[1], 'b:') contour = tf.get_contour([4, 7.0], 1, Npoints=128) plt.plot(contour.T[0], contour.T[1], 'b') contour = tf.get_contour([4, 7.0], 2, Npoints=128) plt.plot(contour.T[0], contour.T[1], 'b--') contour = tf.get_contour([4, 7.0], 3, Npoints=128) plt.plot(contour.T[0], contour.T[1], 'b:') plt.plot(m, UL, 'r') plt.xlim([2, 10]) plt.ylim([0, 10]) plt.savefig('test.eps')
S1, temp = np.loadtxt("../DD_files/" + bkgs[i] + ".txt", unpack=True) interp = interp1d(S1, temp, bounds_error=False, fill_value=0.0) b[bkgs[i]] = interp(s1means) return b bkgs = ['acc', 'Anom', 'ElectronRecoil', 'n', 'Neutrino', 'Wall'] b_dict = load_bkgs() obsT = np.ones_like(s1means) * 35636. b = np.array(b_dict[bkgs[0]] / obsT) B = [ b_dict[bkgs[0]] / obsT, b_dict[bkgs[1]] / obsT, b_dict[bkgs[2]] / obsT, b_dict[bkgs[3]] / obsT, b_dict[bkgs[4]] / obsT, b_dict[bkgs[5]] / obsT ] SF = sf.Swordfish(B, T=[0.01, 0.01, 0.01, 0.01, 0.01, 0.01], E=obsT) def Volumes(Argon=True): if Argon: filename = '../hdf5/Xenon_DS_250000_' else: filename = '../hdf5/Xenon100T_' R_01 = [] R_011 = [] mlist = np.logspace(1, 4, 100) # Calculates the number of signal events in XENONnT for each point for m in mlist: