def CalculateSummary(self, summary, background=True):
# Ntotal
summary.Ntotal = Measure()
for i in range(0, len(self.detail)):
if background != self.main.datasets[i].background:
continue
summary.Ntotal.mean += self.detail[i].Ntotal.mean
summary.Ntotal.error += self.detail[i].Ntotal.error**2
summary.Ntotal.error = sqrt(summary.Ntotal.error)
# Prepare vectors
for i in range(0, len(self.detail[0].Nselected)):
summary.Nselected.append(Measure())
summary.Nrejected.append(Measure())
summary.eff.append(Measure())
summary.effcumu.append(Measure())
# Fill selected and rejected
for iset in range(0, len(self.detail)):
if background != self.main.datasets[iset].background:
continue
for icut in range(0, len(self.detail[iset].Nselected)):
summary.Nselected[icut].mean += self.detail[iset].Nselected[
icut].mean
summary.Nrejected[icut].mean += self.detail[iset].Nrejected[
icut].mean
summary.Nselected[icut].error += self.detail[iset].Nselected[
icut].error**2
summary.Nrejected[icut].error += self.detail[iset].Nrejected[
icut].error**2
for icut in range(0, len(self.detail[0].Nselected)):
summary.Nselected[icut].error = sqrt(summary.Nselected[icut].error)
summary.Nrejected[icut].error = sqrt(summary.Nrejected[icut].error)
# Compute efficiencies
for i in range(0, len(summary.eff)):
if summary.Ntotal.mean != 0:
summary.effcumu[i].mean = float(
summary.Nselected[i].mean) / float(summary.Ntotal.mean)
summary.effcumu[i].error = Measure.binomialError(
summary.Nselected[i].mean, summary.Ntotal.mean)
if i == 0:
if summary.Ntotal.mean != 0:
summary.eff[i].mean = float(
summary.Nselected[i].mean) / float(summary.Ntotal.mean)
summary.eff[i].error = Measure.binomialError(
summary.Nselected[i].mean, summary.Ntotal.mean)
else:
if summary.Nselected[i - 1].mean != 0:
summary.eff[i].mean = float(
summary.Nselected[i].mean) / float(
summary.Nselected[i - 1].mean)
summary.eff[i].error = Measure.binomialError(
summary.Nselected[i].mean,
summary.Nselected[i - 1].mean)
def CalculateSummary(self,summary,background=True):
# Ntotal
summary.Ntotal=Measure()
for i in range(0,len(self.detail)):
if background!=self.main.datasets[i].background:
continue
summary.Ntotal.mean += self.detail[i].Ntotal.mean
summary.Ntotal.error += self.detail[i].Ntotal.error**2
summary.Ntotal.error = sqrt(summary.Ntotal.error)
# Prepare vectors
for i in range(0,len(self.detail[0].Nselected)):
summary.Nselected.append(Measure())
summary.Nrejected.append(Measure())
summary.eff.append(Measure())
summary.effcumu.append(Measure())
# Fill selected and rejected
for iset in range (0,len(self.detail)):
if background!=self.main.datasets[iset].background:
continue
for icut in range (0,len(self.detail[iset].Nselected)):
summary.Nselected[icut].mean += self.detail[iset].Nselected[icut].mean
summary.Nrejected[icut].mean += self.detail[iset].Nrejected[icut].mean
summary.Nselected[icut].error += self.detail[iset].Nselected[icut].error**2
summary.Nrejected[icut].error += self.detail[iset].Nrejected[icut].error**2
for icut in range (0,len(self.detail[0].Nselected)):
summary.Nselected[icut].error = sqrt(summary.Nselected[icut].error)
summary.Nrejected[icut].error = sqrt(summary.Nrejected[icut].error)
# Compute efficiencies
for i in range(0,len(summary.eff)):
if summary.Ntotal.mean!=0:
summary.effcumu[i].mean=float(summary.Nselected[i].mean)/float(summary.Ntotal.mean)
summary.effcumu[i].error=Measure.binomialError(summary.Nselected[i].mean,summary.Ntotal.mean)
if i==0:
if summary.Ntotal.mean!=0:
summary.eff[i].mean=float(summary.Nselected[i].mean)/float(summary.Ntotal.mean)
summary.eff[i].error=Measure.binomialError(summary.Nselected[i].mean,summary.Ntotal.mean)
else:
if summary.Nselected[i-1].mean!=0:
summary.eff[i].mean=float(summary.Nselected[i].mean)/float(summary.Nselected[i-1].mean)
summary.eff[i].error=Measure.binomialError(summary.Nselected[i].mean,summary.Nselected[i-1].mean)
def Calculate(self):
# Calculating Nrejected for positive and negative weighted events
for icut in range(0,len(self.Nselected)):
if icut==0:
self.Nrejected_posweight[icut].mean = self.Ntotal_posweight.mean - self.Nselected_posweight[icut].mean
self.Nrejected_negweight[icut].mean = self.Ntotal_negweight.mean - self.Nselected_negweight[icut].mean
else:
self.Nrejected_posweight[icut].mean = self.Nselected_posweight[icut-1].mean - self.Nselected_posweight[icut].mean
self.Nrejected_negweight[icut].mean = self.Nselected_negweight[icut-1].mean - self.Nselected_negweight[icut].mean
# Combining negative & positive weight events for computing Nselected, Nrejected and Ntotal
self.Ntotal.mean = self.Ntotal_posweight.mean - self.Ntotal_negweight.mean
for icut in range(0,len(self.Nselected)):
self.Nselected[icut].mean = self.Nselected_posweight[icut].mean - self.Nselected_negweight[icut].mean
self.Nrejected[icut].mean = self.Nrejected_posweight[icut].mean - self.Nrejected_negweight[icut].mean
# Checking that all numbers are positive : Nselected and Ntotal
for icut in range(0,len(self.Nselected)):
if self.Nselected[icut].mean<0:
self.warnings[icut].append('The number of selected events is negative: '+\
str(self.Nselected[icut].mean)+'. Set to 0.')
self.Nselected[icut].mean=0
if self.Nrejected[icut].mean<0:
self.warnings[icut].append('The number of rejected events is negative: '+\
str(self.Nrejected[icut].mean)+'. Set to 0.')
self.Nrejected[icut].mean=0
# Checking that a N cut i > N cut i+1 : Nselected and Nrejected
for icut in range(0,len(self.Nselected)):
if icut==0:
if self.Nselected[icut].mean > self.Ntotal.mean:
self.warnings[icut].append('The number of selected events > the initial number of events : '+str(self.Nselected[icut].mean)+' > '+str(self.Ntotal.mean)+'. Set the number of selected events to 0.')
self.Nselected[icut].mean=0
else:
if self.Nselected[icut].mean > self.Nselected[icut-1].mean:
self.warnings[icut].append('The number of selected events > the initial number of events : '+str(self.Nselected[icut].mean)+' > '+str(self.Nselected[icut-1].mean)+'. Set the number of selected events to 0.')
self.Nselected[icut].mean=0
# Calculating errors on Naccepted and Nrejected
for icut in range(0,len(self.Nselected)):
self.Nselected[icut].error = Measure.binomialNEventError(self.Nselected[icut].mean,self.Ntotal.mean)
self.Nrejected[icut].error = Measure.binomialNEventError(self.Nrejected[icut].mean,self.Ntotal.mean)
# efficiency calculation and its error
for icut in range(0,len(self.Nselected)):
if icut==0:
if self.Ntotal.mean==0:
self.eff[icut].mean = 0
else:
self.eff[icut].mean = float(self.Nselected[icut].mean) / \
float(self.Ntotal.mean)
self.eff[icut].error = Measure.binomialError(self.Nselected[icut].mean,self.Ntotal.mean)
else:
if self.Nselected[icut-1].mean==0:
self.eff[icut].mean = 0
else:
self.eff[icut].mean = float(self.Nselected[icut].mean) / \
float(self.Nselected[icut-1].mean)
self.eff[icut].error = Measure.binomialError(self.Nselected[icut].mean,self.Nselected[icut-1].mean)
if self.Ntotal.mean==0:
self.effcumu[icut].mean=0
else:
self.effcumu[icut].mean = float(self.Nselected[icut].mean) / \
float(self.Ntotal.mean)
self.effcumu[icut].error = Measure.binomialError(self.Nselected[icut].mean,self.Ntotal.mean)
# Getting xsection
xsection = self.dataset.measured_global.xsection
xerror = self.dataset.measured_global.xerror
if self.dataset.xsection!=0.:
xsection=self.dataset.xsection
xerror=0
# Saving ntotal
ntot = 0.+self.Ntotal.mean
# Scaling Ntotal
if self.main.normalize == NormalizeType.LUMI:
self.Ntotal.error = xerror * self.main.lumi * 1000
self.Ntotal.mean = xsection * self.main.lumi * 1000
elif self.main.normalize == NormalizeType.LUMI_WEIGHT:
self.Ntotal.error = xerror * self.main.lumi * 1000 * \
self.dataset.weight
self.Ntotal.mean = xsection * self.main.lumi * 1000 * \
self.dataset.weight
# Scaling Nselected
for icut in range(0,len(self.Nselected)):
if self.main.normalize == NormalizeType.LUMI:
# error due to xsec
if ntot!=0:
errXsec = xerror * self.main.lumi * 1000 * self.Nselected[icut].mean / ntot
else:
errXsec=0
# scale factor
if ntot!=0:
factor = xsection * self.main.lumi * 1000 / ntot
else:
factor = 0
self.Nselected[icut].mean *= factor
self.Nselected[icut].error = Measure.binomialNEventError(self.Nselected[icut].mean,self.Ntotal.mean)
# compute final error
self.Nselected[icut].error = sqrt(\
self.Nselected[icut].error**2 + errXsec**2)
elif self.main.normalize == NormalizeType.LUMI_WEIGHT:
# error due to xsec
if ntot!=0:
errXsec = xerror * self.main.lumi * 1000 * self.dataset.weight * self.Nselected[icut].mean / ntot
else:
errXsec=0
# scale factor
if ntot!=0:
factor = xsection * self.main.lumi * self.dataset.weight * 1000 / ntot
else:
factor = 0
self.Nselected[icut].mean *= factor
self.Nselected[icut].error = Measure.binomialNEventError(self.Nselected[icut].mean,self.Ntotal.mean)
# compute final error
self.Nselected[icut].error = sqrt(\
self.Nselected[icut].error**2 + errXsec**2)
# Scaling Nrejected
for icut in range(0,len(self.Nrejected)):
if self.main.normalize == NormalizeType.LUMI:
# error due to xsec
if ntot!=0:
errXsec = xerror * self.main.lumi * 1000 * self.Nrejected[icut].mean / ntot
else:
errXsec=0
# scale factor
if ntot!=0:
factor = xsection * self.main.lumi * 1000 / ntot
else:
factor = 0
self.Nrejected[icut].mean *= factor
self.Nrejected[icut].error = Measure.binomialNEventError(self.Nrejected[icut].mean,self.Ntotal.mean)
# compute final error
self.Nrejected[icut].error = sqrt(\
self.Nrejected[icut].error**2 + errXsec**2)
elif self.main.normalize == NormalizeType.LUMI_WEIGHT:
# error due to xsec
if ntot!=0:
errXsec = xerror * self.main.lumi * 1000 * self.dataset.weight * self.Nrejected[icut].mean / ntot
else:
errXsec=0
# scale factor
if ntot!=0:
factor = xsection * self.main.lumi * self.dataset.weight * 1000 / ntot
else:
factor = 0
self.Nrejected[icut].mean *= factor
self.Nrejected[icut].error = Measure.binomialNEventError(self.Nrejected[icut].mean,self.Ntotal.mean)
# compute final error
self.Nrejected[icut].error = sqrt(\
self.Nrejected[icut].error**2 + errXsec**2)
# recompute error to efficiency
for icut in range(0,len(self.Nselected)):
if icut==0:
self.eff[icut].error = Measure.binomialError(self.Nselected[icut].mean,self.Ntotal.mean)
else:
self.eff[icut].error = Measure.binomialError(self.Nselected[icut].mean,self.Nselected[icut-1].mean)
self.effcumu[icut].error = Measure.binomialError(self.Nselected[icut].mean,self.Ntotal.mean)
def Compute(self, s, es, b, eb):
# Initialization
value = Measure()
# Converting in floating value
S = float(s)
B = float(b)
ES = float(es)
EB = float(eb)
# Mean value
try:
if self.formula == 1:
value.mean = S / B
elif self.formula == 2:
value.mean = S / sqrt(B)
elif self.formula == 3:
value.mean = S / (S + B)
elif self.formula == 4:
value.mean = S / sqrt(S + B)
elif self.formula == 5:
value.mean = S / sqrt(S + B + (self.x * B)**2)
except ZeroDivisionError: # division by 0
value.mean = -1
except ValueError: # negative sqrt
value.mean = -1
# Error value
try:
if self.formula == 1:
value.error = 1./(B**2)*\
sqrt(B**2*ES**2+S**2*EB**2)
elif self.formula == 2:
value.error = 1./(S+B)**2*\
sqrt(B**2*ES**2+S**2*EB**2)
elif self.formula == 3:
value.error = 1./(2*pow(B,3./2.))*\
sqrt((2*B)**2*ES**2+S**2*EB**2)
elif self.formula == 4:
value.error = 1./(2*pow(S+B,3./2.))*\
sqrt((S+2*B)**2*ES**2+S**2*EB**2)
elif self.formula == 5:
value.error = 1./(2*pow(S+B+self.x*B**2,3./2.))*\
sqrt((S+2*B+2*self.x*B**2)**2*ES**2+S**2*(2*self.x*B+1)**2*EB**2)
except ZeroDivisionError: # division by 0
value.mean = -1
except ValueError: # negative sqrt
value.mean = -1
return value
def Initialize(self):
# Preparing architecture for vectors
self.Ntotal = Measure()
self.Ntotal_posweight = Measure()
self.Ntotal_negweight = Measure()
self.Ntotal_sumw2 = Measure()
self.Ntotal_sumw2_posweight = Measure()
self.Ntotal_sumw2_negweight = Measure()
myregs = self.main.regions.GetNames()
myregs.sort()
if myregs == []:
myregs = ['myregion']
for iabscut in range(0, len(self.main.selection)):
if self.main.selection[iabscut].__class__.__name__ != "Cut":
continue
if len(self.main.selection[iabscut].part) != 0:
continue
ireg = 0
for reg in myregs:
if (reg in self.main.selection[iabscut].regions) or (
self.main.regions.GetNames() == []
and reg == "myregion"):
self.Nselected[ireg].append(Measure())
self.Nrejected[ireg].append(Measure())
self.Nselected_sumw2[ireg].append(Measure())
self.Nrejected_sumw2[ireg].append(Measure())
self.Nselected_posweight[ireg].append(Measure())
self.Nrejected_posweight[ireg].append(Measure())
self.Nselected_negweight[ireg].append(Measure())
self.Nrejected_negweight[ireg].append(Measure())
self.Nselected_sumw2_posweight[ireg].append(Measure())
self.Nrejected_sumw2_posweight[ireg].append(Measure())
self.Nselected_sumw2_negweight[ireg].append(Measure())
self.Nrejected_sumw2_negweight[ireg].append(Measure())
self.eff[ireg].append(Measure())
self.effcumu[ireg].append(Measure())
self.warnings[ireg].append([])
ireg += 1
# Extracting Nselected information
for reg in range(len(myregs)):
for icut in range(0, len(self.Nselected[reg])):
self.Nselected_posweight[reg][icut].mean = self.cuts[reg][
icut].sumw_pos
self.Nselected_negweight[reg][icut].mean = self.cuts[reg][
icut].sumw_neg
self.Nselected_sumw2_posweight[reg][icut].mean = self.cuts[
reg][icut].sumw2_pos
self.Nselected_sumw2_negweight[reg][icut].mean = self.cuts[
reg][icut].sumw2_neg
# Extracting Ntotal
self.Ntotal_posweight.mean = self.initial.sumw_pos
self.Ntotal_negweight.mean = self.initial.sumw_neg
self.Ntotal_sumw2_posweight.mean = self.initial.sumw2_pos
self.Ntotal_sumw2_negweight.mean = self.initial.sumw2_neg
return True
def Calculate(self):
myregs = self.main.regions.GetNames()
if myregs == []:
myregs = ['myregion']
# Calculating Nrejected for positive and negative weighted events
for reg in range(len(myregs)):
for icut in range(0, len(self.Nselected[reg])):
if icut == 0:
self.Nrejected_posweight[reg][
icut].mean = self.Ntotal_posweight.mean - self.Nselected_posweight[
reg][icut].mean
self.Nrejected_negweight[reg][
icut].mean = self.Ntotal_negweight.mean - self.Nselected_negweight[
reg][icut].mean
else:
self.Nrejected_posweight[reg][
icut].mean = self.Nselected_posweight[reg][
icut -
1].mean - self.Nselected_posweight[reg][icut].mean
self.Nrejected_negweight[reg][
icut].mean = self.Nselected_negweight[reg][
icut -
1].mean - self.Nselected_negweight[reg][icut].mean
# Combining negative & positive weight events for computing Nselected, Nrejected and Ntotal
self.Ntotal.mean = self.Ntotal_posweight.mean - self.Ntotal_negweight.mean
for reg in range(len(myregs)):
for icut in range(0, len(self.Nselected[reg])):
self.Nselected[reg][icut].mean = self.Nselected_posweight[reg][
icut].mean - self.Nselected_negweight[reg][icut].mean
self.Nrejected[reg][icut].mean = self.Nrejected_posweight[reg][
icut].mean - self.Nrejected_negweight[reg][icut].mean
# Checking that all numbers are positive : Nselected and Ntotal
for reg in range(len(myregs)):
for icut in range(0, len(self.Nselected[reg])):
if self.Nselected[reg][icut].mean < 0:
self.warnings[reg][icut].append('The number of selected events is negative: '+\
str(self.Nselected[reg][icut].mean)+'. Set to 0.')
self.Nselected[reg][icut].mean = 0
if self.Nrejected[reg][icut].mean < 0:
self.warnings[reg][icut].append('The number of rejected events is negative: '+\
str(self.Nrejected[reg][icut].mean)+'. Set to 0.')
self.Nrejected[reg][icut].mean = 0
# Checking that a N cut i > N cut i+1 : Nselected and Nrejected
for reg in range(len(myregs)):
for icut in range(0, len(self.Nselected[reg])):
if icut == 0:
if self.Nselected[reg][icut].mean > self.Ntotal.mean:
self.warnings[reg][icut].append('The number of selected events > the initial number of events: '+\
str(self.Nselected[reg][icut].mean)+' > '+str(self.Ntotal.mean)+'. Set the number of selected events to 0.')
self.Nselected[reg][icut].mean = 0
else:
if self.Nselected[reg][icut].mean > self.Nselected[reg][
icut - 1].mean:
self.warnings[reg][icut].append('The number of selected events > the initial number of events: '+\
str(self.Nselected[reg][icut].mean)+' > '+str(self.Nselected[reg][icut-1].mean)+'. Set the number of selected events to 0.')
self.Nselected[reg][icut].mean = 0
# Calculating errors on Naccepted and Nrejected
for reg in range(len(myregs)):
for icut in range(0, len(self.Nselected[reg])):
self.Nselected[reg][icut].error = Measure.binomialNEventError(
self.Nselected[reg][icut].mean, self.Ntotal.mean)
self.Nrejected[reg][icut].error = Measure.binomialNEventError(
self.Nrejected[reg][icut].mean, self.Ntotal.mean)
# efficiency calculation and its error
for reg in range(len(myregs)):
for icut in range(0, len(self.Nselected[reg])):
if icut == 0:
if self.Ntotal.mean == 0:
self.eff[reg][icut].mean = 0
else:
self.eff[reg][icut].mean = float(self.Nselected[reg][icut].mean) / \
float(self.Ntotal.mean)
self.eff[reg][icut].error = Measure.binomialError(
self.Nselected[reg][icut].mean, self.Ntotal.mean)
else:
if self.Nselected[reg][icut - 1].mean == 0:
self.eff[reg][icut].mean = 0
else:
self.eff[reg][icut].mean = float(self.Nselected[reg][icut].mean) / \
float(self.Nselected[reg][icut-1].mean)
self.eff[reg][icut].error = Measure.binomialError(
self.Nselected[reg][icut].mean,
self.Nselected[reg][icut - 1].mean)
if self.Ntotal.mean == 0:
self.effcumu[reg][icut].mean = 0
else:
self.effcumu[reg][icut].mean = float(self.Nselected[reg][icut].mean) / \
float(self.Ntotal.mean)
self.effcumu[reg][icut].error = Measure.binomialError(
self.Nselected[reg][icut].mean, self.Ntotal.mean)
# Getting xsection
xsection = self.dataset.measured_global.xsection
xerror = self.dataset.measured_global.xerror
if self.dataset.xsection != 0.:
xsection = self.dataset.xsection
xerror = 0
# Saving ntotal
ntot = 0. + self.Ntotal.mean
# Scaling Ntotal
if self.main.normalize == NormalizeType.LUMI:
self.Ntotal.error = xerror * self.main.lumi * 1000
self.Ntotal.mean = xsection * self.main.lumi * 1000
elif self.main.normalize == NormalizeType.LUMI_WEIGHT:
self.Ntotal.error = xerror * self.main.lumi * 1000 * \
self.dataset.weight
self.Ntotal.mean = xsection * self.main.lumi * 1000 * \
self.dataset.weight
# Scaling Nselected
for reg in range(len(myregs)):
for icut in range(0, len(self.Nselected[reg])):
if self.main.normalize == NormalizeType.LUMI:
# error due to xsec
if ntot != 0:
errXsec = xerror * self.main.lumi * 1000 * self.Nselected[
reg][icut].mean / ntot
else:
errXsec = 0
# scale factor
if ntot != 0:
factor = xsection * self.main.lumi * 1000 / ntot
else:
factor = 0
self.Nselected[reg][icut].mean *= factor
self.Nselected[reg][
icut].error = Measure.binomialNEventError(
self.Nselected[reg][icut].mean, self.Ntotal.mean)
# compute final error
self.Nselected[reg][icut].error = sqrt(
self.Nselected[reg][icut].error**2 + errXsec**2)
elif self.main.normalize == NormalizeType.LUMI_WEIGHT:
# error due to xsec
if ntot != 0:
errXsec = xerror * self.main.lumi * 1000 * self.dataset.weight * self.Nselected[
reg][icut].mean / ntot
else:
errXsec = 0
# scale factor
if ntot != 0:
factor = xsection * self.main.lumi * self.dataset.weight * 1000 / ntot
else:
factor = 0
self.Nselected[reg][icut].mean *= factor
self.Nselected[reg][
icut].error = Measure.binomialNEventError(
self.Nselected[reg][icut].mean, self.Ntotal.mean)
# compute final error
self.Nselected[reg][icut].error = sqrt(
self.Nselected[reg][icut].error**2 + errXsec**2)
# Scaling Nrejected
for reg in range(len(myregs)):
for icut in range(0, len(self.Nrejected[reg])):
if self.main.normalize == NormalizeType.LUMI:
# error due to xsec
if ntot != 0:
errXsec = xerror * self.main.lumi * 1000 * self.Nrejected[
reg][icut].mean / ntot
else:
errXsec = 0
# scale factor
if ntot != 0:
factor = xsection * self.main.lumi * 1000 / ntot
else:
factor = 0
self.Nrejected[reg][icut].mean *= factor
self.Nrejected[reg][
icut].error = Measure.binomialNEventError(
self.Nrejected[reg][icut].mean, self.Ntotal.mean)
# compute final error
self.Nrejected[reg][icut].error = sqrt(
self.Nrejected[reg][icut].error**2 + errXsec**2)
elif self.main.normalize == NormalizeType.LUMI_WEIGHT:
# error due to xsec
if ntot != 0:
errXsec = xerror * self.main.lumi * 1000 * self.dataset.weight * self.Nrejected[
reg][icut].mean / ntot
else:
errXsec = 0
# scale factor
if ntot != 0:
factor = xsection * self.main.lumi * self.dataset.weight * 1000 / ntot
else:
factor = 0
self.Nrejected[reg][icut].mean *= factor
self.Nrejected[reg][
icut].error = Measure.binomialNEventError(
self.Nrejected[reg][icut].mean, self.Ntotal.mean)
# compute final error
self.Nrejected[reg][icut].error = sqrt(
self.Nrejected[reg][icut].error**2 + errXsec**2)
# recompute error to efficiency
for reg in range(len(myregs)):
for icut in range(0, len(self.Nselected[reg])):
if icut == 0:
self.eff[reg][icut].error = Measure.binomialError(
self.Nselected[reg][icut].mean, self.Ntotal.mean)
else:
self.eff[reg][icut].error = Measure.binomialError(
self.Nselected[reg][icut].mean,
self.Nselected[reg][icut - 1].mean)
self.effcumu[reg][icut].error = Measure.binomialError(
self.Nselected[reg][icut].mean, self.Ntotal.mean)
def Initialize(self):
# Preparing architecture for vectors
self.Ntotal = Measure()
self.Ntotal_posweight = Measure()
self.Ntotal_negweight = Measure()
self.Ntotal_sumw2 = Measure()
self.Ntotal_sumw2_posweight = Measure()
self.Ntotal_sumw2_negweight = Measure()
for iabscut in range(0, len(self.main.selection)):
if self.main.selection[iabscut].__class__.__name__ != "Cut":
continue
self.Nselected.append(Measure())
self.Nrejected.append(Measure())
self.Nselected_sumw2.append(Measure())
self.Nrejected_sumw2.append(Measure())
self.Nselected_posweight.append(Measure())
self.Nrejected_posweight.append(Measure())
self.Nselected_negweight.append(Measure())
self.Nrejected_negweight.append(Measure())
self.Nselected_sumw2_posweight.append(Measure())
self.Nrejected_sumw2_posweight.append(Measure())
self.Nselected_sumw2_negweight.append(Measure())
self.Nrejected_sumw2_negweight.append(Measure())
self.eff.append(Measure())
self.effcumu.append(Measure())
self.warnings.append([])
# Extracting Nselected information
for icut in range(0, len(self.Nselected)):
self.Nselected_posweight[icut].mean = self.cuts[icut].sumw_pos
self.Nselected_negweight[icut].mean = self.cuts[icut].sumw_neg
self.Nselected_sumw2_posweight[icut].mean = self.cuts[
icut].sumw2_pos
self.Nselected_sumw2_negweight[icut].mean = self.cuts[
icut].sumw2_neg
# Extracting Ntotal
self.Ntotal_posweight.mean = self.initial.sumw_pos
self.Ntotal_negweight.mean = self.initial.sumw_neg
self.Ntotal_sumw2_posweight.mean = self.initial.sumw2_pos
self.Ntotal_sumw2_negweight.mean = self.initial.sumw2_neg
return True
def calculateBSratio(self,B,eB,S,eS):
value = Measure()
value.mean = self.Mformula.Eval(S,B)
value.error = self.Eformula.Eval(S,B,eS,eB)
return value
def calculateBSratio(self, B, eB, S, eS):
value = Measure()
value.mean = self.Mformula.Eval(S, B)
value.error = self.Eformula.Eval(S, B, eS, eB)
return value
