def generate_initial_params(data_bg_mul2, data_bg_mul8, seed=5):
# fit to the data distributions
bg_params = Parameters()
bg_params.add_many(
('alpha', -1.80808e+01, True, 1e-20, 20, None, None),
('beta', -8.21174e-02, True, -10, -1e-20, None, None),
('gamma', 8.06289e-01, True, 1e-20, 10, None, None)
)
bg_model = Model(bg_pdf, bg_params)
bg_fitter = NLLFitter(bg_model)
bg_result = bg_fitter.fit(data_bg_mul2, calculate_corr=False)
n_bg = len(data_bg_mul8)
gRandom.SetSeed(seed)
# Set up bg sampling
bg_pdf_ROOT = functools.partial(bg_pdf, doROOT=True)
tf1_bg_pdf = TF1("tf1_bg_pdf", bg_pdf_ROOT, 2800, 13000, 3)
tf1_bg_pdf.SetParameters(*bg_result.x)
mc_bg = [tf1_bg_pdf.GetRandom() for i in range(n_bg)]
be_bg = bayesian_blocks(mc_bg, p0=0.02)
be_bg[-1] += 0.1
be_bg = np.append(be_bg, [13000])
be_bg[0] = 2800
# print be_bg
# hist(data_bg_mul8, bins=be_bg, scale='binwidth')
# plt.show()
return bg_result, n_bg, be_bg
def generate_initial_params(data_bg_mul2, data_bg_mul8, seed=5):
# fit to the data distributions
bg_model = ff.Model(bg_pdf, ['alpha', 'beta', 'gamma'])
bg_model.set_bounds([(1e-20, 20), (-10, -1e-20), (1e-20, 10)])
bg_fitter = ff.NLLFitter(bg_model, data_bg_mul2)
bg_result = bg_fitter.fit([-1.80808e+01, -8.21174e-02, 8.06289e-01])
n_bg = len(data_bg_mul8)
gRandom.SetSeed(seed)
# Set up bg sampling
bg_pdf_ROOT = functools.partial(bg_pdf, doROOT=True)
tf1_bg_pdf = TF1("tf1_bg_pdf", bg_pdf_ROOT, 2800, 13000, 3)
tf1_bg_pdf.SetParameters(*bg_result.x)
mc_bg = [tf1_bg_pdf.GetRandom() for i in range(n_bg)]
be_bg = bayesian_blocks(mc_bg, p0=0.02)
be_bg[-1] += 0.1
be_bg = np.append(be_bg, [13000])
be_bg[0] = 2800
# print be_bg
# hist(data_bg_mul8, bins=be_bg, scale='binwidth')
# plt.show()
return bg_result, n_bg, be_bg
def createhists(procs,binning,nevts):
"""Prepare histograms for simulated data-MC comparison."""
# BINNING
if len(binning)==3: # constant binning
nbins, xmin, xmax = binning
elif len(binning)==1: # variable binning
nbins = len(binning[0])-1
binning = (nbins,array('d',list(binning[0])))
else:
raise IOError("Wrong binning: %s"%(binning))
# EXPECTED: PSEUDO MC
exphists = [ ]
tothist = None
gRandom.SetSeed(1777)
for hname, htitle, scale, generator, args in procs:
hist = TH1D(hname,htitle,*binning)
hist.Sumw2()
for j in xrange(nevts):
hist.Fill(generator(*args))
hist.Scale(scale)
hist.SetFillColor(coldict.get(hname,kWhite))
exphists.append(hist)
if tothist:
tothist.Add(hist)
else:
tothist = hist.Clone('total')
# OBSERVED: PSEUDO DATA
datahist = TH1D('data','Observed',*binning)
datahist.SetBinErrorOption(TH1D.kPoisson)
if LOG.verbosity>=1:
print ">>> createhists: Creating pseudo data:"
TAB = LOG.table("%5s [%5s, %5s] %-14s %-20s",
"%5d [%5s, %5s] %8.1f +- %5.1f %8d +%5.1f -%5.1f")
TAB.printheader('bin','xlow','xup','exp','data')
for ibin in xrange(0,nbins+2):
exp = tothist.GetBinContent(ibin)
xlow = hist.GetXaxis().GetBinLowEdge(ibin)
xup = hist.GetXaxis().GetBinUpEdge(ibin)
experr = tothist.GetBinError(ibin)
#if ibin==int(0.3*nbins): # add a large deviation to test points falling off ratio plot
# exp *= 0.5
#elif ibin==int(0.8*nbins): # add a large deviation to test points falling off ratio plot
# exp *= 1.51
data = int(gRandom.Poisson(exp))
datahist.SetBinContent(ibin,data)
if LOG.verbosity>=1:
TAB.printrow(ibin,xlow,xup,exp,experr,data,datahist.GetBinErrorUp(ibin),datahist.GetBinErrorLow(ibin))
return datahist, exphists
def createhists(nhist=3):
nbins = 50
xmin = 0
xmax = 100
nevts = 10000
rrange = 0.5
hists = [ ]
gRandom.SetSeed(1777)
for i in xrange(1,nhist+1):
mu = 48+i
sigma = 10
hname = "hist%d"%(i)
htitle = "#mu = %s, #sigma = %s"%(mu,sigma)
hist = TH1D(hname,hname,nbins,xmin,xmax)
for j in xrange(nevts):
hist.Fill(gRandom.Gaus(mu,sigma))
hists.append(hist)
return hists
def __init__(self, parse):
#energy of electron beam, GeV
self.Ee = parse.getfloat("main", "Ee")
#proton beam, GeV
self.Ep = parse.getfloat("main", "Ep")
print("Ee =", self.Ee, "GeV")
print("Ep =", self.Ep, "GeV")
#minimal photon energy, GeV
self.emin = parse.getfloat("main", "emin")
print("emin =", self.emin)
#electron and proton mass
self.me = TDatabasePDG.Instance().GetParticle(11).Mass()
self.mp = TDatabasePDG.Instance().GetParticle(2212).Mass()
self.mep = self.me * self.mp
#CMS energy squared, GeV^2
self.s = 2 * self.Ee * self.Ep + self.me**2 + self.mp**2
self.s += 2 * TMath.Sqrt(self.Ee**2 -
self.me**2) * TMath.Sqrt(self.Ep**2 -
self.mp**2)
print("s =", self.s, "GeV^2")
#normalization, 4 alpha r_e^2
self.ar2 = 4 * 7.297 * 2.818 * 2.818 * 1e-2 # m barn
#parametrizations for dSigma/dy and dSigma/dtheta
gRandom.SetSeed(5572323)
self.eq1par = self.eq1(self)
self.dSigDy = TF1("dSigDy", self.eq1par, self.emin / self.Ee, 1)
tmax = 1.5e-3 #maximal photon angle
self.eq3par = self.eq3(self)
self.dSigDtheta = TF1("dSigDtheta", self.eq3par, 0, tmax)
#uniform generator for azimuthal angles
self.rand = TRandom3()
self.rand.SetSeed(5572323)
print("H1 parametrization initialized")
print("Total cross section: " +
str(self.dSigDy.Integral(self.emin / self.Ee, 1)) + " mb")
def __init__(self, parse):
#electron beam, GeV
self.Ee = parse.getfloat("main", "Ee")
#proton beam, GeV
self.Ep = parse.getfloat("main", "Ep")
print("Ee =", self.Ee, "GeV")
print("Ep =", self.Ep, "GeV")
#minimal photon energy, GeV
self.emin = parse.getfloat("main", "emin")
print("emin =", self.emin)
#maximal photon angle
self.tmax = 1.5e-3
if parse.has_option("main", "tmax"):
self.tmax = parse.getfloat("main", "tmax")
#electron and proton mass
self.me = TDatabasePDG.Instance().GetParticle(11).Mass()
self.mp = TDatabasePDG.Instance().GetParticle(2212).Mass()
self.mep = self.me * self.mp
#normalization, 4 alpha r_e^2
self.ar2 = 4*7.297*2.818*2.818*1e-2 # m barn
#parametrizations for dSigma/dE_gamma and dSigma/dtheta
gRandom.SetSeed(5572323)
self.eq1par = self.eq1(self)
self.dSigDe = TF1("dSigDe", self.eq1par, self.emin, self.Ee)
self.theta_const = 1e-11 # constant term in theta formula
self.eq2par = self.eq2(self)
self.dSigDtheta = TF1("dSigDtheta", self.eq2par, 0, self.tmax)
#uniform generator for azimuthal angles
self.rand = TRandom3()
self.rand.SetSeed(5572323)
print("ZEUS parametrization initialized")
print("Total cross section: "+str(self.dSigDe.Integral(self.emin, self.Ee))+" mb")
hfile.Close()
hfile = TFile('hsimple.root', 'RECREATE', 'Demo ROOT file with histograms')
# Create some histograms, a profile histogram and an ntuple
hpx = TH1F('hpx', 'This is the px distribution', 100, -4, 4)
hpxpy = TH2F('hpxpy', 'py vs px', 40, -4, 4, 40, -4, 4)
hprof = TProfile('hprof', 'Profile of pz versus px', 100, -4, 4, 0, 20)
ntuple = TNtuple('ntuple', 'Demo ntuple', 'px:py:pz:random:i')
# Set canvas/frame attributes.
hpx.SetFillColor(48)
gBenchmark.Start('hsimple')
# Initialize random number generator.
gRandom.SetSeed()
gauss, rndm = gRandom.Gaus, gRandom.Rndm
# For speed, bind and cache the Fill member functions,
histos = ['hpx', 'hpxpy', 'hprof', 'ntuple']
for name in histos:
exec '%sFill = %s.Fill' % (name, name)
# Fill histograms randomly.
kUPDATE = 1000
for i in xrange(25000):
# Generate random values.
px = gauss()
py = gauss()
pz = px * px + py * py
random = rndm(1)
be_10GeV[i + 1])
true_sig_bc_10GeV.append(true_sig * n_sig)
signif_nll_fit_hist = []
signif_nll_constrained_hist = []
signif_nll_true_hist = []
signif_nll_true_fit_hist = []
signif_bb_true_hist = []
signif_bb_shape_hist = []
signif_1GeV_true_hist = []
signif_2GeV_true_hist = []
signif_5GeV_true_hist = []
signif_10GeV_true_hist = []
# Do a bunch of toys
gRandom.SetSeed(20)
for i in tqdm_notebook(list(range(1000))):
mc_bg, mc_sig = generate_toy_data(tf1_bg_pdf, tf1_sig_pdf, n_bg, n_sig)
mc_bg_sig = mc_bg + mc_sig
q0_nll_fit = generate_q0_via_nll_unbinned(mc_bg_sig)
signif_nll_fit_hist.append(np.sqrt(q0_nll_fit))
q0_nll_constrained = generate_q0_via_nll_unbinned_constrained(
mc_bg, mc_bg_sig, bg_result.x)
signif_nll_constrained_hist.append(np.sqrt(q0_nll_constrained))
q0_nll_true = generate_q0_via_nll_unbinned(
mc_bg_sig,
bg_params=[-0.957, 0.399, -0.126],
be_100GeV = np.linspace(2800, 13000, 103)
be_200GeV = np.linspace(2800, 13000, 52)
be_400GeV = np.linspace(2800, 13000, 26)
be_1000GeV = np.linspace(2800, 13000, 11)
be_2000GeV = np.linspace(2800, 13000, 6)
true_bg_bc_bb = get_true_bin_content(be_bg, bg_pdf, bg_result.x)
true_bg_bc_50GeV = get_true_bin_content(be_50GeV, bg_pdf, bg_result.x)
true_bg_bc_100GeV = get_true_bin_content(be_100GeV, bg_pdf, bg_result.x)
true_bg_bc_200GeV = get_true_bin_content(be_200GeV, bg_pdf, bg_result.x)
true_bg_bc_400GeV = get_true_bin_content(be_400GeV, bg_pdf, bg_result.x)
true_bg_bc_1000GeV = get_true_bin_content(be_1000GeV, bg_pdf, bg_result.x)
true_bg_bc_2000GeV = get_true_bin_content(be_2000GeV, bg_pdf, bg_result.x)
# Do a bunch of toys
gRandom.SetSeed(seed)
bg_sig_model = ff.Model(bg_sig_pdf,
['C', 'mu', 'sigma', 'alpha', 'beta', 'gamma'])
# sig_params = [(4000, 800), (5000, 1000), (6000, 1200), (7000, 1400)]
# sig_params = [(4750, 970), (5350, 1070), (6000, 1200), (6600, 1300),
# (7150, 1440), (7800, 1500), (8380, 1660)]
sig_params = [(5350, 1070), (6000, 1200), (6600, 1300), (7150, 1440),
(7800, 1500), (8380, 1660)]
# sig_params = [(7150, 1440)]
unbinned_A_mle = [[] for i in range(len(sig_params))]
binned_A_mle = [[] for i in range(len(sig_params))]
binned_A_hybrid_mle = [[] for i in range(len(sig_params))]
binned_A_50_mle = [[] for i in range(len(sig_params))]
binned_A_100_mle = [[] for i in range(len(sig_params))]
def __init__(self, parse, tree):
#electron and proton energy, GeV
self.Ee = parse.getfloat("main", "Ee")
self.Ep = parse.getfloat("main", "Ep")
print("Ee, GeV =", self.Ee)
print("Ep, GeV =", self.Ep)
#A and Z of the nucleus
self.A = 1
self.Z = 1
if parse.has_option("main", "A"):
self.A = parse.getint("main", "A")
if parse.has_option("main", "Z"):
self.Z = parse.getint("main", "Z")
print("A:", self.A)
print("Z:", self.Z)
#minimal photon energy, GeV
self.emin = parse.getfloat("main", "emin")
print("emin, GeV =", self.emin)
#alpha r_e^2
self.ar2 = 7.297 * 2.818 * 2.818 * 1e-2 # m barn
#electron and nucleus mass
self.me = TDatabasePDG.Instance().GetParticle(11).Mass()
self.mp = TDatabasePDG.Instance().GetParticle(2212).Mass()
self.mn = self.A * self.mp
#nucleus beam vector
nvec = TLorentzVector()
pz_a = TMath.Sqrt(self.Ep**2 - self.mp**2) * self.Z
en_a = TMath.Sqrt(pz_a**2 + self.mn**2)
nvec.SetPxPyPzE(0, 0, pz_a, en_a)
print("Nucleus beam gamma:", nvec.Gamma())
#boost vector of nucleus beam
self.nbvec = nvec.BoostVector()
#electron beam vector
evec = TLorentzVector()
evec.SetPxPyPzE(0, 0, -TMath.Sqrt(self.Ee**2 - self.me**2), self.Ee)
print("Electron beam gamma:", evec.Gamma())
#electron beam energy in nucleus beam rest frame
evec.Boost(-self.nbvec.x(), -self.nbvec.y(), -self.nbvec.z())
self.Ee_n = evec.E()
print("Ee_n, GeV:", self.Ee_n)
#minimal photon energy in nucleus rest frame
eminv = TLorentzVector()
eminv.SetPxPyPzE(0, 0, -self.emin, self.emin)
eminv.Boost(-self.nbvec.x(), -self.nbvec.y(), -self.nbvec.z())
emin_n = eminv.E()
print("emin_n, GeV:", emin_n)
#maximal delta in nucleus frame
dmax_n = 100.
if parse.has_option("main", "dmax_n"):
dmax_n = parse.getfloat("main", "dmax_n")
print("dmax_n:", dmax_n)
#cross section formula
self.eqpar = self.eq(self)
self.dSigDwDt = TF2("dSigDwDt", self.eqpar, emin_n, self.Ee_n, 0,
dmax_n)
self.dSigDwDt.SetNpx(2000)
self.dSigDwDt.SetNpy(2000)
gRandom.SetSeed(5572323)
#total integrated cross section over all delta (to 1e5)
dSigInt = TF2("dSigInt", self.eqpar, emin_n, self.Ee_n, 0, 1e5)
sigma_tot = dSigInt.Integral(emin_n, self.Ee_n, 0, 1e5)
print("Total cross section, mb:", sigma_tot)
#uniform generator for azimuthal angles
self.rand = TRandom3()
self.rand.SetSeed(5572323)
#tree output from the generator
tlist = ["true_phot_w", "true_phot_delta", "true_phot_theta_n"]
tlist += ["true_phot_theta", "true_phot_phi", "true_phot_E"]
tlist += ["true_el_theta", "true_el_phi", "true_el_E"]
self.tree_out = self.set_tree(tree, tlist)
print("Lifshitz_93p16 parametrization initialized")
def Simulate(self, save=None, draw=None):
'''
:param save: if True: saves the root file as well as the true signal distribution
:param draw: if True draws the signal distribution
:param ask:
:return:
'''
# Settings:
MPV = self.MCAttributes['Landau_MPV_bkg'] # background for Landau MPV distribution
sigma = self.MCAttributes['Landau_Sigma'] # Landau scaling sigma
NPeaks = self.MCAttributes['NPeaks']
MCRunPath = self.MCAttributes['MCRunPath'].format(self.RunNumber)
xmin = self.diamond.Position['xmin'] + 0.01
xmax = self.diamond.Position['xmax'] - 0.01
ymin = self.diamond.Position['ymin'] + 0.01
ymax = self.diamond.Position['ymax'] - 0.01
center_x = (xmax + xmin) / 2.
center_y = (ymax + ymin) / 2.
if draw != None:
assert (type(draw) == t.BooleanType), "draw has to be boolean type"
self.MCAttributes['DrawRealDistribution'] = draw
if save != None:
assert (type(save) == t.BooleanType), "save argument has to be of type boolean"
self.MCAttributes['Save'] = save
def ManualHitDistribution(x, par):
'''
Probability density function for hit distribution based on
6 2d gaussian in a rectangular pattern. The PDF is NOT
normalized to 1
:param x: array, x[0]: x position, x[1]: y position
:param par: parameter array;
:return:
'''
result = 0.1 # bkg
norm = 1.
sigma = 0.04
for i in range(len(par) / 2):
result += norm * TMath.Gaus(x[0], par[2 * i], sigma) * TMath.Gaus(x[1], par[2 * i + 1], sigma)
return result
def CreateRandomPeaksConfig(xmin, xmax, ymin, ymax, bkg=120, peak_height=0.5, npeaks=NPeaks):
'''
Creates the input parameters for SignalShape, which describes the peak distribution in the
Signal distribution
:param xmin: window parameter
:param xmax: window parameter
:param ymin: window parameter
:param ymax: window parameter
:param bkg: background of signal response
:param peak_height: height of one peak in % of bkg, if bkg==0: the peaks heights are set to 1
:param npeaks: number of peaks in window - if none it picks random between 0 and 15
:return: array containing the parameters
'''
if npeaks == None:
npeaks = int(round(gRandom.Uniform(0, 15)))
if self.MCAttributes['SpecialDistribution'] in ["Central", "central"]:
npeaks = 1
dxy = 0.02
parameters = np.zeros(7)
parameters[0] = npeaks
parameters[1] = bkg
parameters[2] = peak_height
parameters[3] = gRandom.Uniform(center_x - dxy, center_x + dxy)
parameters[4] = gRandom.Uniform(center_y - dxy, center_y + dxy)
parameters[5] = gRandom.Uniform(self.MCAttributes['PeakSigmaX_min'], self.MCAttributes['PeakSigmaX_max'])
parameters[6] = gRandom.Uniform(self.MCAttributes['PeakSigmaY_min'], self.MCAttributes['PeakSigmaY_max'])
elif self.MCAttributes['SpecialDistribution'] in ["4Peaks", "4peaks", "L", "3Peaks"]:
npeaks = 4
dxy = 0.02
parameters = np.zeros(3 + 4 * npeaks)
parameters[0] = npeaks
parameters[1] = bkg
parameters[2] = peak_height
# peaks:
peaknr = 0
for x in [center_x - 0.07, center_x + 0.07]:
for y in [center_y - 0.07, center_y + 0.07]:
parameters[3 + 4 * peaknr] = gRandom.Uniform(x - dxy, x + dxy)
parameters[4 + 4 * peaknr] = gRandom.Uniform(y - dxy, y + dxy)
parameters[5 + 4 * peaknr] = gRandom.Uniform(self.MCAttributes['PeakSigmaX_min'], self.MCAttributes['PeakSigmaX_max'])
parameters[6 + 4 * peaknr] = gRandom.Uniform(self.MCAttributes['PeakSigmaY_min'], self.MCAttributes['PeakSigmaY_max'])
peaknr += 1
if self.MCAttributes['SpecialDistribution'] in ["L", "3Peaks"]:
npeaks = 3
parameters[0] = npeaks
parameters = parameters[:3 + 4 * npeaks]
elif self.MCAttributes['SpecialDistribution'] in ["Testpattern", "testpattern", "Test", "test"]:
npeaks = 8
Center_x = gRandom.Uniform(center_x - 0.01, center_x + 0.01)
Center_y = gRandom.Uniform(center_y - 0.01, center_y + 0.01)
parameters = np.zeros(3 + 4 * npeaks)
parameters[0] = npeaks
parameters[1] = bkg
parameters[2] = peak_height
parameters[3] = Center_x - 0.1
parameters[4] = Center_y + 0.08
parameters[5] = 0.02
parameters[6] = 0.02
parameters[7] = Center_x - 0.04
parameters[8] = Center_y + 0.08
parameters[9] = 0.02
parameters[10] = 0.02
parameters[11] = Center_x - 0.1
parameters[12] = Center_y
parameters[13] = 0.025
parameters[14] = 0.025
parameters[15] = Center_x
parameters[16] = Center_y
parameters[17] = 0.02
parameters[18] = 0.02
parameters[19] = Center_x + 0.1
parameters[20] = Center_y
parameters[21] = 0.03
parameters[22] = 0.03
parameters[23] = Center_x - 0.04
parameters[24] = Center_y - 0.06
parameters[25] = 0.015
parameters[26] = 0.015
parameters[27] = Center_x - 0.12
parameters[28] = Center_y - 0.12
parameters[29] = 0.03
parameters[30] = 0.03
parameters[31] = Center_x + 0.08
parameters[32] = Center_y - 0.12
parameters[33] = 0.04
parameters[34] = 0.04
else:
parameters = np.zeros(3 + 4 * npeaks)
parameters[0] = npeaks
parameters[1] = bkg
parameters[2] = peak_height
for i in range(npeaks):
parameters[3 + 4 * i] = gRandom.Uniform(xmin, xmax)
parameters[4 + 4 * i] = gRandom.Uniform(ymin, ymax)
parameters[5 + 4 * i] = gRandom.Uniform(0.02, 0.07)
parameters[6 + 4 * i] = gRandom.Uniform(0.02, 0.07)
self.MCAttributes['NPeaks'] = npeaks
return parameters
def SignalShape(x, par):
'''
:param x: x[0]: x position
x[1]: y position
:param par: par[0]: number of peaks
par[1]: mean bkg signal
par[2]: peak height in percent of bkg
par[3]: peak1 x position
par[4]: peak1 y position
par[5]: peak1 sigma in x
par[6]: peak1 sigma in y
...
par[3+4*n]: peakn x position
par[4+4*n]: peakn y position
par[5+4*n]: peakn sigma in x
par[6+4*n]: peakn sigma in y
:return:
'''
norm = par[1] * par[2]
result = par[1]
if par[1] == 0:
norm = 1
for i in range(int(par[0])):
result += norm * TMath.Gaus(x[0], par[3 + 4 * i], par[5 + 4 * i]) * TMath.Gaus(x[1], par[4 + 4 * i], par[6 + 4 * i])
return result
# Set seed for random number generator:
today = datetime.today()
seed = int((today - datetime(today.year, today.month, today.day, 0, 0, 0, 0)).total_seconds() % 1800 * 1e6)
gRandom.SetSeed(seed)
# create track_info ROOT file
if not os.path.exists(MCRunPath):
os.makedirs(MCRunPath)
if self.MCAttributes['Save']:
file = TFile(MCRunPath + 'track_info.root', 'RECREATE')
self.track_info = TTree('track_info', 'MC track_info')
track_x = array('f', [0])
track_y = array('f', [0])
integral50 = array('f', [0])
calibflag = array('i', [0])
calib_offset = array('i', [0])
time_stamp = array('f', [0])
self.track_info.Branch('track_x', track_x, 'track_x/F')
self.track_info.Branch('track_y', track_y, 'track_y/F')
self.track_info.Branch('integral50', integral50, 'integral50/F')
self.track_info.Branch('calibflag', calibflag, 'calibflag/I')
self.track_info.Branch('calib_offset', calib_offset, 'calib_offset/I')
self.track_info.Branch('time_stamp', time_stamp, 'time_stamp/F')
# Create Manual Hit Distribution:
if self.MCAttributes['HitDistributionMode'] == 'Manual':
dx = 0.08
dy = 0.07
f_lateral = TF2('f_lateral', ManualHitDistribution, xmin, xmax, ymin, ymax, 12)
f_lateral.SetNpx(80)
f_lateral.SetNpy(80)
# 6 gaus centers:
par = np.array([center_x - dx / 2., # x1
center_y + dy, # y1
center_x + dx / 2., # x2
center_y + dy, # y2
center_x + dx / 2., # x3
center_y, # y3
center_x - dx / 2., # x4
center_y, # y4
center_x - dx / 2., # x5
center_y - dy, # y5
center_x + dx / 2., # x6
center_y - dy # y6
])
f_lateral.SetParameters(par)
a = Double()
b = Double()
# Generate Signal Distribution:
if self.MCAttributes['SignalMode'] == 'Landau':
self.SignalParameters = CreateRandomPeaksConfig(xmin, xmax, ymin, ymax, peak_height=self.MCAttributes['PeakHeight'], bkg=MPV)
else:
self.SignalParameters = CreateRandomPeaksConfig(xmin, xmax, ymin, ymax, peak_height=self.MCAttributes['PeakHeight'], bkg=100)
f_signal = TF2('f_signal', SignalShape, xmin, xmax, ymin, ymax, len(self.SignalParameters))
f_signal.SetNpx(40) # Resolution
f_signal.SetNpy(40)
f_signal.SetParameters(self.SignalParameters)
if self.MCAttributes['DrawRealDistribution']:
canvas = TCanvas('canvas', 'canvas')
canvas.cd()
gStyle.SetPalette(55) # a Rain Bow palette == used.
gStyle.SetNumberContours(8)
f_signal.Draw('surf1')
gPad.Print(MCRunPath + 'RealSignalDistribution.png')
if self.ShowAndWait:
answer = input('for data creation, type `yes`: ')
else:
answer = 'yes'
else:
answer = 'yes'
# Set the Hit distribution for Manual or Import
if self.MCAttributes['HitDistributionMode'] == 'Manual':
HitsTemplate = f_lateral
elif self.MCAttributes['HitDistributionMode'] == 'Import':
HitsTemplate = self.counthisto
mc_start_timestamp = 42. # arbitrary timestamp for the first MC event
MCEventDeltaTime = 30. * 60. / 300000. # 1800s/300000Hits = 0.006s/Hit
tmp_time = mc_start_timestamp
# Generate Toy Data:
if answer == 'yes':
if self.verbose:
self.ShowMCConfig()
self.verbose_print('Creating Toy Data with {0} Hits'.format(self.NumberOfHits))
integral50_max = self.MCAttributes['integral50_max'] # Maximum of Signal response allowed (data: 500 ?)
i = 0
j = 0
while i < self.NumberOfHits and j < 2 * self.NumberOfHits:
# Get x and y
if self.MCAttributes['HitDistributionMode'] == 'Uniform':
track_x[0] = gRandom.Uniform(xmin, xmax)
track_y[0] = gRandom.Uniform(ymin, ymax)
else:
HitsTemplate.GetRandom2(a, b)
track_x[0] = gRandom.Gaus(a, self.MCAttributes['TrackResolution']) # 0.002 = 20mu track resolution (first guess)
track_y[0] = gRandom.Gaus(b, self.MCAttributes['TrackResolution'])
# Get Signal at x and y
if self.MCAttributes['SignalMode'] == 'Landau':
integral50[0] = gRandom.Landau(f_signal(track_x[0], track_y[0]), sigma)
else:
integral50[0] = gRandom.Gaus(f_signal(track_x[0], track_y[0]), 0.6 * f_signal(track_x[0], track_y[0]) - 33)
# check if found values fulfill requirements
if xmin < track_x[0] < xmax and ymin < track_y[0] < ymax and integral50[0] < integral50_max:
tmp_time += MCEventDeltaTime
time_stamp[0] = tmp_time
self.track_info.Fill()
self.Data['track_x'].append(track_x[0])
self.Data['track_y'].append(track_y[0])
self.Data['integral50'].append(integral50[0])
i += 1
j += 1
if not j < 2 * self.NumberOfHits: # if too many times requirements were not fulfilled
assert (False), "Bad MC Parameters"
# Save root file and true Signal Shape:
if self.MCAttributes['Save']:
file.Write()
f_signal.SaveAs(MCRunPath + 'RealSignalDistribution.root')
self.verbose_print(MCRunPath + 'track_info.root has been written')
self.TrackingPadAnalysis['ROOTFile'] = MCRunPath + 'track_info.root'
# Print Settings of created data:
if self.verbose:
print("\nToydata containing {:.0f} peaks generated.".format(self.SignalParameters[0]))
if self.MCAttributes['SignalMode'] == 'Landau':
for i in range(int(self.SignalParameters[0])):
x = self.SignalParameters[3 + 4 * i]
y = self.SignalParameters[4 + 4 * i]
print("Peak {0:.0f} at position: ({1:.3f}/{2:.3f}) with Laundau Response MPV: {3:.2f} Sigma: {4:.1f}".format(i + 1, x, y, f_signal(x, y), sigma))
else:
integral50[0] = gRandom.Gaus(f_signal(track_x[0], track_y[0]), 0.6 * f_signal(track_x[0], track_y[0]) - 33)
for i in range(int(self.SignalParameters[0])):
x = self.SignalParameters[3 + 4 * i]
y = self.SignalParameters[4 + 4 * i]
print("Peak {0:.0f} at position: ({1:.3f}/{2:.3f}) with Gaussian Response Mean: {3:.2f} Sigma: {4:.1f}".format(i + 1, x, y, f_signal(x, y), 0.6 * f_signal(x, y) - 33))
self.DataIsMade = True
self.verbose_print('Monte Carlo Toy Data created.\n')
# Authors: H. Jung,
# A. Bermudez Martinez, L.I. Estevez Banos, J. Lidrych, M. Mendizabal Morentin,
# S. Taheri Monfared, P. L.S. Connor, Q. Wang, H. Yang, R. Zlebcik
#
# Define function which we want to integrate
from ROOT import gRandom
from math import sqrt
def g0(z):
return 3 * z * z
# initialise random number generator:
gRandom.SetSeed(32767)
# Calculate the sum and sum2 of the function values at the random points
xg0 = xg00 = 0
npoints = 1000000
for n in range(npoints):
x0 = gRandom.Uniform()
f = g0(x0)
xg0 += f
xg00 += f**2
# Calculate average and average to the squared values
avg = xg0 / npoints
avg2 = xg00 / npoints
legendLinearPlot[iPt].SetNColumns(3)
if cutSetCfg['linearplot']['uncbands']:
fNfdNpromptUpper.append([])
fNfdNpromptLower.append([])
# apply smearing to raw yields
if doRawYieldsSmearing:
listRawYield.reverse()
listRawYieldSmeared = []
listBkg.reverse()
listDelta = []
listDeltaSmeared = []
listDeltaBkg = []
listDeltaSmearedBkg = []
if cutSetCfg['minimisation']['setseed']:
gRandom.SetSeed(10)
for iRawYeld, _ in enumerate(listRawYield):
if iRawYeld == 0:
listDelta.append(0.)
listDeltaBkg.append(0.)
else:
listDelta.append(listRawYield[iRawYeld] -
listRawYield[iRawYeld - 1])
listDeltaBkg.append(listBkg[iRawYeld] - listBkg[iRawYeld - 1])
listDeltaSmeared.append(
gRandom.PoissonD(listDelta[iRawYeld] + listDeltaBkg[iRawYeld]))
if cutSetCfg['minimisation']['correlated']:
if iRawYeld == 0:
listRawYieldSmeared.append(
gRandom.PoissonD(listRawYield[iRawYeld] +
listBkg[iRawYeld]) -
from ROOT import TCanvas, TFile, TProfile, TNtuple, TH1F, TH2F from ROOT import gROOT, gBenchmark, gRandom, gSystem, Double
# Create a new canvas, and customize it.
c1 = TCanvas( 'c1', 'Dynamic Filling Example', 200, 10, 700, 500 ) c1.SetFillColor( 42 ) c1.GetFrame().SetFillColor( 21 )
c1.GetFrame().SetBorderSize( 6 ) c1.GetFrame().SetBorderMode( -1 )
# Create a new ROOT binary machine independent file. Note that this file may contain any kind of ROOT objects, histograms,
# pictures, graphics objects, detector geometries, tracks, events, etc.. This file is now becoming the current directory.
hfile = gROOT.FindObject( 'py-hsimple.root' ) if hfile:
hfile.Close() hfile = TFile( 'py-hsimple.root', 'RECREATE', 'Demo ROOT file with histograms' )
# Create some histograms, a profile histogram and an ntuple
hpx = TH1F( 'hpx', 'This is the px distribution', 100, -4, 4 ) hpxpy = TH2F( 'hpxpy', 'py vs px', 40, -4, 4, 40, -4, 4 ) hprof =
TProfile( 'hprof', 'Profile of pz versus px', 100, -4, 4, 0, 20 ) ntuple = TNtuple( 'ntuple', 'Demo ntuple', 'px:py:pz:random:i' )
# Set canvas/frame attributes.
hpx.SetFillColor( 48 ) gBenchmark.Start( 'hsimple' )
# Initialize random number generator.
gRandom.SetSeed() rannor, rndm = gRandom.Rannor, gRandom.Rndm
# For speed, bind and cache the Fill member functions,
histos = [ 'hpx', 'hpxpy', 'hprof', 'ntuple' ] for name in histos:
exec('%sFill = %s.Fill' % (name,name))
# Fill histograms randomly.
px, py = Double(), Double() kUPDATE = 1000 for i in range( 25000 ):
# Generate random values.
rannor( px, py )
pz = px*px + py*py
random = rndm(1)
# Fill histograms.
hpx.Fill( px )
hpxpy.Fill( px, py )
hprof.Fill( px, pz )
ntuple.Fill( px, py, pz, random, i )
# Update display every kUPDATE events.
if i and i%kUPDATE == 0:
dest='seed',
type='int',
default=0,
help='random seed for generating toys.')
parser.add_option('-m',
'--mode',
default="HWWconfig",
dest='modeConfig',
help='which config to select from WjjFitterConfigs')
(opts, args) = parser.parse_args()
import generateToyWpJ
from ROOT import gRandom
startingFile = 'TempInitFile.txt'
cpCmd = ['cp', '-v', opts.startingFile, startingFile]
optCmd = [
'python', 'newOptimize.py', '-b', '-j',
str(opts.Nj), '-p',
str(opts.P), '-m', opts.modeConfig, '--init', startingFile, '--dir',
opts.mcdir
]
print ' '.join(cpCmd)
subprocess.call(cpCmd)
if opts.seed > 0:
gRandom.SetSeed(opts.seed)
generateToyWpJ.generate(opts.mcdir, opts.Nj, opts.modeConfig)
print ' '.join(optCmd)
subprocess.call(optCmd)
neutrino_global_normalisation = 0.
for neutrino_name in neutrino_names_list:
neutrino_spectra_dict[neutrino_name] = TH2D(
neutrino_spectra_file.Get(neutrino_name))
neutrino_type_threshold[
neutrino_name] = neutrino_global_normalisation + neutrino_spectra_dict[
neutrino_name].GetSum()
neutrino_global_normalisation += neutrino_spectra_dict[
neutrino_name].GetSum()
print(toolbox.warning, "Opening file containing PREM function :",
parameters["PREM_file"])
PREM_file = TFile.Open(parameters["PREM_file"], "READ")
PREM_TF1 = TF1(PREM_file.Get("PREM_TF1"))
gRandom.SetSeed(
parameters["PRNG_seed"]) # set the generator seed for TH2D.GetRandom2
variables_names_list = list()
# saved variables
variables_names_list.append("PDG_code") # sampled by the norm of each spectrum
variables_names_list.append("E_nu") # sampled by the spectrum
variables_names_list.append(
"R_Earth_emitted") # determined by neutrino_altitude and earth radius
variables_names_list.append("R_SK_emitted") # computed
variables_names_list.append("cos_theta_SK") # sampled by the spectrum
variables_names_list.append("cos_theta_Earth") # computed
variables_names_list.append("phi") # sampled
