def __init__(self): #interaction cross section, mb self.sigma_tot = 0. #instantaneous luminosity, cm^-2 sec^-1 self.lumi_cmsec = 0. #number of bunches self.nbunch = 0. #electron beam energy, GeV self.Ee = 0. #coincidence selection self.emin = 1. # GeV #collider circumference, speed of light, electron mass self.circ = 3834. # m self.cspeed = 299792458. # m sec^-1 self.me = TDatabasePDG.Instance().GetParticle(11).Mass() # GeV #input self.tree = TChain("DetectorTree") #geometry self.geo = None #output file name self.outfile = "hits_spect.root"
def __init__(self, funcName, minMass, maxMass, numSigmaSideBands=0., peakMass=0., peakSigma=0., secPeakMass=0., secPeakSigma=0.): if funcName not in self.__implFunc: raise ValueError(f'Function \'{funcName}\' not implemented') self.funcName = funcName self.minMass = minMass self.maxMass = maxMass self.peakMass = peakMass self.peakDelta = peakSigma * numSigmaSideBands self.secPeakMass = secPeakMass self.secPeakDelta = secPeakSigma * numSigmaSideBands self.funcSBCallable = None self.funcFullCallable = None self.removePeak = False self.removeSecPeak = False if self.peakMass > 0. and self.peakDelta > 0.: self.removePeak = True if self.secPeakMass > 0. and self.secPeakDelta > 0.: self.removeSecPeak = True self.mPi = TDatabasePDG.Instance().GetParticle(211).Mass()
def __init__(self, parse, tree, hepmc_attrib): #minumum and maximum energy, GeV self.emin = parse.getfloat("main", "emin") self.emax = parse.getfloat("main", "emax") print("emin =", self.emin) print("emax =", self.emax) #pdg for generated particle, electron or photon self.pdg = 22 if parse.has_option("main", "pdg"): self.pdg = parse.getint("main", "pdg") print("pdg =", self.pdg) #angular range, electrons for now self.theta_min = 0. self.theta_max = 0. #angles as mlt = -log_10(pi - theta) if parse.has_option("main", "mlt_min"): mlt_min = parse.getfloat("main", "mlt_min") mlt_max = parse.getfloat("main", "mlt_max") print("mlt_min =", mlt_min) print("mlt_max =", mlt_max) self.theta_min = TMath.Pi() - 10.**(-mlt_min) self.theta_max = TMath.Pi() - 10.**(-mlt_max) print("theta_min =", self.theta_min) print("theta_max =", self.theta_max) #generator functions for photons and electrons self.gen_func = {} self.gen_func[22] = self.gen_phot self.gen_func[11] = self.gen_el #test for pdg if self.gen_func.get(self.pdg) is None: print("Fatal: pdg", self.pdg, "is not supported") raise KeyError #uniform generator self.rand = TRandom3() self.rand.SetSeed(5572323) #electron mass self.me = TDatabasePDG.Instance().GetParticle(11).Mass() #set the output tree if self.pdg == 22: tnam = ["gen_E"] if self.pdg == 11: tnam = ["true_el_pT", "true_el_theta", "true_el_phi", "true_el_E"] self.out = self.make_tree(tree, tnam) #event attributes for hepmc self.hepmc_attrib = hepmc_attrib print("Uniform generator initialized")
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 get_scale(Ni): #scale for event rate in Hz per one simulated interaction #Ni is number of simulated interactions #interaction cross section, mb sigma_tot = 171.29 # 18x275 #sigma_tot = 123.83 # 10x100 #sigma_tot = 79.18 # 5x41 #instantaneous luminosity, cm^-2 sec^-1 lumi_cmsec = 1.54e33 # 18x275 #lumi_cmsec = 4.48e33 # 10x100 #lumi_cmsec = 0.44e33 # 5x41 #number of bunches nbunch = 290 # 18x275 #nbunch = 1160 # 10x100 #nbunch = 1160 # 5x41 #electron beam energy, GeV #Ee = 18. # GeV #Ee = 10. # GeV Ee = 5. # GeV #collider circumference, speed of light, electron mass circ = 3834. # m cspeed = 299792458. # m sec^-1 me = TDatabasePDG.Instance().GetParticle(11).Mass() # GeV #beam velocity (units of c) beta = np.sqrt(Ee**2 - me**2) / Ee print("Beta:", beta) print("Orbit period (micro sec):", 1e6 * circ / (beta * cspeed)) #bunch spacing, sec Tb = circ / (beta * cspeed * nbunch) print("Bunch spacing (micro sec):", 1e6 * Tb) print("Bunch frequency (MHz):", 1e-6 / Tb) #luminosity per bunch crossing, mb^-1 Lb = lumi_cmsec * 1e-27 * Tb print("Luminosity per bunch crossing, mb^-1:", Lb) print("Mean number of interactions per bunch crossing:", sigma_tot * Lb) print("Probability for at least one interaction in bunch crossing:", (1. - np.e**(-sigma_tot * Lb))) scale = {} scale["lambda"] = sigma_tot * Lb scale["Tb"] = Tb # sec #rate per one simulated interaction, Hz #return (1./Ni)*sigma_tot*1e-27*lumi_cmsec return scale
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")
def __init__(self, en, pdg, zsign): #energy, pdg, sign of z-momentum particle.__init__(self, pdg) self.pdg = pdg #status code for beam particles self.stat = 201 #set kinematics for beam particle m = TDatabasePDG.Instance().GetParticle(pdg).Mass() pz = zsign * sqrt(en**2 - m**2) self.vec.SetPxPyPzE(0, 0, pz, en)
def get_s(self, Ee, Ep): #calculate the CMS squared s #proton mass mp = TDatabasePDG.Instance().GetParticle(2212).Mass() #CMS energy squared s, GeV^2 s = 2.*Ee*Ep + self.me**2 + mp**2 s += 2*TMath.Sqrt(Ee**2 - self.me**2) * TMath.Sqrt(Ep**2 - mp**2) #print "sqrt(s):", TMath.Sqrt(s) return s
def q2_calc_vec_from_kine(en, theta, phi): #create Lorentz vector from electron kinematics loaded from the tree #transverse momentum m = TDatabasePDG.Instance().GetParticle(11).Mass() pt = sqrt(0.5 * (en**2 - m**2) * (1. - cos(2. * theta))) #pseudorapidity eta = -log(tan(theta / 2.)) #set the Lorentz vector vec = TLorentzVector() vec.SetPtEtaPhiE(pt, eta, phi, en) return vec
def __init__(self, en, theta, phi): particle.__init__(self, 11) #transverse momentum m = TDatabasePDG.Instance().GetParticle(11).Mass() pt = sqrt(0.5 * (en**2 - m**2) * (1. - cos(2. * theta))) #pseudorapidity, rotate the theta for pz negative theta = pi - theta eta = -log(tan(theta / 2.)) #set the electron Lorentz vector self.vec.SetPtEtaPhiE(pt, eta, phi, en) #status for the final particle self.stat = 1
def __init__(self, parse): #electron beam energy, GeV self.Ee = parse.getfloat("main", "Ee") print("Ee =", self.Ee) #energy spread from input relative energy spread self.espread = None if parse.has_option("main", "espread"): sig_e = self.Ee * parse.getfloat("main", "espread") self.espread = TF1("espread", "gaus", -12 * sig_e, 12 * sig_e) self.espread.SetParameters(1, 0, sig_e) #electron mass self.me = TDatabasePDG.Instance().GetParticle(11).Mass() print("Electron beam initialized")
def __init__(self, pdg): #particle Lorentz vector self.vec = TLorentzVector() #index in particle list self.idx = 0 #status code self.stat = 0 #pdg code self.pdg = pdg #particle database for pass and codes self.pdgdat = TDatabasePDG.Instance() #mass, GeV self.mass = self.pdgdat.GetParticle(self.pdg).Mass() #parent particle id self.parent_id = 0 #vertex coordinates, mm self.vx = 0. self.vy = 0. self.vz = 0. #precision for momentum and energy self.pxyze_prec = 6
markerstyle=markersData[cut]) hEffPtIntMC = TH1F('hEffPtIntMC', ';|#Delta#it{M}(KK)| selection; efficiency', 21, 4.5, 25.5) hEffPtIntData = TH1F('hEffPtIntData', ';|#Delta#it{M}(KK)| selection; efficiency', 21, 4.5, 25.5) SetObjectStyle(hEffPtIntMC, color=kRed + 1, fillstyle=0, markerstyle=kFullSquare) SetObjectStyle(hEffPtIntData, color=kAzure + 4, fillstyle=0, markerstyle=kFullCircle) massPhi = TDatabasePDG.Instance().GetParticle(333).Mass() massK = TDatabasePDG.Instance().GetParticle(321).Mass() widthPhi = TDatabasePDG.Instance().GetParticle(333).Width() for iPt in range(nPtBinsMC): if iPt < nPtBinsMC - 1: ptMin = ptLims[iPt] ptMax = ptLims[iPt + 1] else: ptMin = ptLims[0] ptMax = ptLims[-1] # get massKK distributions in signal region massLowLimit = mean[iPt] - args.nSigma * sigma[iPt] massHighLimit = mean[iPt] + args.nSigma * sigma[iPt] binLow = hMassKKvsMassKKpiMC[iPt].GetXaxis().FindBin(massLowLimit * 1.0001)
def main(): #input inp = TFile.Open("pC.root") tree = inp.Get("DetectorTree") #input generated particles gen_pdg = std.vector(int)() gen_en = std.vector(float)() tree.SetBranchAddress("gen_pdg", gen_pdg) tree.SetBranchAddress("gen_en", gen_en) #layer hits lay10_hit_edep = std.vector(float)() lay11_hit_edep = std.vector(float)() lay12_hit_edep = std.vector(float)() lay13_hit_edep = std.vector(float)() lay20_hit_edep = std.vector(float)() lay21_hit_edep = std.vector(float)() lay22_hit_edep = std.vector(float)() lay23_hit_edep = std.vector(float)() tree.SetBranchAddress("lay10_HitEdep", lay10_hit_edep) tree.SetBranchAddress("lay11_HitEdep", lay11_hit_edep) tree.SetBranchAddress("lay12_HitEdep", lay12_hit_edep) tree.SetBranchAddress("lay13_HitEdep", lay13_hit_edep) tree.SetBranchAddress("lay20_HitEdep", lay20_hit_edep) tree.SetBranchAddress("lay21_HitEdep", lay21_hit_edep) tree.SetBranchAddress("lay22_HitEdep", lay22_hit_edep) tree.SetBranchAddress("lay23_HitEdep", lay23_hit_edep) #output out = TFile("events.root", "recreate") otree = TTree("event", "event") ekin = c_float(0) lay10_edep = c_float(0) lay11_edep = c_float(0) lay12_edep = c_float(0) lay13_edep = c_float(0) lay20_edep = c_float(0) lay21_edep = c_float(0) lay22_edep = c_float(0) lay23_edep = c_float(0) otree.Branch("ekin", ekin, "ekin/F") # kinetic energy, MeV otree.Branch("lay10_edep", lay10_edep, "lay10_edep/F") # deposited energy, MeV otree.Branch("lay11_edep", lay11_edep, "lay11_edep/F") otree.Branch("lay12_edep", lay12_edep, "lay12_edep/F") otree.Branch("lay13_edep", lay13_edep, "lay13_edep/F") otree.Branch("lay20_edep", lay20_edep, "lay20_edep/F") otree.Branch("lay21_edep", lay21_edep, "lay21_edep/F") otree.Branch("lay22_edep", lay22_edep, "lay22_edep/F") otree.Branch("lay21_edep", lay23_edep, "lay23_edep/F") #number of events nev = tree.GetEntries() #nev = 100000 #event loop for iev in range(nev): tree.GetEntry(iev) if iev%100000 == 0: print("Event: ", iev) #deposited energy, MeV lay10_edep.value = 0. lay11_edep.value = 0. lay12_edep.value = 0. lay13_edep.value = 0. lay20_edep.value = 0. lay21_edep.value = 0. lay22_edep.value = 0. lay23_edep.value = 0. #hit loops for layers nhit = 0 nhit += get_edep_lay(lay10_hit_edep, lay10_edep) nhit += get_edep_lay(lay11_hit_edep, lay11_edep) nhit += get_edep_lay(lay12_hit_edep, lay12_edep) nhit += get_edep_lay(lay13_hit_edep, lay13_edep) nhit += get_edep_lay(lay20_hit_edep, lay20_edep) nhit += get_edep_lay(lay21_hit_edep, lay21_edep) nhit += get_edep_lay(lay22_hit_edep, lay22_edep) nhit += get_edep_lay(lay23_hit_edep, lay23_edep) #events with hits if nhit <= 0: continue #generated kinetic energy, MeV egen = gen_en.at(0) mass = TDatabasePDG.Instance().GetParticle(gen_pdg.at(0)).Mass() ekin.value = (egen-mass)*1e3 # MeV #fill the output tree otree.Fill() #finish otree.Write() out.Close()
def __init__(self, parse, tree=None): self.parse = parse #electron energy, GeV self.Ee = parse.getfloat("main", "Ee") print("Ee, GeV =", self.Ee) #Z of the nucleus self.Z = 1 if parse.has_option("main", "Z"): self.Z = parse.getint("main", "Z") 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 mass self.me = TDatabasePDG.Instance().GetParticle(11).Mass() #maximal delta self.dmax = 200. if parse.has_option("main", "dmax"): self.dmax = parse.getfloat("main", "dmax") print("dmax:", self.dmax) #cross section formula #self.eqpar = self.eq_93p16(self) #self.dSigDwDt = TF2("dSigDwDt", self.eqpar, self.emin, self.Ee, 0, self.dmax) #self.dSigDwDt.SetNpx(2000) #self.dSigDwDt.SetNpy(2000) #self.dSigDwDt.SetNpx(100) #self.dSigDwDt.SetNpy(100) #gRandom.SetSeed(5572323) #total integrated cross section over all delta (to 1e5) #dSigInt = TF2("dSigInt", self.eqpar, self.emin, self.Ee, 0, 1e5) #sigma_tot = dSigInt.Integral(self.emin, self.Ee, 0, 1e5) #print("Total cross section, mb:", sigma_tot) #FOAM integration self.eq_foam = self.eq_93p16_foam(self) self.rand_foam = TRandom3() self.rand_foam.SetSeed(123) self.foam = TFoam("foam") self.foam.SetkDim(2) self.foam.SetnCells(2000) self.foam.SetRhoInt(self.eq_foam) self.foam.SetPseRan(self.rand_foam) self.foam.Initialize() #to print the total cross section from FOAM at the end atexit.register(self.finish) #uniform generator for azimuthal angles self.rand = TRandom3() self.rand.SetSeed(5572323) #chamber pressure for z-vertex self.pressure_par = self.eq_pressure(self) zmin = self.pressure_par.zmin zmax = self.pressure_par.zmax #custom range in z, only within the default limits given by pressure data if parse.has_option( "main", "zmin") and (parse.getfloat("main", "zmin") > zmin): zmin = parse.getfloat("main", "zmin") if parse.has_option( "main", "zmax") and (parse.getfloat("main", "zmax") < zmax): zmax = parse.getfloat("main", "zmax") print("zmin, zmax (mm):", zmin, zmax) self.pressure_func = TF1("pressure", self.pressure_par, zmin, zmax) #electron lattice self.lat = self.load_lattice() #beam transverte shape for vertex in x and y self.beam_par = self.eq_beam_sigma(self.lat, self.pressure_par.hz, parse) #tree output from the generator tlist = ["true_phot_w", "true_phot_delta"] tlist += ["true_phot_theta", "true_phot_phi", "true_phot_E"] tlist += ["vtx_x", "vtx_y", "vtx_z", "divx", "divy"] self.tree_out = self.set_tree(tree, tlist) print("Beam-gas generator initialized")
def __init__(self, parse, tree, hepmc_attrib): print("Quasi-real configuration:") #electron and proton beam energy, GeV self.Ee = parse.getfloat("main", "Ee") self.Ep = parse.getfloat("main", "Ep") print("Ee =", self.Ee, "GeV") print("Ep =", self.Ep, "GeV") #electron and proton mass self.me = TDatabasePDG.Instance().GetParticle(11).Mass() mp = TDatabasePDG.Instance().GetParticle(2212).Mass() #boost vector pbvec of proton beam pbeam = TLorentzVector() pbeam.SetPxPyPzE(0, 0, TMath.Sqrt(self.Ep**2-mp**2), self.Ep) self.pbvec = pbeam.BoostVector() #electron beam energy Ee_p in proton beam rest frame ebeam = TLorentzVector() ebeam.SetPxPyPzE(0, 0, -TMath.Sqrt(self.Ee**2-self.me**2), self.Ee) ebeam.Boost(-self.pbvec.x(), -self.pbvec.y(), -self.pbvec.z()) # transform to proton beam frame self.Ee_p = ebeam.E() #center-of-mass squared s, GeV^2 self.s = self.get_s(self.Ee, self.Ep) print("s =", self.s, "GeV^2") print("sqrt(s) =", TMath.Sqrt(self.s), "GeV") #range in x xmin = parse.getfloat("main", "xmin") xmax = parse.getfloat("main", "xmax") print("xmin =", xmin) print("xmax =", xmax) #range in u = log_10(x) umin = TMath.Log10(xmin) umax = TMath.Log10(xmax) print("umin =", umin) print("umax =", umax) #range in y ymin = parse.getfloat("main", "ymin") ymax = parse.getfloat("main", "ymax") #range in W wmin = -1. wmax = -1. if parse.has_option("main", "Wmin"): wmin = parse.getfloat("main", "Wmin") print("Wmin =", wmin) if parse.has_option("main", "Wmax"): wmax = parse.getfloat("main", "Wmax") print("Wmax =", wmax) #adjust range in y according to W if wmin > 0 and ymin < wmin**2/self.s: ymin = wmin**2/self.s if wmax > 0 and ymax > wmax**2/self.s: ymax = wmax**2/self.s print("ymin =", ymin) print("ymax =", ymax) #range in v = log_10(y) vmin = TMath.Log10(ymin) vmax = TMath.Log10(ymax) print("vmin =", vmin) print("vmax =", vmax) #range in Q2 self.Q2min = parse.getfloat("main", "Q2min") self.Q2max = parse.getfloat("main", "Q2max") print("Q2min =", self.Q2min) print("Q2max =", self.Q2max) #constant term in the cross section self.const = TMath.Log(10)*TMath.Log(10)*(1./137)/(2.*math.pi) #cross section formula for d^2 sigma / dxdy, Eq. II.6 #transformed as x -> u = log_10(x) and y -> v = log_10(y) self.eq_II6_uv_par = self.eq_II6_uv(self) self.eq = TF2("d2SigDuDvII6", self.eq_II6_uv_par, umin, umax, vmin, vmax) self.eq.SetNpx(1000) self.eq.SetNpy(1000) #uniform generator for azimuthal angles self.rand = TRandom3() self.rand.SetSeed(5572323) #generator event variables in output tree tnam = ["gen_u", "gen_v", "true_x", "true_y", "true_Q2", "true_W2"] tnam += ["true_el_Q2"] tnam += ["true_el_pT", "true_el_theta", "true_el_phi", "true_el_E"] #create the tree variables tcmd = "struct gen_out { Double_t " for i in tnam: tcmd += i + ", " tcmd = tcmd[:-2] + ";};" gROOT.ProcessLine( tcmd ) self.out = rt.gen_out() #put zero to all variables for i in tnam: exec("self.out."+i+"=0") #set the variables in the tree if tree is not None: for i in tnam: tree.Branch(i, addressof(self.out, i), i+"/D") #event attributes for hepmc self.hepmc_attrib = hepmc_attrib #counters for all generated and selected events self.nall = 0 self.nsel = 0 #print generator statistics at the end atexit.register(self.show_stat) #total integrated cross section self.sigma_tot = self.eq.Integral(umin, umax, vmin, vmax) print("Total integrated cross section for a given x and y range:", self.sigma_tot, "mb") print("Quasi-real photoproduction initialized")
def __init__(self, parse, tree): #electron and proton beam energy, GeV self.Ee = parse.getfloat("lgen", "Ee") self.Ep = parse.getfloat("lgen", "Ep") print "Ee =", self.Ee print "Ep =", self.Ep #electron mass self.me = TDatabasePDG.Instance().GetParticle(11).Mass() #center-of-mass squared s, GeV^2 self.s = self.get_s(self.Ee, self.Ep) #range in x and y, max 4 orders of magnitude for the range of x xmin = parse.getfloat("lgen", "xmin") xmax = parse.getfloat("lgen", "xmax") print "xmin =", xmin print "xmax =", xmax #range in y ymin = parse.getfloat("lgen", "ymin") ymax = parse.getfloat("lgen", "ymax") print "ymin =", ymin print "ymax =", ymax #constant term in the cross section self.const = (1. / 137) / (2. * math.pi) #cross section formula for d^2 sigma / dxdy, Eq. II.6 self.eq = TF2("d2SigDxDyII6", self.eq_II6, xmin, xmax, ymin, ymax) #number of points for function evaluation to generate #the values of x and y down to x = 1e-7 self.eq.SetNpx(10000) # max for npx allowed in ROOT #uniform generator for azimuthal angles self.rand = TRandom3() self.rand.SetSeed(5572323) #generator event variables in output tree tnam = ["gen_x", "gen_y", "gen_Q2", "gen_theta", "gen_E", "gen_phi"] #create the tree variables tcmd = "struct gen_out { Double_t " for i in tnam: tcmd += i + ", " tcmd = tcmd[:-2] + ";};" gROOT.ProcessLine(tcmd) #set the variables in the tree if tree is not None: self.out = rt.gen_out() for i in tnam: tree.Branch(i, AddressOf(self.out, i), i + "/D") #total integrated cross section self.sigma_tot = self.eq.Integral(xmin, xmax, ymin, ymax) print "Total integrated cross section for a given x and y range:", self.sigma_tot, "mb" print "Quasi-real photoproduction initialized"
def comp_fit_pars(do_ratio=False, meson='Ds'): #pylint: disable-msg=too-many-statements,too-many-locals inputdir = '../../AnalysisNonPromptDpp2017/Dplus/outputs/rawyields' input_files = ['RawYieldsDplus_pp5TeV_prompt_central.root', 'RawYieldsDplus_pp5TeV_FD_central_freesigma.root'] input_files_MC = ['RawYieldsDplusMC_pp5TeV_prompt_central.root', 'RawYieldsDplusMC_pp5TeV_FD_central.root'] colors = [kOrange+7, kAzure+2, kRed+1, kAzure+4] markers = [kOpenCircle, kOpenSquare, kFullCircle, kFullSquare] legendnames = ['MC - prompt enhanced', 'MC - FD enhanced', 'data - prompt enhanced', 'data - FD enhanced'] suffix = 'CompMCData' min_pt = 2. max_pt = 16. SetGlobalStyle(padleftmargin=0.18, padtopmargin=0.05, padbottommargin=0.14, titleoffsety=1.6, titlesize=0.045, labelsize=0.04) hMean, hSigma = [], [] input_files = input_files_MC + input_files if meson == 'Ds': massD = TDatabasePDG.Instance().GetParticle(431).Mass() elif meson == 'Dplus': massD = TDatabasePDG.Instance().GetParticle(411).Mass() lineMass = TLine(min_pt, massD, max_pt, massD) lineMass.SetLineWidth(2) lineMass.SetLineColor(kBlack) lineMass.SetLineStyle(9) legSigma = TLegend(0.2, 0.78, 0.8, 0.93) legSigma.SetFillStyle(0) legSigma.SetBorderSize(0) legSigma.SetTextSize(0.04) legMean = TLegend(0.4, 0.73, 0.7, 0.93) legMean.SetFillStyle(0) legMean.SetBorderSize(0) legMean.SetTextSize(0.04) legMean.AddEntry(lineMass, "PDG", 'l') for file_path, color, marker, legend_name in zip(input_files, colors, markers, legendnames): input_file = TFile(f'{inputdir}/{file_path}') histo_mean = input_file.Get('hRawYieldsMean') histo_sigma = input_file.Get('hRawYieldsSigma') histo_mean.SetDirectory(0) histo_sigma.SetDirectory(0) SetObjectStyle(histo_mean, linecolor=color, markercolor=color, markerstyle=marker) SetObjectStyle(histo_sigma, linecolor=color, markercolor=color, markerstyle=marker) legMean.AddEntry(histo_mean, legend_name, 'p') legSigma.AddEntry(histo_sigma, legend_name, 'p') hMean.append(histo_mean) hSigma.append(histo_sigma) if do_ratio: mean_num_list = list(hMean) mean_num_list.pop(0) mean_den_hist = hMean[0] mean_ratio_list = [] for histo in mean_num_list: mean_ratio_list.append(ComputeRatioDiffBins(histo, mean_den_hist)) cMeanRatio = TCanvas('cMeanRatio', '', 800, 800) cMeanRatio.DrawFrame(min_pt, 0.99, max_pt, 1.01, ';#it{p}_{T} (GeV/#it{c}); peak mean / peak mean MC') lineRatio = TLine(min_pt, 1., max_pt, 1.) lineRatio.SetLineWidth(2) lineRatio.SetLineColor(kBlack) lineRatio.SetLineStyle(9) legMeanRatio = TLegend(0.4, 0.73, 0.7, 0.93) legMeanRatio.SetFillStyle(0) legMeanRatio.SetBorderSize(0) legMeanRatio.SetTextSize(0.04) for hist, color, marker, legend_name in zip(mean_ratio_list, colors[1:], markers[1:], legendnames[1:]): SetObjectStyle(hist, linecolor=color, markercolor=color, markerstyle=marker) hist.Draw('same') legMeanRatio.AddEntry(hist, legend_name, 'p') lineRatio.Draw() legMeanRatio.Draw() sigma_num_list = list(hSigma) sigma_num_list.pop(0) sigma_den_hist = hSigma[0] sigma_ratio_list = [] for histo in sigma_num_list: sigma_ratio_list.append(ComputeRatioDiffBins(histo, sigma_den_hist)) cSigmaRatio = TCanvas('cSigmaRatio', '', 800, 800) hFrameSigma = cSigmaRatio.DrawFrame(min_pt, 0.6, max_pt, 1.8, ';#it{p}_{T} (GeV/#it{c}); peak width / peak width MC') hFrameSigma.GetYaxis().SetDecimals() legSigmaRatio = TLegend(0.4, 0.73, 0.7, 0.93) legSigmaRatio.SetFillStyle(0) legSigmaRatio.SetBorderSize(0) legSigmaRatio.SetTextSize(0.04) for hist, color, marker, legend_name in zip(sigma_ratio_list, colors[1:], markers[1:], legendnames[1:]): SetObjectStyle(hist, linecolor=color, markercolor=color, markerstyle=marker) hist.Draw('same') legSigmaRatio.AddEntry(hist, legend_name, 'p') lineRatio.Draw() legSigmaRatio.Draw() cMeanRatio.SaveAs(f'{inputdir}/MeanRatio_{suffix}.pdf') cSigmaRatio.SaveAs(f'{inputdir}/SigmaRatio_{suffix}.pdf') cMean = TCanvas('cMean', '', 800, 800) hFrameMean = cMean.DrawFrame(min_pt, massD*0.995, max_pt, massD*1.01, ';#it{p}_{T} (GeV/#it{c}); peak mean (GeV/#it{c}^{2})') hFrameMean.GetYaxis().SetDecimals() lineMass.Draw("same") for histo_mean in hMean: histo_mean.Draw('same') legMean.Draw() cSigma = TCanvas('cSigma', '', 800, 800) cSigma.DrawFrame(min_pt, 0., max_pt, 0.025, ';#it{p}_{T} (GeV/#it{c}); peak width (GeV/#it{c}^{2})') for histo_sigma in hSigma: histo_sigma.Draw('same') legSigma.Draw() cMean.SaveAs(f'{inputdir}/Mean_{suffix}.pdf') cSigma.SaveAs(f'{inputdir}/Sigma_{suffix}.pdf') input('Press enter to exit')
markerstyle=kFullSquare) SetObjectStyle(hRawYieldsSigmaRatioSecondFirstPeak, color=kRed, markerstyle=kFullSquare) SetObjectStyle(hRawYieldsSoverBSecPeak, color=kRed, markerstyle=kFullSquare) SetObjectStyle(hRawYieldsSignalSecPeak, color=kRed, markerstyle=kFullSquare) SetObjectStyle(hRawYieldsBkgSecPeak, color=kRed, markerstyle=kFullSquare) SetObjectStyle(hRawYieldsTrue, color=kRed, markerstyle=kFullSquare) SetObjectStyle(hRawYieldsSecPeakTrue, color=kRed, markerstyle=kFullSquare) SetObjectStyle(hRelDiffRawYieldsFitTrue, color=kRed, markerstyle=kFullSquare) SetObjectStyle(hRelDiffRawYieldsSecPeakFitTrue, color=kRed, markerstyle=kFullSquare) # fit histos massDplus = TDatabasePDG.Instance().GetParticle(411).Mass() massDs = TDatabasePDG.Instance().GetParticle(431).Mass() massForFit = massDplus if fitConfig[cent]['Meson'] == 'Dplus' else massDs cMass = TCanvas("cMass", "cMass", 1920, 1080) DivideCanvas(cMass, nPtBins) cResiduals = TCanvas("cResiduals", "cResiduals", 1920, 1080) DivideCanvas(cResiduals, nPtBins) massFitter = [] for iPt, (hM, ptMin, ptMax, reb, sgn, bkg, secPeak, massMin, massMax) in enumerate(zip( hMass, ptMins, ptMaxs, fitConfig[cent]['Rebin'], SgnFunc, BkgFunc, \ inclSecPeak, fitConfig[cent]['MassMin'], fitConfig[cent]['MassMax'])): hMassForFit.append(TH1F()) AliVertexingHFUtils.RebinHisto(hM, reb).Copy(
parser.add_argument('outFileName', metavar='text', default='outFileName.root', help='output root file name') args = parser.parse_args() #config with input file details with open(args.cfgFileName, 'r') as ymlCfgFile: inputCfg = yaml.load(ymlCfgFile, yaml.FullLoader) inFileNames = inputCfg['filename'] if not isinstance(inFileNames, list): inFileNames = [inFileNames] isMC = inputCfg['isMC'] #define mass binning meson = inputCfg['tree']['meson'] if meson == 'Ds': mD = TDatabasePDG.Instance().GetParticle(431).Mass() elif meson == 'Dplus': mD = TDatabasePDG.Instance().GetParticle(411).Mass() else: print('Error: only Dplus and Ds mesons supported. Exit!') exit() #selections to be applied with open(args.cutSetFileName, 'r') as ymlCutSetFile: cutSetCfg = yaml.load(ymlCutSetFile, yaml.FullLoader) cutVars = cutSetCfg['cutvars'] selToApply = [] for iPt, _ in enumerate(cutVars['Pt']['min']): selToApply.append('') for iVar, varName in enumerate(cutVars): if varName == 'InvMass':
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")
ptBinsArr)) SetObjectStyle(hRawYieldsSignalDiffSigma[iS], color=kBlack, markerstyle=kFullCircle) SetObjectStyle(hRawYieldsBkgDiffSigma[iS], color=kBlack, markerstyle=kFullCircle) SetObjectStyle(hRawYieldsSoverBDiffSigma[iS], color=kBlack, markerstyle=kFullCircle) SetObjectStyle(hRawYieldsSignifDiffSigma[iS], color=kBlack, markerstyle=kFullCircle) # fit histos massDplus = TDatabasePDG.Instance().GetParticle(411).Mass() massDs = TDatabasePDG.Instance().GetParticle(431).Mass() massLc = TDatabasePDG.Instance().GetParticle(4122).Mass() massDstar = TDatabasePDG.Instance().GetParticle( 413).Mass() - TDatabasePDG.Instance().GetParticle(421).Mass() massD0 = TDatabasePDG.Instance().GetParticle(421).Mass() if particleName == 'Dplus': massForFit = massDplus elif particleName == 'Ds': massForFit = massDs elif particleName == 'Dstar': massForFit = massDstar elif particleName == 'D0': massForFit = massD0 else: