def createDataSet(self, dname, dcut):
"""Return named dataset, create if not exist"""
if dname in self.dataset.keys() and not self.process.cfg['args'].force:
self.logger.logINFO("\033[0;34;47m Dataset: ", dname,
" Already Exists! \033[0m. Total Entries:",
self.dataset[dname].sumEntries())
self.logger.logDEBUG(dcut, Stamp=False)
return 1
tempfile_preload = ROOT.TFile(tempfile.gettempdir() + "/temp.root",
'RECREATE') #Pritam
RooCut = ROOT.RooFit.Cut(dcut)
Import = ROOT.RooFit.Import(self.ch)
Range = ROOT.RooFit.CutRange(
dname.split(".")[2]) # Not taking effect, need review
Weight = ROOT.RooFit.WeightVar(self.cfg['weight'])
if self.argset.find("Bmass"):
self.argset.find(
"Bmass").removeRange() # Analysis specific line introduced
if "dataReader" in dname or "sigMCGENReader" in dname:
data = RooDataSet(dname, "", self.argset, Import, RooCut, Range)
else:
data = RooDataSet(dname, "Weighted dataset", self.argset, Import,
RooCut, Range, Weight)
if self.argset.find("Phimass"):
self.argset.find("Phimass").setBins(20)
datahist = ROOT.RooDataHist(
dname + ".hist", "",
ROOT.RooArgSet(self.argset.find("Phimass")), data)
self.dataset[dname + ".hist"] = deepcopy(datahist)
data.Write()
self.dataset[dname] = deepcopy(data)
self.logger.logINFO("\033[0;34;47m Creating Dataset: ", dname,
": \033[0m. Total Entries:", data.sumEntries())
self.logger.logDEBUG(dcut, Stamp=False)
tempfile_preload.Close() #Pritam
return 1
dataSetAsymW = RooDataSet( 'asymDataW', 'asymDataW', obsSet, Import = dataSetAsym, WeightVar = ( 'weightVar', True ) )
del dataSetAsym
ws.put(dataSetAsymW)
del dataSetAsymW
dataSetAsymW = ws['asymDataW']
obsSet = RooArgSet( dataSetAsymW.get() )
dataSetAsymW.Print()
# get sums of weights
sumW = dict( plus = 0., minus = 0. )
for evSet in dataSetAsymW :
if evSet.getCatIndex('asymCat') == 1 :
sumW['plus'] += dataSetAsymW.weight()
else :
sumW['minus'] += dataSetAsymW.weight()
assert abs( dataSetAsymW.sumEntries() - sumW['plus'] - sumW['minus'] ) < 1.e-5
if applyAngWeights :
ASumW = 2. * sumW['plus'] - ( sumW['plus'] + sumW['minus'] )
else :
ASumW = 2. * sumW['plus'] / ( sumW['plus'] + sumW['minus'] ) - 1.
# create arrays of time bins
from array import array
timeArr = array( 'd', [ ( periodShift + ( float(it) + binOffset + 0.5 ) / float(numTimeBins) ) * oscPeriod\
for it in range( numTimeBins + 1 ) ] )
timeErrArr = array( 'd', [ 0.5 / float(numTimeBins) * oscPeriod ] * ( numTimeBins + 1 ) )
timeArrPdf = array( 'd', [ ( periodShift + ( float(it) + binOffset + float(frac) ) / float(numTimeBins) ) * oscPeriod\
for it in range( numTimeBins + 1 ) for frac in timeFracs ]\
+ [ ( periodShift + 1. + ( 1. + binOffset + float( timeFracs[0] ) ) / float(numTimeBins) ) * oscPeriod ] )
timeErrArrPdf = array( 'd', [ 0. ] * len(timeArrPdf) )
# print bin,
# for val in rVals :
# print '%s: %.3f - %.3f ' % ( val, t.getMin(val), t.getMax(val) ),
# for vals in tVals :
# print '[%s]' % ', '.join( '%.3f' % val for val in vals ),
# print
# create PDF integrals in bins for plus and minus categories
emptySet = RooArgSet()
timeSet = RooArgSet( ws['time'] )
angleSet = RooArgSet( ws[varName] for varName in [ 'helcosthetaK', 'helcosthetaL', 'helphi' ] )
intSet = RooArgSet(timeSet)
intSet.add(angleSet)
from ROOT import RooExplicitNormPdf
asymPdfs = dict( plus = RooExplicitNormPdf( 'pdfPlus', 'pdfPlus', timeSet, angleSet, pdf._var, pdf._var
, projDataSets['plus'].sumEntries() / dataSetAsymW.sumEntries(), projDataSets['plus'] )
, minus = RooExplicitNormPdf( 'pdfMinus', 'pdfMinus', timeSet, angleSet, pdf._var, pdf._var
, projDataSets['minus'].sumEntries() / dataSetAsymW.sumEntries(), projDataSets['minus'] )
)
asymPdfInts = dict( plus = dict( [ ( bin, RooExplicitNormPdf( 'pdfPlus%02d' % bin, 'pdfPlus%02d' % bin, emptySet, intSet, pdf._var
, pdf._var, projDataSets['plus'].sumEntries() / dataSetAsymW.sumEntries()
, projDataSets['plus'], ','.join( name for name in rangeNames[bin] )
) ) for bin in sorted( rangeNames.keys() )
] )
, minus = dict( [ ( bin, RooExplicitNormPdf( 'pdfMinus%02d' % bin, 'pdfMinus%02d' % bin, emptySet, intSet, pdf._var
, pdf._var, projDataSets['minus'].sumEntries() / dataSetAsymW.sumEntries()
, projDataSets['minus'], ','.join( name for name in rangeNames[bin] )
) ) for bin in sorted( rangeNames.keys() )
] )
)
if args[0].startswith('MC'):
from ROOT import TFile
sig_file = TFile(input_data['sig_cache'])
sig_data = sig_file.Get(input_data['sig_dataset'])
prompt_file = TFile(input_data['prompt_cache'])
prompt_data = prompt_file.Get(input_data['prompt_dataset'])
else:
sig_file = TFile("/project/bfys/jleerdam/data/Bs2Jpsiphi/Reco14/fitNTuple_peakBkg_2011_2012_Reco14_TOS_HLT2B_20140415.root")
sig_tree = sig_file.Get("DecayTree")
period = 'p' + args[0][:4]
sig_data = RooDataSet('sig_data', 'sig_data', RooArgSet(momentum, weight, runPeriod),
RooFit.Import(sig_tree), RooFit.WeightVar(weight),
RooFit.Cut('runPeriod == runPeriod::%s' % period))
from ROOT import TFile
prompt_file = TFile(input_data['cache'])
prompt_data = prompt_file.Get(input_data['dataset'])
from ROOT import TCanvas
canvas = TCanvas('momentum_canvas', 'momentum_canvas', 600, 400)
canvas.SetLogy()
frame = momentum.frame(Range = (0, 500000))
from ROOT import kBlue, kGreen
sig_data.plotOn(frame, Rescale = (1 / sig_data.sumEntries()), MarkerColor = kBlue)
prompt_data.plotOn(frame, Rescale = (1 / prompt_data.sumEntries()), MarkerColor = kGreen)
frame.GetXaxis().SetTitle("P_{B} [MeV]")
frame.GetYaxis().SetTitle("scaled candidates")
frame.GetYaxis().SetRangeUser(0.00005, 0.1)
frame.Draw()
massLb = space.var('lbl0Mass')
massTkTk = space.var('tktkMass')
massLb.setBins(50)
massLb.setRange('sigRangeLb', 5.4, 5.9)
loadDatasetLb = RooDataSet(
'loadDatasetLb', 'loadData16', inN16,
RooArgSet(massLb, massTkTk, space.var('lbl0Pt'))).reduce(
'tktkMass>1.110&&tktkMass<1.120 &&{0}'.format(ptCut))
loadDatasetlB = RooDataSet(
'loadDatasetlB', 'loadData16', inn16,
RooArgSet(massLb, massTkTk, space.var('lbl0Pt'))).reduce(
'tktkMass>1.110&&tktkMass<1.120 &&{0}'.format(ptCut))
totNum = loadDatasetLb.sumEntries()
space.factory('numLb[{0},-1000.,{1}]'.format(
space1st.var('numLb').getVal(), totNum))
simulComponents = []
# scan Lb likelihood {{{
# jack's profile likelihood scan
if sysFitLb:
label = 'sysLbFit'
numSig = spaceExt.var('numLb')
numBkg = spaceExt.var('numCombBkg_Run2016Data_pLbL0')
varName = 'lbl0Mass'
figDir.cd()
class ToyDataSetManager(RootHelperBase):
def __init__(self):
"""Initialize whatever is needed"""
self.my_logger = Logger()
self.log = self.my_logger.getLogger(self.__class__.__name__, 10)
# }
self.DEBUG = self.my_logger.is_debug()
self.pp = pprint.PrettyPrinter(indent=4)
# initialize RooFit
gSystem.Load("libHiggsAnalysisCombinedLimit.so")
self.output_filename = "worskapce_with_embedded_toys.root"
def set_toys_path(self, toys_path):
"""
Set the path for the toy dataset.There is aleays one active toy held in self.toys.
"""
self.toys_path = toys_path
self.toys = self.get_object(path=toys_path, object_type=RooAbsData, clone=False)
def set_workspace_path(self, ws_path):
"""
Set the path for the workspace where toys will be included.
There is only one workspace that can be active in the class.
"""
self.ws = self.get_object(path=ws_path, object_type=RooWorkspace, clone=False)
def set_output_file_name(self, output_filename):
"""
Set the name of the output root file.
"""
self.output_filename = output_filename
def set_new_toys_name(self, new_toys_name):
"""
Set name for toys in the workspace
"""
self.new_toys_name = new_toys_name
def import_toys_to_ws(self, ws_path=None, toys_path=None, output_filename=None, new_toys_name=None):
"""
Imports a given toys dataset (or multiple toys) into the workspace and dumps to new root file.
Parameters:
-----------
ws_path : path to exisitng workspace (string)
toys_path : path or list of paths to toys.TODO add regexp parsing to import matching toys.
output_filename : file name of the output workspace
new_toys_name : in case of one toy import, a new name can be set. In case of list, the name is set
to be the same as in the source file.
Returns:
--------
Returns 0 in case it goes trough without erorrs(?).
"""
# TODO set checks for the input provided
if ws_path:
self.set_workspace_path(ws_path)
if output_filename:
self.set_output_file_name(output_filename)
if new_toys_name:
self.set_new_toys_name(new_toys_name)
try:
self.ws
except AttributeError:
raise AttributeError, "You need to provide workspace path."
if toys_path:
toys_path_list = []
if isinstance(toys_path, list):
toys_path_list = toys_path
elif isinstance(toys_path, str):
toys_path_list = [toys_path]
for the_toy in toys_path_list:
self.set_toys_path(the_toy)
toys_name = self.get_paths(the_toy)[-1] # just getthe name of toys object in the root file.
self.log.info("Setting toys name in workspace to: {0}".format(toys_name))
self.set_new_toys_name(toys_name)
self.toys.SetName(self.new_toys_name)
getattr(self.ws, "import")(self.toys)
self.log.info(
"Imported DataSet '{0}' into workspace '{1}'.".format(self.toys.GetName(), self.ws.GetName())
)
else:
try:
self.toys
except AttributeError:
raise AttributeError, "You need to provide toys path."
try:
self.new_toys_name
except AttributeError:
toys_name = self.get_paths(self.toys_path)[-1] # just getthe name of toys object in the root file.
self.log.info("Setting toys name in workspace to: {0}".format(toys_name))
self.set_new_toys_name(toys_name)
self.toys.SetName(self.new_toys_name)
getattr(self.ws, "import")(self.toys)
self.log.info("Imported DataSet '{0}' into workspace '{1}'.".format(self.toys.GetName(), self.ws.GetName()))
self.ws.data(self.toys.GetName()).Print()
self.ws.data(self.toys.GetName()).Print("v")
# write workspace
self.ws.writeToFile(self.output_filename)
self.log.info("Writing workspace '{0}' to file {1}".format(self.ws.GetName(), self.output_filename))
return 0
def set_dataset_name(self, dataset_name):
"""
Set name of the dataset in workspace.
"""
self.dataset_name = dataset_name
def import_dataset_to_ws(self, dataset, workspace, output_filename=None, new_name=None):
"""
Import dataset to worspace workspace.
"""
if new_name:
dataset.SetName(new_name)
if output_filename:
self.set_output_file_name(output_filename)
self.log.info(
"Imported DataSet '{0}' into workspace '{1}' and written to file {2}.".format(
dataset.GetName(), workspace.GetName(), self.output_filename
)
)
pass
def set_workspace(self, workspace):
"""
Provide workspace from path naload it to self.ws or
provide directly workspace and load it to self.ws
"""
if isinstance(workspace, RooWorkspace):
self.ws = workspace
self.log.debug("Loaded in workspace {0}.".format(self.ws.GetName()))
elif isinstance(workspace, str):
self.set_workspace_path(self, workspace)
self.log.debug("Loaded in workspace {0} from path: ".format(workspace))
def dump_datasets_to_file(self, output_filename=None, access="RECREATE"):
"""
Write all datasets collected in the basket(RootHelperBase) to a file.
"""
if output_filename:
self.set_output_file_name(output_filename)
self.dump_basket_to_file(self.output_filename, access)
self.log.info("All items from the basket have been written to file: {0}".format(self.output_filename))
return 0
def get_dataset_from_tree(
self,
path_to_tree,
tree_variables,
weight="1==1",
weight_var_name=0,
dataset_name="my_dataset",
basket=True,
category=None,
):
"""
Creates RooDataSet from a plain root tree given:
- variables name list
- weight expression. It works in the same way as TTree cut.
Returns:
--------
- RooDataSet
- also fills the basket with datasets (basket inhereted from RootHelperBase class)
TODO
----
- add implementation for category setting(check in prepare_toy_datasets_for_sync)
- check if adding toy dataset to each channel workspace individually behaves well
after combineCards.py.
"""
# make RooRealVars from tree_variables
my_arg_set = RooArgSet()
my_rrv = dict()
for var_name in tree_variables:
# TODO implement check that branch exist
my_rrv[var_name] = RooRealVar(var_name, var_name, -999999999, 999999999)
my_arg_set.add(my_rrv[var_name])
if self.DEBUG:
self.log.debug("RooArgSet is now:")
my_arg_set.Print()
# get the tree from path_to_tree
my_tree = self.get_TTree(path_to_tree, cut=weight)
self.log.debug("Selected tree contains {0} events".format(my_tree.GetEntries()))
# create RooDataSet and reduce tree if needed
# self.dataset_from_tree = RooDataSet(dataset_name, dataset_name, my_tree, my_arg_set, weight).reduce(my_arg_set)
self.dataset_from_tree = RooDataSet(dataset_name, dataset_name, my_tree, my_arg_set)
# self.dataset_from_tree = RooDataSet(dataset_name, dataset_name, my_tree, my_arg_set, "", weight_var_name)
# data[j]=new RooDataSet(Form("data%d",j),Form("data%d",j),outTree,RooArgSet(rCMS_zz4l_widthKD,rCMS_zz4l_widthMass,rweightFit),"","_weight_");
self.log.debug("RooDataSet contains {0} events".format(self.dataset_from_tree.sumEntries()))
# .reduce(ROOT.RooArgSet(self.D0))
self.current_arg_set = my_arg_set
# add dataset to basket
if basket:
self.add_to_basket(self.dataset_from_tree, new_name=dataset_name, new_title=dataset_name)
return self.dataset_from_tree
def get_current_arg_set(self):
"""
Return last dataset setup used by get_dataset_from_tree().
"""
return self.current_arg_set
def alpha(channel):
nElec = channel.count('e')
nMuon = channel.count('m')
nLept = nElec + nMuon
nBtag = channel.count('b')
# Channel-dependent settings
# Background function. Semi-working options are: EXP, EXP2, EXPN, EXPTAIL
if nLept == 0:
treeName = 'SR'
signName = 'XZh'
colorVjet = sample['DYJetsToNuNu']['linecolor']
triName = "HLT_PFMET"
leptCut = "0==0"
topVeto = selection["TopVetocut"]
massVar = "X_cmass"
binFact = 1
#fitFunc = "EXP"
#fitFunc = "EXP2"
#fitFunc = "EXPN"
#fitFunc = "EXPTAIL"
fitFunc = "EXPN" if nBtag < 2 else "EXP"
fitAltFunc = "EXPTAIL" if nBtag < 2 else "EXPTAIL"
fitFuncVjet = "ERFEXP" if nBtag < 2 else "ERFEXP"
fitFuncVV = "EXPGAUS"
fitFuncTop = "GAUS2"
elif nLept == 1:
treeName = 'WCR'
signName = 'XWh'
colorVjet = sample['WJetsToLNu']['linecolor']
triName = "HLT_Ele" if nElec > 0 else "HLT_Mu"
leptCut = "isWtoEN" if nElec > 0 else "isWtoMN"
topVeto = selection["TopVetocut"]
massVar = "X_mass"
binFact = 2
if nElec > 0:
fitFunc = "EXP" if nBtag < 2 else "EXP"
fitAltFunc = "EXPTAIL" if nBtag < 2 else "EXPTAIL"
else:
fitFunc = "EXPTAIL" if nBtag < 2 else "EXP"
fitAltFunc = "EXPN" if nBtag < 2 else "EXPTAIL"
fitFuncVjet = "ERFEXP" if nBtag < 2 else "ERFEXP"
fitFuncVV = "EXPGAUS"
fitFuncTop = "GAUS3" if nBtag < 2 else "GAUS2"
else:
treeName = 'XZh'
signName = 'XZh'
colorVjet = sample['DYJetsToLL']['linecolor']
triName = "HLT_Ele" if nElec > 0 else "HLT_Mu"
leptCut = "isZtoEE" if nElec > 0 else "isZtoMM"
topVeto = "0==0"
massVar = "X_mass"
binFact = 5
if nElec > 0:
fitFunc = "EXP" if nBtag < 2 else "EXP"
fitAltFunc = "POW" if nBtag < 2 else "POW"
else:
fitFunc = "EXP" if nBtag < 2 else "EXP"
fitAltFunc = "POW" if nBtag < 2 else "POW"
fitFuncVjet = "ERFEXP" if nBtag < 2 else "EXP"
fitFuncVV = "EXPGAUS2"
fitFuncTop = "GAUS"
btagCut = selection["2Btag"] if nBtag == 2 else selection["1Btag"]
print "--- Channel", channel, "---"
print " number of electrons:", nElec, " muons:", nMuon, " b-tags:", nBtag
print " read tree:", treeName, "and trigger:", triName
if ALTERNATIVE: print " using ALTERNATIVE fit functions"
print "-"*11*2
# Silent RooFit
RooMsgService.instance().setGlobalKillBelow(RooFit.FATAL)
#*******************************************************#
# #
# Variables and selections #
# #
#*******************************************************#
# Define all the variables from the trees that will be used in the cuts and fits
# this steps actually perform a "projection" of the entire tree on the variables in thei ranges, so be careful once setting the limits
X_mass = RooRealVar( massVar, "m_{X}" if nLept > 0 else "m_{T}^{X}", XBINMIN, XBINMAX, "GeV")
J_mass = RooRealVar( "fatjet1_prunedMassCorr", "corrected pruned mass", HBINMIN, HBINMAX, "GeV")
CSV1 = RooRealVar( "fatjet1_CSVR1", "", -1.e99, 1.e4 )
CSV2 = RooRealVar( "fatjet1_CSVR2", "", -1.e99, 1.e4 )
nBtag = RooRealVar( "fatjet1_nBtag", "", 0., 4 )
CSVTop = RooRealVar( "bjet1_CSVR", "", -1.e99, 1.e4 )
isZtoEE = RooRealVar("isZtoEE", "", 0., 2 )
isZtoMM = RooRealVar("isZtoMM", "", 0., 2 )
isWtoEN = RooRealVar("isWtoEN", "", 0., 2 )
isWtoMN = RooRealVar("isWtoMN", "", 0., 2 )
weight = RooRealVar( "eventWeightLumi", "", -1.e9, 1. )
# Define the RooArgSet which will include all the variables defined before
# there is a maximum of 9 variables in the declaration, so the others need to be added with 'add'
variables = RooArgSet(X_mass, J_mass, CSV1, CSV2, nBtag, CSVTop)
variables.add(RooArgSet(isZtoEE, isZtoMM, isWtoEN, isWtoMN, weight))
# Define the ranges in fatJetMass - these will be used to define SB and SR
J_mass.setRange("LSBrange", LOWMIN, LOWMAX)
J_mass.setRange("HSBrange", HIGMIN, HIGMAX)
J_mass.setRange("VRrange", LOWMAX, SIGMIN)
J_mass.setRange("SRrange", SIGMIN, SIGMAX)
J_mass.setBins(54)
# Define the selection for the various categories (base + SR / LSBcut / HSBcut )
baseCut = leptCut + " && " + btagCut + "&&" + topVeto
massCut = massVar + ">%d" % XBINMIN
baseCut += " && " + massCut
# Cuts
SRcut = baseCut + " && %s>%d && %s<%d" % (J_mass.GetName(), SIGMIN, J_mass.GetName(), SIGMAX)
LSBcut = baseCut + " && %s>%d && %s<%d" % (J_mass.GetName(), LOWMIN, J_mass.GetName(), LOWMAX)
HSBcut = baseCut + " && %s>%d && %s<%d" % (J_mass.GetName(), HIGMIN, J_mass.GetName(), HIGMAX)
SBcut = baseCut + " && ((%s>%d && %s<%d) || (%s>%d && %s<%d))" % (J_mass.GetName(), LOWMIN, J_mass.GetName(), LOWMAX, J_mass.GetName(), HIGMIN, J_mass.GetName(), HIGMAX)
VRcut = baseCut + " && %s>%d && %s<%d" % (J_mass.GetName(), LOWMAX, J_mass.GetName(), SIGMIN)
# Binning
binsJmass = RooBinning(HBINMIN, HBINMAX)
binsJmass.addUniform(HBINS, HBINMIN, HBINMAX)
binsXmass = RooBinning(XBINMIN, XBINMAX)
binsXmass.addUniform(binFact*XBINS, XBINMIN, XBINMAX)
#*******************************************************#
# #
# Input files #
# #
#*******************************************************#
# Import the files using TChains (separately for the bkg "classes" that we want to describe: here DY and VV+ST+TT)
treeData = TChain(treeName)
treeMC = TChain(treeName)
treeVjet = TChain(treeName)
treeVV = TChain(treeName)
treeTop = TChain(treeName)
# treeSign = {}
# nevtSign = {}
# Read data
pd = getPrimaryDataset(triName)
if len(pd)==0: raw_input("Warning: Primary Dataset not recognized, continue?")
for i, s in enumerate(pd): treeData.Add(NTUPLEDIR + s + ".root")
# Read V+jets backgrounds
for i, s in enumerate(["WJetsToLNu_HT", "DYJetsToNuNu_HT", "DYJetsToLL_HT"]):
for j, ss in enumerate(sample[s]['files']): treeVjet.Add(NTUPLEDIR + ss + ".root")
# Read VV backgrounds
for i, s in enumerate(["VV"]):
for j, ss in enumerate(sample[s]['files']): treeVV.Add(NTUPLEDIR + ss + ".root")
# Read Top backgrounds
for i, s in enumerate(["ST", "TTbar"]):
for j, ss in enumerate(sample[s]['files']): treeTop.Add(NTUPLEDIR + ss + ".root")
# Sum all background MC
treeMC.Add(treeVjet)
treeMC.Add(treeVV)
treeMC.Add(treeTop)
# create a dataset to host data in sideband (using this dataset we are automatically blind in the SR!)
setDataSB = RooDataSet("setDataSB", "setDataSB", variables, RooFit.Cut(SBcut), RooFit.WeightVar(weight), RooFit.Import(treeData))
setDataLSB = RooDataSet("setDataLSB", "setDataLSB", variables, RooFit.Import(setDataSB), RooFit.Cut(LSBcut), RooFit.WeightVar(weight))
setDataHSB = RooDataSet("setDataHSB", "setDataHSB", variables, RooFit.Import(setDataSB), RooFit.Cut(HSBcut), RooFit.WeightVar(weight))
# Observed data (WARNING, BLIND!)
setDataSR = RooDataSet("setDataSR", "setDataSR", variables, RooFit.Cut(SRcut), RooFit.WeightVar(weight), RooFit.Import(treeData))
setDataVR = RooDataSet("setDataVR", "setDataVR", variables, RooFit.Cut(VRcut), RooFit.WeightVar(weight), RooFit.Import(treeData)) # Observed in the VV mass, just for plotting purposes
# same for the bkg datasets from MC, where we just apply the base selections (not blind)
setVjet = RooDataSet("setVjet", "setVjet", variables, RooFit.Cut(baseCut), RooFit.WeightVar(weight), RooFit.Import(treeVjet))
setVjetSB = RooDataSet("setVjetSB", "setVjetSB", variables, RooFit.Import(setVjet), RooFit.Cut(SBcut), RooFit.WeightVar(weight))
setVjetSR = RooDataSet("setVjetSR", "setVjetSR", variables, RooFit.Import(setVjet), RooFit.Cut(SRcut), RooFit.WeightVar(weight))
setVV = RooDataSet("setVV", "setVV", variables, RooFit.Cut(baseCut), RooFit.WeightVar(weight), RooFit.Import(treeVV))
setVVSB = RooDataSet("setVVSB", "setVVSB", variables, RooFit.Import(setVV), RooFit.Cut(SBcut), RooFit.WeightVar(weight))
setVVSR = RooDataSet("setVVSR", "setVVSR", variables, RooFit.Import(setVV), RooFit.Cut(SRcut), RooFit.WeightVar(weight))
setTop = RooDataSet("setTop", "setTop", variables, RooFit.Cut(baseCut), RooFit.WeightVar(weight), RooFit.Import(treeTop))
setTopSB = RooDataSet("setTopSB", "setTopSB", variables, RooFit.Import(setTop), RooFit.Cut(SBcut), RooFit.WeightVar(weight))
setTopSR = RooDataSet("setTopSR", "setTopSR", variables, RooFit.Import(setTop), RooFit.Cut(SRcut), RooFit.WeightVar(weight))
print " Data events SB: %.2f" % setDataSB.sumEntries()
print " V+jets entries: %.2f" % setVjet.sumEntries()
print " VV, VH entries: %.2f" % setVV.sumEntries()
print " Top,ST entries: %.2f" % setTop.sumEntries()
# the relative normalization of the varius bkg is taken from MC by counting all the events in the full fatJetMass range
#coef = RooRealVar("coef", "coef", setVV.sumEntries()/setVjet.sumEntries(),0.,1.)
coef_VV_Vjet = RooRealVar("coef2_1", "coef2_1", setVV.sumEntries()/setVjet.sumEntries(), 0., 1.)
coef_Top_VVVjet = RooRealVar("coef3_21", "coef3_21", setTop.sumEntries()/(setVjet.sumEntries()+setVV.sumEntries()),0.,1.);
coef_VV_Vjet.setConstant(True)
coef_Top_VVVjet.setConstant(True)
# Define entries
entryVjet = RooRealVar("entryVjets", "V+jets normalization", setVjet.sumEntries(), 0., 1.e6)
entryVV = RooRealVar("entryVV", "VV normalization", setVV.sumEntries(), 0., 1.e6)
entryTop = RooRealVar("entryTop", "Top normalization", setTop.sumEntries(), 0., 1.e6)
entrySB = RooRealVar("entrySB", "Data SB normalization", setDataSB.sumEntries(SBcut), 0., 1.e6)
entrySB.setError(math.sqrt(entrySB.getVal()))
entryLSB = RooRealVar("entryLSB", "Data LSB normalization", setDataSB.sumEntries(LSBcut), 0., 1.e6)
entryLSB.setError(math.sqrt(entryLSB.getVal()))
entryHSB = RooRealVar("entryHSB", "Data HSB normalization", setDataSB.sumEntries(HSBcut), 0., 1.e6)
entryHSB.setError(math.sqrt(entryHSB.getVal()))
#*******************************************************#
# #
# NORMALIZATION #
# #
#*******************************************************#
# set reasonable ranges for J_mass and X_mass
# these are used in the fit in order to avoid ROOFIT to look in regions very far away from where we are fitting
J_mass.setRange("h_reasonable_range", LOWMIN, HIGMAX)
X_mass.setRange("X_reasonable_range", XBINMIN, XBINMAX)
# Set RooArgSets once for all, see https://root.cern.ch/phpBB3/viewtopic.php?t=11758
jetMassArg = RooArgSet(J_mass)
#*******************************************************#
# #
# V+jets normalization #
# #
#*******************************************************#
# Variables for V+jets
constVjet = RooRealVar("constVjet", "slope of the exp", -0.020, -1., 0.)
offsetVjet = RooRealVar("offsetVjet", "offset of the erf", 30., -50., 200.)
widthVjet = RooRealVar("widthVjet", "width of the erf", 100., 1., 200.)
offsetVjet.setConstant(True)
a0Vjet = RooRealVar("a0Vjet", "width of the erf", -0.1, -5, 0)
a1Vjet = RooRealVar("a1Vjet", "width of the erf", 0.6, 0, 5)
a2Vjet = RooRealVar("a2Vjet", "width of the erf", -0.1, -1, 1)
# Define V+jets model
if fitFuncVjet == "ERFEXP": modelVjet = RooErfExpPdf("modelVjet", "error function for V+jets mass", J_mass, constVjet, offsetVjet, widthVjet)
elif fitFuncVjet == "EXP": modelVjet = RooExponential("modelVjet", "exp for V+jets mass", J_mass, constVjet)
elif fitFuncVjet == "POL": modelVjet = RooChebychev("modelVjet", "polynomial for V+jets mass", J_mass, RooArgList(a0Vjet, a1Vjet, a2Vjet))
elif fitFuncVjet == "POW": modelVjet = RooGenericPdf("modelVjet", "powerlaw for X mass", "@0^@1", RooArgList(J_mass, a0Vjet))
else:
print " ERROR! Pdf", fitFuncVjet, "is not implemented for Vjets"
exit()
# fit to main bkg in MC (whole range)
frVjet = modelVjet.fitTo(setVjet, RooFit.SumW2Error(True), RooFit.Range("h_reasonable_range"), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.Save(1), RooFit.PrintLevel(1 if VERBOSE else -1))
# integrals and number of events
iSBVjet = modelVjet.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange,HSBrange"))
iLSBVjet = modelVjet.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange"))
iHSBVjet = modelVjet.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("HSBrange"))
iSRVjet = modelVjet.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("SRrange"))
iVRVjet = modelVjet.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("VRrange"))
# Do not remove the following lines, integrals are computed here
iALVjet = modelVjet.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg))
nSBVjet = iSBVjet.getVal()/iALVjet.getVal()*setVjet.sumEntries(SBcut)
nLSBVjet = iLSBVjet.getVal()/iALVjet.getVal()*setVjet.sumEntries(LSBcut)
nHSBVjet = iHSBVjet.getVal()/iALVjet.getVal()*setVjet.sumEntries(HSBcut)
nSRVjet = iSRVjet.getVal()/iALVjet.getVal()*setVjet.sumEntries(SRcut)
drawPlot("JetMass_Vjet", channel, J_mass, modelVjet, setVjet, binsJmass, frVjet)
if VERBOSE: print "********** Fit result [JET MASS Vjets] *"+"*"*40, "\n", frVjet.Print(), "\n", "*"*80
#*******************************************************#
# #
# VV, VH normalization #
# #
#*******************************************************#
# Variables for VV
# Error function and exponential to model the bulk
constVV = RooRealVar("constVV", "slope of the exp", -0.030, -0.1, 0.)
offsetVV = RooRealVar("offsetVV", "offset of the erf", 90., 1., 300.)
widthVV = RooRealVar("widthVV", "width of the erf", 50., 1., 100.)
erfrVV = RooErfExpPdf("baseVV", "error function for VV jet mass", J_mass, constVV, offsetVV, widthVV)
expoVV = RooExponential("baseVV", "error function for VV jet mass", J_mass, constVV)
# gaussian for the V mass peak
meanVV = RooRealVar("meanVV", "mean of the gaussian", 90., 60., 100.)
sigmaVV = RooRealVar("sigmaVV", "sigma of the gaussian", 10., 6., 30.)
fracVV = RooRealVar("fracVV", "fraction of gaussian wrt erfexp", 3.2e-1, 0., 1.)
gausVV = RooGaussian("gausVV", "gaus for VV jet mass", J_mass, meanVV, sigmaVV)
# gaussian for the H mass peak
meanVH = RooRealVar("meanVH", "mean of the gaussian", 125., 100., 150.)
sigmaVH = RooRealVar("sigmaVH", "sigma of the gaussian", 30., 5., 40.)
fracVH = RooRealVar("fracVH", "fraction of gaussian wrt erfexp", 1.5e-2, 0., 1.)
gausVH = RooGaussian("gausVH", "gaus for VH jet mass", J_mass, meanVH, sigmaVH)
# Define VV model
if fitFuncVV == "ERFEXPGAUS": modelVV = RooAddPdf("modelVV", "error function + gaus for VV jet mass", RooArgList(gausVV, erfrVV), RooArgList(fracVV))
elif fitFuncVV == "ERFEXPGAUS2": modelVV = RooAddPdf("modelVV", "error function + gaus + gaus for VV jet mass", RooArgList(gausVH, gausVV, erfrVV), RooArgList(fracVH, fracVV))
elif fitFuncVV == "EXPGAUS": modelVV = RooAddPdf("modelVV", "error function + gaus for VV jet mass", RooArgList(gausVV, expoVV), RooArgList(fracVV))
elif fitFuncVV == "EXPGAUS2": modelVV = RooAddPdf("modelVV", "error function + gaus + gaus for VV jet mass", RooArgList(gausVH, gausVV, expoVV), RooArgList(fracVH, fracVV))
else:
print " ERROR! Pdf", fitFuncVV, "is not implemented for VV"
exit()
# fit to secondary bkg in MC (whole range)
frVV = modelVV.fitTo(setVV, RooFit.SumW2Error(True), RooFit.Range("h_reasonable_range"), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.Save(1), RooFit.PrintLevel(1 if VERBOSE else -1))
# integrals and number of events
iSBVV = modelVV.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange,HSBrange"))
iLSBVV = modelVV.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange"))
iHSBVV = modelVV.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("HSBrange"))
iSRVV = modelVV.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("SRrange"))
iVRVV = modelVV.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("VRrange"))
# Do not remove the following lines, integrals are computed here
iALVV = modelVV.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg))
nSBVV = iSBVV.getVal()/iALVV.getVal()*setVV.sumEntries(SBcut)
nLSBVV = iLSBVV.getVal()/iALVV.getVal()*setVV.sumEntries(LSBcut)
nHSBVV = iHSBVV.getVal()/iALVV.getVal()*setVV.sumEntries(HSBcut)
nSRVV = iSRVV.getVal()/iALVV.getVal()*setVV.sumEntries(SRcut)
rSBSRVV = nSRVV/nSBVV
drawPlot("JetMass_VV", channel, J_mass, modelVV, setVV, binsJmass, frVV)
if VERBOSE: print "********** Fit result [JET MASS VV] ****"+"*"*40, "\n", frVV.Print(), "\n", "*"*80
#*******************************************************#
# #
# Top, ST normalization #
# #
#*******************************************************#
# Variables for Top
# Error Function * Exponential to model the bulk
constTop = RooRealVar("constTop", "slope of the exp", -0.030, -1., 0.)
offsetTop = RooRealVar("offsetTop", "offset of the erf", 175.0, 50., 250.)
widthTop = RooRealVar("widthTop", "width of the erf", 100.0, 1., 300.)
gausTop = RooGaussian("baseTop", "gaus for Top jet mass", J_mass, offsetTop, widthTop)
erfrTop = RooErfExpPdf("baseTop", "error function for Top jet mass", J_mass, constTop, offsetTop, widthTop)
# gaussian for the W mass peak
meanW = RooRealVar("meanW", "mean of the gaussian", 80., 70., 90.)
sigmaW = RooRealVar("sigmaW", "sigma of the gaussian", 10., 2., 20.)
fracW = RooRealVar("fracW", "fraction of gaussian wrt erfexp", 0.1, 0., 1.)
gausW = RooGaussian("gausW", "gaus for W jet mass", J_mass, meanW, sigmaW)
# gaussian for the Top mass peak
meanT = RooRealVar("meanT", "mean of the gaussian", 175., 150., 200.)
sigmaT = RooRealVar("sigmaT", "sigma of the gaussian", 12., 5., 50.)
fracT = RooRealVar("fracT", "fraction of gaussian wrt erfexp", 0.1, 0., 1.)
gausT = RooGaussian("gausT", "gaus for T jet mass", J_mass, meanT, sigmaT)
# Define Top model
if fitFuncTop == "ERFEXPGAUS2": modelTop = RooAddPdf("modelTop", "error function + gaus + gaus for Top jet mass", RooArgList(gausW, gausT, erfrTop), RooArgList(fracW, fracT))
elif fitFuncTop == "ERFEXPGAUS": modelTop = RooAddPdf("modelTop", "error function + gaus for Top jet mass", RooArgList(gausT, erfrTop), RooArgList(fracT))
elif fitFuncTop == "GAUS3": modelTop = RooAddPdf("modelTop", "gaus + gaus + gaus for Top jet mass", RooArgList(gausW, gausT, gausTop), RooArgList(fracW, fracT))
elif fitFuncTop == "GAUS2": modelTop = RooAddPdf("modelTop", "gaus + gaus for Top jet mass", RooArgList(gausT, gausTop), RooArgList(fracT))
elif fitFuncTop == "GAUS": modelTop = RooGaussian("modelTop", "gaus for Top jet mass", J_mass, offsetTop, widthTop)
else:
print " ERROR! Pdf", fitFuncTop, "is not implemented for Top"
exit()
# fit to secondary bkg in MC (whole range)
frTop = modelTop.fitTo(setTop, RooFit.SumW2Error(True), RooFit.Range("h_reasonable_range"), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.Save(1), RooFit.PrintLevel(1 if VERBOSE else -1))
# integrals and number of events
iSBTop = modelTop.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange,HSBrange"))
iLSBTop = modelTop.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange"))
iHSBTop = modelTop.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("HSBrange"))
iSRTop = modelTop.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("SRrange"))
iVRTop = modelTop.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("VRrange"))
# Do not remove the following lines, integrals are computed here
iALTop = modelTop.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg))
nSBTop = iSBTop.getVal()/iALTop.getVal()*setTop.sumEntries(SBcut)
nLSBTop = iLSBTop.getVal()/iALTop.getVal()*setTop.sumEntries(LSBcut)
nHSBTop = iHSBTop.getVal()/iALTop.getVal()*setTop.sumEntries(HSBcut)
nSRTop = iSRTop.getVal()/iALTop.getVal()*setTop.sumEntries(SRcut)
drawPlot("JetMass_Top", channel, J_mass, modelTop, setTop, binsJmass, frTop)
if VERBOSE: print "********** Fit result [JET MASS TOP] ***"+"*"*40, "\n", frTop.Print(), "\n", "*"*80
#*******************************************************#
# #
# All bkg normalization #
# #
#*******************************************************#
constVjet.setConstant(True)
offsetVjet.setConstant(True)
widthVjet.setConstant(True)
a0Vjet.setConstant(True)
a1Vjet.setConstant(True)
a2Vjet.setConstant(True)
constVV.setConstant(True)
offsetVV.setConstant(True)
widthVV.setConstant(True)
meanVV.setConstant(True)
sigmaVV.setConstant(True)
fracVV.setConstant(True)
meanVH.setConstant(True)
sigmaVH.setConstant(True)
fracVH.setConstant(True)
constTop.setConstant(True)
offsetTop.setConstant(True)
widthTop.setConstant(True)
meanW.setConstant(True)
sigmaW.setConstant(True)
fracW.setConstant(True)
meanT.setConstant(True)
sigmaT.setConstant(True)
fracT.setConstant(True)
# Final background model by adding the main+secondary pdfs (using 'coef': ratio of the secondary/main, from MC)
model = RooAddPdf("model", "model", RooArgList(modelTop, modelVV, modelVjet), RooArgList(coef_Top_VVVjet, coef_VV_Vjet))#FIXME
model.fixAddCoefRange("h_reasonable_range")
# Extended fit model to data in SB
# all the 3 sidebands (Low / High / the 2 combined) could be used
# currently using the LOW+HIGH (the others are commented out)
yieldLSB = RooRealVar("yieldLSB", "Lower SB normalization", 10, 0., 1.e6)
yieldHSB = RooRealVar("yieldHSB", "Higher SB normalization", 10, 0., 1.e6)
yieldSB = RooRealVar("yieldSB", "All SB normalization", 10, 0., 1.e6)
#model_ext = RooExtendPdf("model_ext", "extended p.d.f", model, yieldLSB)
#model_ext = RooExtendPdf("model_ext", "extended p.d.f", model, yieldHSB)
model_ext = RooExtendPdf("model_ext", "extended p.d.f", model, yieldSB)
#frMass = model_ext.fitTo(setDataSB, RooFit.ConditionalObservables(RooArgSet(J_mass)),RooFit.SumW2Error(True),RooFit.Extended(True),RooFit.Range("LSBrange"),RooFit.PrintLevel(-1))
#frMass = model_ext.fitTo(setDataSB, RooFit.ConditionalObservables(RooArgSet(J_mass)),RooFit.SumW2Error(True),RooFit.Extended(True),RooFit.Range("HSBrange"),RooFit.PrintLevel(-1))
#frMass = model_ext.fitTo(setDataSB, RooFit.ConditionalObservables(RooArgSet(J_mass)), RooFit.SumW2Error(True), RooFit.Extended(True), RooFit.Range("LSBrange,HSBrange"), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.PrintLevel(1 if VERBOSE else -1))
#print "********** Fit result [JET MASS DATA] **"+"*"*40
#print frMass.Print()
#print "*"*80
# Calculate integral of the model obtained from the fit to data (fraction of PDF that is within a given region)
#nSB = model_ext.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange,HSBrange"))
#nSB = model_ext.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange"))
#nSB = model_ext.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("HSBrange"))
#nSR = model_ext.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("SRrange"))
#nVR = model_ext.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("VRrange"))
# scale the yieldSB from SB to SR using the ratio of the PDFs defined by the two integrals
SRyield = RooFormulaVar("SRyield", "extrapolation to SR","(@0-@1*@3-@2*@4) * @5/@6 +@1*@7+@2*@8", RooArgList(entrySB, entryVV, entryTop, iSBVV, iSBTop, iSRVjet, iSBVjet, iSRVV, iSRTop))
VRyield = RooFormulaVar("VRyield", "extrapolation to VR","(@0-@1*@3-@2*@4) * @5/@6 +@1*@7+@2*@8", RooArgList(entrySB, entryVV, entryTop, iSBVV, iSBTop, iVRVjet, iSBVjet, iVRVV, iVRTop))
HSByield = RooFormulaVar("SRyield", "extrapolation to SR","(@0-@1*@3-@2*@4) * @5/@6 +@1*@7+@2*@8", RooArgList(entryLSB, entryVV, entryTop, iLSBVV, iLSBTop, iHSBVjet, iLSBVjet, iHSBVV, iHSBTop))
# RooFormulaVar SRyield("SRyield","extrapolation to SR","(@0/@1)*@2",RooArgList(*nSR,*nSB,yieldLowerSB))
# RooFormulaVar SRyield("SRyield","extrapolation to SR","(@0/@1)*@2",RooArgList(*nSR,*nSB,yieldHigherSB))
#SRyield = RooFormulaVar("SRyield", "extrapolation to SR","(@0/@1)*@2", RooArgList(nSR, nSB, entrySB))
bkgYield = SRyield.getVal()
bkgYield_error = math.sqrt(SRyield.getPropagatedError(frVjet)**2 + SRyield.getPropagatedError(frVV)**2 + SRyield.getPropagatedError(frTop)**2 + (entrySB.getError()*rSBSRVV)**2)
bkgNorm = entrySB.getVal() + SRyield.getVal() + VRyield.getVal()
bkgYield_eig_norm = RooRealVar("predSR_eig_norm", "expected yield in SR", bkgYield, 0., 1.e6)
bkgYieldExt = HSByield.getVal()
drawPlot("JetMass", channel, J_mass, model, setDataSB, binsJmass, None, None, "", bkgNorm, True)
print channel, "normalization = %.3f +/- %.3f, observed = %.0f" % (bkgYield, bkgYield_error, setDataSR.sumEntries() if not BLIND else -1)
if VERBOSE: raw_input("Press Enter to continue...")
def dijet(category):
channel = 'bb'
stype = channel
isSB = True # relict from using Alberto's more complex script
isData = not ISMC
nTupleDir = NTUPLEDIR
samples = data if isData else back
pd = []
for sample_name in samples:
if YEAR == 'run2':
pd += sample[sample_name]['files']
else:
pd += [x for x in sample[sample_name]['files'] if YEAR in x]
print "datasets:", pd
if not os.path.exists(PLOTDIR): os.makedirs(PLOTDIR)
if BIAS: print "Running in BIAS mode"
order = 0
RSS = {}
X_mass = RooRealVar("jj_mass_widejet", "m_{jj}", X_min, X_max, "GeV")
weight = RooRealVar("MANtag_weight", "", -1.e9, 1.e9)
variables = RooArgSet(X_mass)
variables.add(RooArgSet(weight))
if VARBINS:
binsXmass = RooBinning(len(abins) - 1, abins)
X_mass.setBinning(RooBinning(len(abins_narrow) - 1, abins_narrow))
plot_binning = RooBinning(
int((X_mass.getMax() - X_mass.getMin()) / 100), X_mass.getMin(),
X_mass.getMax())
else:
X_mass.setBins(int((X_mass.getMax() - X_mass.getMin()) / 10))
binsXmass = RooBinning(int((X_mass.getMax() - X_mass.getMin()) / 100),
X_mass.getMin(), X_mass.getMax())
plot_binning = binsXmass
baseCut = ""
print stype, "|", baseCut
print " - Reading from Tree"
treeBkg = TChain("tree")
for ss in pd:
if os.path.exists(nTupleDir + ss + "_" + BTAGGING + ".root"):
treeBkg.Add(nTupleDir + ss + "_" + BTAGGING + ".root")
else:
print "found no file for sample:", ss
setData = RooDataSet("setData", "Data (QCD+TTbar MC)", variables,
RooFit.Cut(baseCut), RooFit.WeightVar(weight),
RooFit.Import(treeBkg))
nevents = setData.sumEntries()
dataMin, dataMax = array('d', [0.]), array('d', [0.])
setData.getRange(X_mass, dataMin, dataMax)
xmin, xmax = dataMin[0], dataMax[0]
lastBin = X_mass.getMax()
if VARBINS:
for b in narrow_bins:
if b > xmax:
lastBin = b
break
print "Imported", (
"data" if isData else "MC"
), "RooDataSet with", nevents, "events between [%.1f, %.1f]" % (xmin, xmax)
#xmax = xmax+binsXmass.averageBinWidth() # start form next bin
# 1 parameter
print "fitting 1 parameter model"
p1_1 = RooRealVar("CMS" + YEAR + "_" + category + "_p1_1", "p1", 7.0, 0.,
2000.)
modelBkg1 = RooGenericPdf("Bkg1", "Bkg. fit (2 par.)",
"1./pow(@0/13000, @1)", RooArgList(X_mass, p1_1))
normzBkg1 = RooRealVar(
modelBkg1.GetName() + "_norm", "Number of background events", nevents,
0., 5. * nevents) #range dependent of actual number of events!
modelExt1 = RooExtendPdf(modelBkg1.GetName() + "_ext",
modelBkg1.GetTitle(), modelBkg1, normzBkg1)
fitRes1 = modelExt1.fitTo(setData, RooFit.Extended(True), RooFit.Save(1),
RooFit.SumW2Error(not isData),
RooFit.Strategy(2), RooFit.Minimizer("Minuit2"),
RooFit.PrintLevel(1 if VERBOSE else -1))
fitRes1.Print()
RSS[1] = drawFit("Bkg1", category, X_mass, modelBkg1, setData, binsXmass,
[fitRes1], normzBkg1.getVal())
# 2 parameters
print "fitting 2 parameter model"
p2_1 = RooRealVar("CMS" + YEAR + "_" + category + "_p2_1", "p1", 0., -100.,
1000.)
p2_2 = RooRealVar("CMS" + YEAR + "_" + category + "_p2_2", "p2",
p1_1.getVal(), -100., 600.)
modelBkg2 = RooGenericPdf("Bkg2", "Bkg. fit (3 par.)",
"pow(1-@0/13000, @1) / pow(@0/13000, @2)",
RooArgList(X_mass, p2_1, p2_2))
normzBkg2 = RooRealVar(modelBkg2.GetName() + "_norm",
"Number of background events", nevents, 0.,
5. * nevents)
modelExt2 = RooExtendPdf(modelBkg2.GetName() + "_ext",
modelBkg2.GetTitle(), modelBkg2, normzBkg2)
fitRes2 = modelExt2.fitTo(setData, RooFit.Extended(True), RooFit.Save(1),
RooFit.SumW2Error(not isData),
RooFit.Strategy(2), RooFit.Minimizer("Minuit2"),
RooFit.PrintLevel(1 if VERBOSE else -1))
fitRes2.Print()
RSS[2] = drawFit("Bkg2", category, X_mass, modelBkg2, setData, binsXmass,
[fitRes2], normzBkg2.getVal())
# 3 parameters
print "fitting 3 parameter model"
p3_1 = RooRealVar("CMS" + YEAR + "_" + category + "_p3_1", "p1",
p2_1.getVal(), -2000., 2000.)
p3_2 = RooRealVar("CMS" + YEAR + "_" + category + "_p3_2", "p2",
p2_2.getVal(), -400., 2000.)
p3_3 = RooRealVar("CMS" + YEAR + "_" + category + "_p3_3", "p3", -2.5,
-500., 500.)
modelBkg3 = RooGenericPdf(
"Bkg3", "Bkg. fit (4 par.)",
"pow(1-@0/13000, @1) / pow(@0/13000, @2+@3*log(@0/13000))",
RooArgList(X_mass, p3_1, p3_2, p3_3))
normzBkg3 = RooRealVar(modelBkg3.GetName() + "_norm",
"Number of background events", nevents, 0.,
5. * nevents)
modelExt3 = RooExtendPdf(modelBkg3.GetName() + "_ext",
modelBkg3.GetTitle(), modelBkg3, normzBkg3)
fitRes3 = modelExt3.fitTo(setData, RooFit.Extended(True), RooFit.Save(1),
RooFit.SumW2Error(not isData),
RooFit.Strategy(2), RooFit.Minimizer("Minuit2"),
RooFit.PrintLevel(1 if VERBOSE else -1))
fitRes3.Print()
RSS[3] = drawFit("Bkg3", category, X_mass, modelBkg3, setData, binsXmass,
[fitRes3], normzBkg3.getVal())
# 4 parameters
print "fitting 4 parameter model"
p4_1 = RooRealVar("CMS" + YEAR + "_" + category + "_p4_1", "p1",
p3_1.getVal(), -2000., 2000.)
p4_2 = RooRealVar("CMS" + YEAR + "_" + category + "_p4_2", "p2",
p3_2.getVal(), -2000., 2000.)
p4_3 = RooRealVar("CMS" + YEAR + "_" + category + "_p4_3", "p3",
p3_3.getVal(), -50., 50.)
p4_4 = RooRealVar("CMS" + YEAR + "_" + category + "_p4_4", "p4", 0.1, -50.,
50.)
modelBkg4 = RooGenericPdf(
"Bkg4", "Bkg. fit (5 par.)",
"pow(1 - @0/13000, @1) / pow(@0/13000, @2+@3*log(@0/13000)+@4*pow(log(@0/13000), 2))",
RooArgList(X_mass, p4_1, p4_2, p4_3, p4_4))
normzBkg4 = RooRealVar(modelBkg4.GetName() + "_norm",
"Number of background events", nevents, 0.,
5. * nevents)
modelExt4 = RooExtendPdf(modelBkg4.GetName() + "_ext",
modelBkg4.GetTitle(), modelBkg4, normzBkg4)
fitRes4 = modelExt4.fitTo(setData, RooFit.Extended(True), RooFit.Save(1),
RooFit.SumW2Error(not isData),
RooFit.Strategy(2), RooFit.Minimizer("Minuit2"),
RooFit.PrintLevel(1 if VERBOSE else -1))
fitRes4.Print()
RSS[4] = drawFit("Bkg4", category, X_mass, modelBkg4, setData, binsXmass,
[fitRes4], normzBkg4.getVal())
# Normalization parameters are should be set constant, but shape ones should not
# if BIAS:
# p1_1.setConstant(True)
# p2_1.setConstant(True)
# p2_2.setConstant(True)
# p3_1.setConstant(True)
# p3_2.setConstant(True)
# p3_3.setConstant(True)
# p4_1.setConstant(True)
# p4_2.setConstant(True)
# p4_3.setConstant(True)
# p4_4.setConstant(True)
normzBkg1.setConstant(True)
normzBkg2.setConstant(True)
normzBkg3.setConstant(True)
normzBkg4.setConstant(True)
#*******************************************************#
# #
# Fisher #
# #
#*******************************************************#
# Fisher test
with open(PLOTDIR + "/Fisher_" + category + ".tex", 'w') as fout:
fout.write(r"\begin{tabular}{c|c|c|c|c}")
fout.write("\n")
fout.write(r"function & $\chi^2$ & RSS & ndof & F-test \\")
fout.write("\n")
fout.write("\hline")
fout.write("\n")
CL_high = False
for o1 in range(1, 5):
o2 = min(o1 + 1, 5)
fout.write("%d par & %.2f & %.2f & %d & " %
(o1 + 1, RSS[o1]["chi2"], RSS[o1]["rss"],
RSS[o1]["nbins"] - RSS[o1]["npar"]))
if o2 > len(RSS):
fout.write(r"\\")
fout.write("\n")
continue #order==0 and
CL = fisherTest(RSS[o1]['rss'], RSS[o2]['rss'], o1 + 1., o2 + 1.,
RSS[o1]["nbins"])
fout.write("CL=%.3f " % (CL))
if CL > 0.10: # The function with less parameters is enough
if not CL_high:
order = o1
#fout.write( "%d par are sufficient " % (o1+1))
CL_high = True
else:
#fout.write( "%d par are needed " % (o2+1))
if not CL_high:
order = o2
fout.write(r"\\")
fout.write("\n")
fout.write("\hline")
fout.write("\n")
fout.write(r"\end{tabular}")
print "saved F-test table as", PLOTDIR + "/Fisher_" + category + ".tex"
#print "-"*25
#print "function & $\\chi^2$ & RSS & ndof & F-test & result \\\\"
#print "\\multicolumn{6}{c}{", "Zprime_to_bb", "} \\\\"
#print "\\hline"
#CL_high = False
#for o1 in range(1, 5):
# o2 = min(o1 + 1, 5)
# print "%d par & %.2f & %.2f & %d & " % (o1+1, RSS[o1]["chi2"], RSS[o1]["rss"], RSS[o1]["nbins"]-RSS[o1]["npar"]),
# if o2 > len(RSS):
# print "\\\\"
# continue #order==0 and
# CL = fisherTest(RSS[o1]['rss'], RSS[o2]['rss'], o1+1., o2+1., RSS[o1]["nbins"])
# print "%d par vs %d par CL=%f & " % (o1+1, o2+1, CL),
# if CL > 0.10: # The function with less parameters is enough
# if not CL_high:
# order = o1
# print "%d par are sufficient" % (o1+1),
# CL_high=True
# else:
# print "%d par are needed" % (o2+1),
# if not CL_high:
# order = o2
# print "\\\\"
#print "\\hline"
#print "-"*25
#print "@ Order is", order, "("+category+")"
#order = min(3, order)
#order = 2
if order == 1:
modelBkg = modelBkg1 #.Clone("Bkg")
modelAlt = modelBkg2 #.Clone("BkgAlt")
normzBkg = normzBkg1 #.Clone("Bkg_norm")
fitRes = fitRes1
elif order == 2:
modelBkg = modelBkg2 #.Clone("Bkg")
modelAlt = modelBkg3 #.Clone("BkgAlt")
normzBkg = normzBkg2 #.Clone("Bkg_norm")
fitRes = fitRes2
elif order == 3:
modelBkg = modelBkg3 #.Clone("Bkg")
modelAlt = modelBkg4 #.Clone("BkgAlt")
normzBkg = normzBkg3 #.Clone("Bkg_norm")
fitRes = fitRes3
elif order == 4:
modelBkg = modelBkg4 #.Clone("Bkg")
modelAlt = modelBkg3 #.Clone("BkgAlt")
normzBkg = normzBkg4 #.Clone("Bkg_norm")
fitRes = fitRes4
else:
print "Functions with", order + 1, "or more parameters are needed to fit the background"
exit()
modelBkg.SetName("Bkg_" + YEAR + "_" + category)
modelAlt.SetName("Alt_" + YEAR + "_" + category)
normzBkg.SetName("Bkg_" + YEAR + "_" + category + "_norm")
print "-" * 25
# Generate pseudo data
setToys = RooDataSet()
setToys.SetName("data_toys")
setToys.SetTitle("Data (toys)")
if not isData:
print " - Generating", nevents, "events for toy data"
setToys = modelBkg.generate(RooArgSet(X_mass), nevents)
#setToys = modelAlt.generate(RooArgSet(X_mass), nevents)
print "toy data generated"
if VERBOSE: raw_input("Press Enter to continue...")
#*******************************************************#
# #
# Plot #
# #
#*******************************************************#
print "starting to plot"
c = TCanvas("c_" + category, category, 800, 800)
c.Divide(1, 2)
setTopPad(c.GetPad(1), RATIO)
setBotPad(c.GetPad(2), RATIO)
c.cd(1)
frame = X_mass.frame()
setPadStyle(frame, 1.25, True)
if VARBINS: frame.GetXaxis().SetRangeUser(X_mass.getMin(), lastBin)
signal = getSignal(
category, stype,
2000) #replacing Alberto's getSignal by own dummy function
graphData = setData.plotOn(frame, RooFit.Binning(plot_binning),
RooFit.Scaling(False), RooFit.Invisible())
modelBkg.plotOn(frame, RooFit.VisualizeError(fitRes, 1, False),
RooFit.LineColor(602), RooFit.FillColor(590),
RooFit.FillStyle(1001), RooFit.DrawOption("FL"),
RooFit.Name("1sigma"))
modelBkg.plotOn(frame, RooFit.LineColor(602), RooFit.FillColor(590),
RooFit.FillStyle(1001), RooFit.DrawOption("L"),
RooFit.Name(modelBkg.GetName()))
modelAlt.plotOn(frame, RooFit.LineStyle(7), RooFit.LineColor(613),
RooFit.FillColor(609), RooFit.FillStyle(1001),
RooFit.DrawOption("L"), RooFit.Name(modelAlt.GetName()))
if not isSB and signal[0] is not None: # FIXME remove /(2./3.)
signal[0].plotOn(
frame,
RooFit.Normalization(signal[1] * signal[2], RooAbsReal.NumEvent),
RooFit.LineStyle(3), RooFit.LineWidth(6), RooFit.LineColor(629),
RooFit.DrawOption("L"), RooFit.Name("Signal"))
graphData = setData.plotOn(
frame, RooFit.Binning(plot_binning), RooFit.Scaling(False),
RooFit.XErrorSize(0 if not VARBINS else 1),
RooFit.DataError(RooAbsData.Poisson if isData else RooAbsData.SumW2),
RooFit.DrawOption("PE0"), RooFit.Name(setData.GetName()))
fixData(graphData.getHist(), True, True, not isData)
pulls = frame.pullHist(setData.GetName(), modelBkg.GetName(), True)
chi = frame.chiSquare(setData.GetName(), modelBkg.GetName(), True)
#setToys.plotOn(frame, RooFit.DataError(RooAbsData.Poisson), RooFit.DrawOption("PE0"), RooFit.MarkerColor(2))
frame.GetYaxis().SetTitle("Events / ( 100 GeV )")
frame.GetYaxis().SetTitleOffset(1.05)
frame.Draw()
#print "frame drawn"
# Get Chi2
# chi2[1] = frame.chiSquare(modelBkg1.GetName(), setData.GetName())
# chi2[2] = frame.chiSquare(modelBkg2.GetName(), setData.GetName())
# chi2[3] = frame.chiSquare(modelBkg3.GetName(), setData.GetName())
# chi2[4] = frame.chiSquare(modelBkg4.GetName(), setData.GetName())
frame.SetMaximum(frame.GetMaximum() * 10)
frame.SetMinimum(max(frame.GetMinimum(), 1.e-1))
c.GetPad(1).SetLogy()
drawAnalysis(category)
drawRegion(category, True)
#drawCMS(LUMI, "Simulation Preliminary")
drawCMS(LUMI, "Work in Progress", suppressCMS=True)
leg = TLegend(0.575, 0.6, 0.95, 0.9)
leg.SetBorderSize(0)
leg.SetFillStyle(0) #1001
leg.SetFillColor(0)
leg.AddEntry(setData.GetName(),
setData.GetTitle() + " (%d events)" % nevents, "PEL")
leg.AddEntry(modelBkg.GetName(), modelBkg.GetTitle(),
"FL") #.SetTextColor(629)
leg.AddEntry(modelAlt.GetName(), modelAlt.GetTitle(), "L")
if not isSB and signal[0] is not None:
leg.AddEntry("Signal", signal[0].GetTitle(), "L")
leg.SetY1(0.9 - leg.GetNRows() * 0.05)
leg.Draw()
latex = TLatex()
latex.SetNDC()
latex.SetTextSize(0.04)
latex.SetTextFont(42)
if not isSB:
latex.DrawLatex(leg.GetX1() * 1.16,
leg.GetY1() - 0.04, "HVT model B (g_{V}=3)")
# latex.DrawLatex(0.67, leg.GetY1()-0.045, "#sigma_{X} = 1.0 pb")
c.cd(2)
frame_res = X_mass.frame()
setPadStyle(frame_res, 1.25)
frame_res.addPlotable(pulls, "P")
setBotStyle(frame_res, RATIO, False)
if VARBINS: frame_res.GetXaxis().SetRangeUser(X_mass.getMin(), lastBin)
frame_res.GetYaxis().SetRangeUser(-5, 5)
frame_res.GetYaxis().SetTitle("pulls(#sigma)")
frame_res.GetYaxis().SetTitleOffset(0.3)
frame_res.Draw()
fixData(pulls, False, True, False)
drawChi2(RSS[order]["chi2"], RSS[order]["nbins"] - (order + 1), True)
line = drawLine(X_mass.getMin(), 0, lastBin, 0)
if VARBINS:
c.SaveAs(PLOTDIR + "/BkgSR_" + category + ".pdf")
c.SaveAs(PLOTDIR + "/BkgSR_" + category + ".png")
else:
c.SaveAs(PLOTDIR + "/BkgSR_" + category + ".pdf")
c.SaveAs(PLOTDIR + "/BkgSR_" + category + ".png")
#*******************************************************#
# #
# Generate workspace #
# #
#*******************************************************#
if BIAS:
gSystem.Load("libHiggsAnalysisCombinedLimit.so")
from ROOT import RooMultiPdf
cat = RooCategory("pdf_index", "Index of Pdf which is active")
pdfs = RooArgList(modelBkg, modelAlt)
roomultipdf = RooMultiPdf("roomultipdf", "All Pdfs", cat, pdfs)
normulti = RooRealVar("roomultipdf_norm",
"Number of background events", nevents, 0., 1.e6)
normzBkg.setConstant(
False
) ## newly put here to ensure it's freely floating in the combine fit
# create workspace
w = RooWorkspace("Zprime_" + YEAR, "workspace")
# Dataset
if isData: getattr(w, "import")(setData, RooFit.Rename("data_obs"))
else: getattr(w, "import")(setToys, RooFit.Rename("data_obs"))
#getattr(w, "import")(setData, RooFit.Rename("data_obs"))
if BIAS:
getattr(w, "import")(cat, RooFit.Rename(cat.GetName()))
getattr(w, "import")(normulti, RooFit.Rename(normulti.GetName()))
getattr(w, "import")(roomultipdf, RooFit.Rename(roomultipdf.GetName()))
getattr(w, "import")(modelBkg, RooFit.Rename(modelBkg.GetName()))
getattr(w, "import")(modelAlt, RooFit.Rename(modelAlt.GetName()))
getattr(w, "import")(normzBkg, RooFit.Rename(normzBkg.GetName()))
w.writeToFile(WORKDIR + "%s_%s.root" % (DATA_TYPE + "_" + YEAR, category),
True)
print "Workspace", WORKDIR + "%s_%s.root" % (
DATA_TYPE + "_" + YEAR, category), "saved successfully"
if VERBOSE: raw_input("Press Enter to continue...")
def FitMassPoint(filename, massin, massmin, massmax, rwCPS=1, nbins=50):
### take the input tree from the file
inputFile = ROOT.TFile(filename);
tree = inputFile.Get("WJet");
print "Lineshape Higgs mass --> n entries: ", tree.GetEntries();
# RooFitting
rrv_mass = RooRealVar("rrv_mass","rrv_mass",massin,massmin,massmax);
rrv_weight = RooRealVar("rrv_weight","rrv_weight",0. ,10000000.);
rrv_mH1 = RooRealVar("rrv_mH1","rrv_mH1", massin, massmin, massmax );
rrv_gamma1 = RooRealVar("rrv_gamma1","rrv_gamma1",20.,0.,massmax);
rrv_mH2 = RooRealVar("rrv_mH2","rrv_mH2", massin, massmin, massmax )
rrv_gamma2 = RooRealVar("rrv_gamma2","rrv_gamma2",20.,0.,massmax)
rrv_mH3 = RooRealVar("rrv_mH3","rrv_mH3", massin, massmin, massmax );
rrv_gamma3 = RooRealVar("rrv_gamma3","rrv_gamma3",20.,0.,massmax);
rds_raw = RooDataSet("rds_raw","rds_raw",RooArgSet(rrv_mass,rrv_weight),RooFit.WeightVar(rrv_weight)); ## created the raw dataset --> raw lineshape
rds_cps = RooDataSet("rds_cps","rds_cps",RooArgSet(rrv_mass,rrv_weight),RooFit.WeightVar(rrv_weight)); ## create the cps dataset --> cps lineshape
rds_cps_intf = ROOT.RooDataSet("rds_cps_intf","rds_cps_intf",RooArgSet(rrv_mass,rrv_weight),RooFit.WeightVar(rrv_weight)); ## create the cps + interference dataset
model1_pdf = ROOT.RooRelBWRunningWidth("model1_pdf","model1_pdf",rrv_mass,rrv_mH1,rrv_gamma1); ## BWRunningWidth Pdf from the dedicated library
model2_pdf = ROOT.RooRelBWRunningWidth("model2_pdf","model2_pdf",rrv_mass,rrv_mH2,rrv_gamma2); ## BWRunningWidth Pdf from the dedicated library
model3_pdf = ROOT.RooRelBWRunningWidth("model3_pdf","model3_pdf",rrv_mass,rrv_mH3,rrv_gamma3); ## BWRunningWidth Pdf from the dedicated library
### loop on Higgs signal events
for i in range(tree.GetEntries()):
if i % 10000 == 0: print "reweighter, i: ", i;
tree.GetEntry(i);
curmass = getattr(tree,"W_H_mass_gen"); ## take the higgs generated mass inside the window; point not in the window are neglected
if curmass < massmax and curmass > massmin:
rrv_mass.setVal( curmass ); ## set the value of the RooRealVar
tmpweight_cps = getattr(tree,"complexpolewtggH"+str(massin))*rwCPS/getattr(tree,"avecomplexpolewtggH"+str(massin)); ## take the cps weight from the tree
tmpweight_cps_intf = getattr(tree,"complexpolewtggH"+str(massin))*rwCPS*getattr(tree,"interferencewtggH"+str(massin))/getattr(tree,"avecomplexpolewtggH"+str(massin)); ## cps*int
rds_raw.add( RooArgSet( rrv_mass ), 1. );
rds_cps.add( RooArgSet( rrv_mass ), tmpweight_cps );
rds_cps_intf.add( RooArgSet( rrv_mass ), tmpweight_cps_intf );
print ">>>>"
RooTrace.dump(ROOT.cout,ROOT.kTRUE);
RooTrace.mark();
print "<<<<"
#### final fit
model1_pdf.fitTo(rds_raw,RooFit.Save(1), RooFit.SumW2Error(kTRUE));
model1_pdf.fitTo(rds_raw,RooFit.Save(1), RooFit.SumW2Error(kTRUE), RooFit.Minimizer("Minuit2"));
model2_pdf.fitTo(rds_cps,RooFit.Save(1), RooFit.SumW2Error(kTRUE));
model2_pdf.fitTo(rds_cps,RooFit.Save(1), RooFit.SumW2Error(kTRUE), RooFit.Minimizer("Minuit2"));
model3_pdf.fitTo(rds_cps_intf,RooFit.Save(1), RooFit.SumW2Error(kTRUE));
model3_pdf.fitTo(rds_cps_intf,RooFit.Save(1), RooFit.SumW2Error(kTRUE), RooFit.Minimizer("Minuit2"));
## plot of the fits
mplot = rrv_mass.frame(RooFit.Title("mass plot"));
rds_raw.plotOn(mplot, RooFit.MarkerColor(kBlack), RooFit.LineColor(kBlack), RooFit.Binning(nbins,massmin,massmax), RooFit.DataError(RooAbsData.SumW2) );
rds_cps.plotOn(mplot, RooFit.MarkerColor(kRed), RooFit.LineColor(kRed), RooFit.Binning(nbins,massmin,massmax), RooFit.DataError(RooAbsData.SumW2) );
rds_cps_intf.plotOn(mplot, RooFit.MarkerColor(kBlue), RooFit.LineColor(kBlue), RooFit.Binning(nbins,massmin,massmax), RooFit.DataError(RooAbsData.SumW2) );
model1_pdf.plotOn(mplot, RooFit.LineColor(kBlack));
model2_pdf.plotOn(mplot, RooFit.LineColor(kRed), RooFit.LineStyle(2) );
model3_pdf.plotOn(mplot, RooFit.LineColor(kBlue), RooFit.LineStyle(3) );
rds_raw.plotOn(mplot, RooFit.MarkerColor(kBlack), RooFit.LineColor(kBlack), RooFit.Binning(nbins,massmin,massmax), RooFit.DataError(RooAbsData.SumW2) );
rds_cps.plotOn(mplot, RooFit.MarkerColor(kRed), RooFit.LineColor(kRed), RooFit.Binning(nbins,massmin,massmax), RooFit.DataError(RooAbsData.SumW2) );
rds_cps_intf.plotOn(mplot, RooFit.MarkerColor(kBlue), RooFit.LineColor(kBlue), RooFit.Binning(nbins,massmin,massmax), RooFit.DataError(RooAbsData.SumW2) );
print "rds_raw.sumEntries() = ", rds_raw.sumEntries()
print "model1_pdf: mH = ", rrv_mH1.getVal(), ", gamma = ", rrv_gamma1.getVal();
print "rds_cps.sumEntries() = ", rds_cps.sumEntries()
print "model2_pdf: mH = ", rrv_mH2.getVal(), ", gamma = ", rrv_gamma2.getVal();
print "rds_cps_intf.sumEntries() = ", rds_cps_intf.sumEntries()
print "model3_pdf: mH = ", rrv_mH3.getVal(), ", gamma = ", rrv_gamma3.getVal();
dummy_h1 = ROOT.TH1F("dummy_h1","dummy_h1",1,0,1);
dummy_h1.SetMarkerColor( ROOT.kBlack );
dummy_h2 = ROOT.TH1F("dummy_h2","dummy_h2",1,0,1);
dummy_h2.SetMarkerColor( ROOT.kRed );
dummy_h3 = ROOT.TH1F("dummy_h3","dummy_h3",1,0,1);
dummy_h3.SetMarkerColor( ROOT.kBlue );
L = TLegend(0.65,0.60,0.93,0.85);
L.SetFillStyle(0);
L.AddEntry(dummy_h1,"Powheg","p");
L.AddEntry(dummy_h2,"w/CPS weight","p");
L.AddEntry(dummy_h3,"w/CPS,Intf weight","p");
can2 = ROOT.TCanvas("can2","can2",800,800);
mplot.Draw();
L.Draw();
os.system("mkdir -p massFits");
can2.SaveAs("massFits/mass_rf_"+str(massin)+".pdf");
can2.SaveAs("massFits/mass_rf_"+str(massin)+".png");
outputpar_1 = [];
outputpar_1.append( rrv_mH1.getVal() );
outputpar_1.append( rrv_gamma1.getVal() );
outputpar_2 = [];
outputpar_2.append( rrv_mH2.getVal() );
outputpar_2.append( rrv_gamma2.getVal() );
outputpar_3 = [];
outputpar_3.append( rrv_mH3.getVal() );
outputpar_3.append( rrv_gamma3.getVal() );
model1_pdf.Delete();
model2_pdf.Delete();
model3_pdf.Delete();
rds_raw.Delete(),
rds_cps.Delete(),
rds_cps_intf.Delete();
rrv_mH1.Delete(),
rrv_gamma1.Delete();
rrv_mH2.Delete(),
rrv_gamma2.Delete();
rrv_mH3.Delete(),
rrv_gamma3.Delete();
rrv_mass.Delete();
return outputpar_2
data4_SB = RooDataSet("data4_SB", "data4 SB", RooArgSet(x), RooFit.Import( data4 ), RooFit.Cut("x<-2||x>4") )
# set range
x.setRange("signal_region",-2 ,4 )
x.setRange("left_side_band_region",-10 ,-2 )
x.setRange("right_side_band_region",4 ,10 )
# use gauss 13 to generate toy MC and cut right SB
data_gauss13 = gauss13.generate(RooArgSet(x), n_generate*(1-frac_combine4.getVal() ) )
#data_gauss13.plotOn(xframe8,RooFit.LineColor(RooFit.kGreen))
data_gauss13_right_SB = RooDataSet("data_gauss13_right_SB", "data_gauss13_right_SB", RooArgSet(x), RooFit.Import( data_gauss13 ), RooFit.Cut("x>4") )
#data_gauss13_right_SB.plotOn(xframe8,RooFit.LineColor(RooFit.kGreen))
nDataGauss_right_SB = data_gauss13_right_SB.sumEntries()
print ""
print "nDataGauss_right_SB: ", nDataGauss_right_SB
print ""
# combined ext PDF
# gauss 14
mean14 = RooRealVar("mean14","mean of gaussian",-1.5,-10,10)
sigma14 = RooRealVar("sigma14","width of gaussian",1.5,0.1,10)
gauss14 = RooGaussian("gauss14","gaussian PDF",x,mean14,sigma14)
# gauss 15
mean15 = RooRealVar("mean15","mean of gaussian",4,-10,10)
sigma15 = RooRealVar("sigma15","width of gaussian",1.3,0.1,10)
def alpha(channel):
nElec = channel.count('e')
nMuon = channel.count('m')
nLept = nElec + nMuon
nBtag = channel.count('b')
# Channel-dependent settings
# Background function. Semi-working options are: EXP, EXP2, EXPN, EXPTAIL
if nLept == 0:
treeName = 'SR'
signName = 'XZh'
colorVjet = sample['DYJetsToNuNu']['linecolor']
triName = "HLT_PFMET"
leptCut = "0==0"
topVeto = selection["TopVetocut"]
massVar = "X_cmass"
binFact = 1
#fitFunc = "EXP"
#fitFunc = "EXP2"
#fitFunc = "EXPN"
#fitFunc = "EXPTAIL"
fitFunc = "EXPN" if nBtag < 2 else "EXP"
fitAltFunc = "EXPTAIL" if nBtag < 2 else "EXPTAIL"
fitFuncVjet = "ERFEXP" if nBtag < 2 else "ERFEXP"
fitFuncVV = "EXPGAUS"
fitFuncTop = "GAUS2"
elif nLept == 1:
treeName = 'WCR'
signName = 'XWh'
colorVjet = sample['WJetsToLNu']['linecolor']
triName = "HLT_Ele" if nElec > 0 else "HLT_Mu"
leptCut = "isWtoEN" if nElec > 0 else "isWtoMN"
topVeto = selection["TopVetocut"]
massVar = "X_mass"
binFact = 2
if nElec > 0:
fitFunc = "EXP" if nBtag < 2 else "EXP"
fitAltFunc = "EXPTAIL" if nBtag < 2 else "EXPTAIL"
else:
fitFunc = "EXPTAIL" if nBtag < 2 else "EXP"
fitAltFunc = "EXPN" if nBtag < 2 else "EXPTAIL"
fitFuncVjet = "ERFEXP" if nBtag < 2 else "ERFEXP"
fitFuncVV = "EXPGAUS"
fitFuncTop = "GAUS3" if nBtag < 2 else "GAUS2"
else:
treeName = 'XZh'
signName = 'XZh'
colorVjet = sample['DYJetsToLL']['linecolor']
triName = "HLT_Ele" if nElec > 0 else "HLT_Mu"
leptCut = "isZtoEE" if nElec > 0 else "isZtoMM"
topVeto = "0==0"
massVar = "X_mass"
binFact = 5
if nElec > 0:
fitFunc = "EXP" if nBtag < 2 else "EXP"
fitAltFunc = "POW" if nBtag < 2 else "POW"
else:
fitFunc = "EXP" if nBtag < 2 else "EXP"
fitAltFunc = "POW" if nBtag < 2 else "POW"
fitFuncVjet = "ERFEXP" if nBtag < 2 else "EXP"
fitFuncVV = "EXPGAUS2"
fitFuncTop = "GAUS"
btagCut = selection["2Btag"] if nBtag == 2 else selection["1Btag"]
print "--- Channel", channel, "---"
print " number of electrons:", nElec, " muons:", nMuon, " b-tags:", nBtag
print " read tree:", treeName, "and trigger:", triName
if ALTERNATIVE: print " using ALTERNATIVE fit functions"
print "-"*11*2
# Silent RooFit
RooMsgService.instance().setGlobalKillBelow(RooFit.FATAL)
#*******************************************************#
# #
# Variables and selections #
# #
#*******************************************************#
# Define all the variables from the trees that will be used in the cuts and fits
# this steps actually perform a "projection" of the entire tree on the variables in thei ranges, so be careful once setting the limits
X_mass = RooRealVar( massVar, "m_{X}" if nLept > 0 else "m_{T}^{X}", XBINMIN, XBINMAX, "GeV")
J_mass = RooRealVar( "fatjet1_prunedMassCorr", "corrected pruned mass", HBINMIN, HBINMAX, "GeV")
CSV1 = RooRealVar( "fatjet1_CSVR1", "", -1.e99, 1.e4 )
CSV2 = RooRealVar( "fatjet1_CSVR2", "", -1.e99, 1.e4 )
nBtag = RooRealVar( "fatjet1_nBtag", "", 0., 4 )
CSVTop = RooRealVar( "bjet1_CSVR", "", -1.e99, 1.e4 )
isZtoEE = RooRealVar("isZtoEE", "", 0., 2 )
isZtoMM = RooRealVar("isZtoMM", "", 0., 2 )
isWtoEN = RooRealVar("isWtoEN", "", 0., 2 )
isWtoMN = RooRealVar("isWtoMN", "", 0., 2 )
weight = RooRealVar( "eventWeightLumi", "", -1.e9, 1. )
# Define the RooArgSet which will include all the variables defined before
# there is a maximum of 9 variables in the declaration, so the others need to be added with 'add'
variables = RooArgSet(X_mass, J_mass, CSV1, CSV2, nBtag, CSVTop)
variables.add(RooArgSet(isZtoEE, isZtoMM, isWtoEN, isWtoMN, weight))
# Define the ranges in fatJetMass - these will be used to define SB and SR
J_mass.setRange("LSBrange", LOWMIN, LOWMAX)
J_mass.setRange("HSBrange", HIGMIN, HIGMAX)
J_mass.setRange("VRrange", LOWMAX, SIGMIN)
J_mass.setRange("SRrange", SIGMIN, SIGMAX)
J_mass.setBins(54)
# Define the selection for the various categories (base + SR / LSBcut / HSBcut )
baseCut = leptCut + " && " + btagCut + "&&" + topVeto
massCut = massVar + ">%d" % XBINMIN
baseCut += " && " + massCut
# Cuts
SRcut = baseCut + " && %s>%d && %s<%d" % (J_mass.GetName(), SIGMIN, J_mass.GetName(), SIGMAX)
LSBcut = baseCut + " && %s>%d && %s<%d" % (J_mass.GetName(), LOWMIN, J_mass.GetName(), LOWMAX)
HSBcut = baseCut + " && %s>%d && %s<%d" % (J_mass.GetName(), HIGMIN, J_mass.GetName(), HIGMAX)
SBcut = baseCut + " && ((%s>%d && %s<%d) || (%s>%d && %s<%d))" % (J_mass.GetName(), LOWMIN, J_mass.GetName(), LOWMAX, J_mass.GetName(), HIGMIN, J_mass.GetName(), HIGMAX)
VRcut = baseCut + " && %s>%d && %s<%d" % (J_mass.GetName(), LOWMAX, J_mass.GetName(), SIGMIN)
# Binning
binsJmass = RooBinning(HBINMIN, HBINMAX)
binsJmass.addUniform(HBINS, HBINMIN, HBINMAX)
binsXmass = RooBinning(XBINMIN, XBINMAX)
binsXmass.addUniform(binFact*XBINS, XBINMIN, XBINMAX)
#*******************************************************#
# #
# Input files #
# #
#*******************************************************#
# Import the files using TChains (separately for the bkg "classes" that we want to describe: here DY and VV+ST+TT)
treeData = TChain(treeName)
treeMC = TChain(treeName)
treeVjet = TChain(treeName)
treeVV = TChain(treeName)
treeTop = TChain(treeName)
# treeSign = {}
# nevtSign = {}
# Read data
print "read data start"
pd = getPrimaryDataset(triName)
if len(pd)==0: raw_input("Warning: Primary Dataset not recognized, continue?")
for i, s in enumerate(pd): treeData.Add(NTUPLEDIR + s + ".root")
# Read V+jets backgrounds
print "read V+jet start"
for i, s in enumerate(["WJetsToLNu_HT", "DYJetsToNuNu_HT", "DYJetsToLL_HT"]):
for j, ss in enumerate(sample[s]['files']): treeVjet.Add(NTUPLEDIR + ss + ".root")
# Read VV backgrounds
print "read VV start"
for i, s in enumerate(["VV"]):
for j, ss in enumerate(sample[s]['files']): treeVV.Add(NTUPLEDIR + ss + ".root")
# Read Top backgrounds
print "read Top start"
for i, s in enumerate(["ST", "TTbar"]):
for j, ss in enumerate(sample[s]['files']): treeTop.Add(NTUPLEDIR + ss + ".root")
# Sum all background MC
treeMC.Add(treeVjet)
treeMC.Add(treeVV)
treeMC.Add(treeTop)
# print "prepare SB dataset"
# create a dataset to host data in sideband (using this dataset we are automatically blind in the SR!)
# setDataSB = RooDataSet("setDataSB", "setDataSB", variables, RooFit.Cut(SBcut), RooFit.WeightVar(weight), RooFit.Import(treeData))
# setDataLSB = RooDataSet("setDataLSB", "setDataLSB", variables, RooFit.Import(setDataSB), RooFit.Cut(LSBcut), RooFit.WeightVar(weight))
# setDataHSB = RooDataSet("setDataHSB", "setDataHSB", variables, RooFit.Import(setDataSB), RooFit.Cut(HSBcut), RooFit.WeightVar(weight))
# print "prepare SR dataset"
# Observed data (WARNING, BLIND!)
# setDataSR = RooDataSet("setDataSR", "setDataSR", variables, RooFit.Cut(SRcut), RooFit.WeightVar(weight), RooFit.Import(treeData))
# setDataVR = RooDataSet("setDataVR", "setDataVR", variables, RooFit.Cut(VRcut), RooFit.WeightVar(weight), RooFit.Import(treeData)) # Observed in the VV mass, just for plotting purposes
print "prepare MC dataset"
# same for the bkg datasets from MC, where we just apply the base selections (not blind)
setVjet = RooDataSet("setVjet", "setVjet", variables, RooFit.Cut(baseCut), RooFit.WeightVar(weight), RooFit.Import(treeVjet))
setVjetSB = RooDataSet("setVjetSB", "setVjetSB", variables, RooFit.Import(setVjet), RooFit.Cut(SBcut), RooFit.WeightVar(weight))
setVjetSR = RooDataSet("setVjetSR", "setVjetSR", variables, RooFit.Import(setVjet), RooFit.Cut(SRcut), RooFit.WeightVar(weight))
print "finish Vjet dataset"
# setVV = RooDataSet("setVV", "setVV", variables, RooFit.Cut(baseCut), RooFit.WeightVar(weight), RooFit.Import(treeVV))
# setVVSB = RooDataSet("setVVSB", "setVVSB", variables, RooFit.Import(setVV), RooFit.Cut(SBcut), RooFit.WeightVar(weight))
# setVVSR = RooDataSet("setVVSR", "setVVSR", variables, RooFit.Import(setVV), RooFit.Cut(SRcut), RooFit.WeightVar(weight))
# print "finish VV dataset"
# setTop = RooDataSet("setTop", "setTop", variables, RooFit.Cut(baseCut), RooFit.WeightVar(weight), RooFit.Import(treeTop))
# setTopSB = RooDataSet("setTopSB", "setTopSB", variables, RooFit.Import(setTop), RooFit.Cut(SBcut), RooFit.WeightVar(weight))
# setTopSR = RooDataSet("setTopSR", "setTopSR", variables, RooFit.Import(setTop), RooFit.Cut(SRcut), RooFit.WeightVar(weight))
# print "finish Top dataset"
# print " Data events SB: %.2f" % setDataSB.sumEntries()
print " V+jets entries: %.2f" % setVjet.sumEntries()
# print " VV, VH entries: %.2f" % setVV.sumEntries()
# print " Top,ST entries: %.2f" % setTop.sumEntries()
# the relative normalization of the varius bkg is taken from MC by counting all the events in the full fatJetMass range
#coef = RooRealVar("coef", "coef", setVV.sumEntries()/setVjet.sumEntries(),0.,1.)
# coef_VV_Vjet = RooRealVar("coef2_1", "coef2_1", setVV.sumEntries()/setVjet.sumEntries(), 0., 1.)
# coef_Top_VVVjet = RooRealVar("coef3_21", "coef3_21", setTop.sumEntries()/(setVjet.sumEntries()+setVV.sumEntries()),0.,1.);
# coef_VV_Vjet.setConstant(True)
# coef_Top_VVVjet.setConstant(True)
# Define entries
entryVjet = RooRealVar("entryVjets", "V+jets normalization", setVjet.sumEntries(), 0., 1.e6)
# entryVV = RooRealVar("entryVV", "VV normalization", setVV.sumEntries(), 0., 1.e6)
# entryTop = RooRealVar("entryTop", "Top normalization", setTop.sumEntries(), 0., 1.e6)
# entrySB = RooRealVar("entrySB", "Data SB normalization", setDataSB.sumEntries(SBcut), 0., 1.e6)
# entrySB.setError(math.sqrt(entrySB.getVal()))
# entryLSB = RooRealVar("entryLSB", "Data LSB normalization", setDataSB.sumEntries(LSBcut), 0., 1.e6)
# entryLSB.setError(math.sqrt(entryLSB.getVal()))
# entryHSB = RooRealVar("entryHSB", "Data HSB normalization", setDataSB.sumEntries(HSBcut), 0., 1.e6)
# entryHSB.setError(math.sqrt(entryHSB.getVal()))
#*******************************************************#
# #
# NORMALIZATION #
# #
#*******************************************************#
# set reasonable ranges for J_mass and X_mass
# these are used in the fit in order to avoid ROOFIT to look in regions very far away from where we are fitting
J_mass.setRange("h_reasonable_range", LOWMIN, HIGMAX)
X_mass.setRange("X_reasonable_range", XBINMIN, XBINMAX)
# Set RooArgSets once for all, see https://root.cern.ch/phpBB3/viewtopic.php?t=11758
jetMassArg = RooArgSet(J_mass)
##############################
# #
# Yu-hsiang test region #
# #
##############################
# test it in the channel "XZhnnb"
print "the channel is", channel
if channel == "XZhnnb":
# -------------------------------------------------------------------
# draw the setVjet
Jmass_frame = J_mass.frame(RooFit.Title("test frame"))
setVjet.plotOn(Jmass_frame)
# -------------------------------------------------------------------
# use a PDF to fit the dataset
print "fitFuncVjet is", fitFuncVjet
constVjet_value_initial = -0.020
offsetVjet_value_initial = 30.
widthVjet_value_initial = 100.
constVjet_test = RooRealVar("constVjet_test", "slope of the exp", constVjet_value_initial , -1., 0.)
offsetVjet_test = RooRealVar("offsetVjet_test", "offset of the erf", offsetVjet_value_initial, -50., 200.)
widthVjet_test = RooRealVar("widthVjet_test", "width of the erf", widthVjet_value_initial, 1., 200.)
modelVjet_test = RooErfExpPdf("modelVjet_test", "error function for V+jets mass", J_mass, constVjet_test, offsetVjet_test, widthVjet_test)
# constVjet_test.Print()
# offsetVjet_test.Print()
# widthVjet_test.Print()
# constVjet_test.setConstant(True)
# offsetVjet_test.setConstant(True)
# widthVjet_test.setConstant(True)
frVjet_test = modelVjet_test.fitTo(setVjet, RooFit.SumW2Error(True), RooFit.Range("h_reasonable_range"), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.Save(1), RooFit.PrintLevel(1 if VERBOSE else -1))
# constVjet_test.Print()
# offsetVjet_test.Print()
# widthVjet_test.Print()
constVjet_value_fit_MC = constVjet_test.getVal()
offsetVjet_value_fit_MC = offsetVjet_test.getVal()
widthVjet_value_fit_MC = widthVjet_test.getVal()
print "constVjet_value_fit_MC:", constVjet_value_fit_MC, "offsetVjet_value_fit_MC:",offsetVjet_value_fit_MC,"widthVjet_value_fit_MC:",widthVjet_value_fit_MC
modelVjet_test.plotOn(Jmass_frame,RooFit.LineColor(4))
# -------------------------------------------------------------------
# use the shape of fit to generate the psudo-data
Entries_pseudo_data = setVjet.sumEntries()
# Entries_pseudo_data = 502
# Entries_pseudo_data = 5021
pseudo_data = modelVjet_test.generate(RooArgSet(J_mass),Entries_pseudo_data )
# pseudo_data = modelVjet_test.generate(RooArgSet(J_mass),setVjet.sumEntries())
# pseudo_data = modelVjet_test.generate(RooArgSet(J_mass),502 )
# pseudo_data = modelVjet_test.generate(RooArgSet(J_mass),5021 )
# pseudo_data.Print("v")
Jmass_frame2 = J_mass.frame(RooFit.Title("test frame2"))
pseudo_data.plotOn(Jmass_frame2)
modelVjet_test.plotOn(Jmass_frame2,RooFit.LineColor(4))
# -------------------------------------------------------------------
# make another dataset that remove the signal region
pseudo_data_SB = RooDataSet("pseudo_data_SB", "pseudo_data_SB", RooArgSet(J_mass), RooFit.Import(pseudo_data), RooFit.Cut("fatjet1_prunedMassCorr<65 || fatjet1_prunedMassCorr>135") )
pseudo_data_SB.plotOn(Jmass_frame2,RooFit.LineColor(2))
# -------------------------------------------------------------------
# use another PDF to fit the pseudo-data in SB only
constVjet_test2 = RooRealVar("constVjet_test2", "slope of the exp", constVjet_value_fit_MC , -1., 0.)
offsetVjet_test2 = RooRealVar("offsetVjet_test2", "offset of the erf", offsetVjet_value_fit_MC , -50., 200.)
widthVjet_test2 = RooRealVar("widthVjet_test2", "width of the erf", widthVjet_value_fit_MC , 1., 200.)
modelVjet_test2 = RooErfExpPdf("modelVjet_test2", "error function for V+jets mass", J_mass, constVjet_test2, offsetVjet_test2, widthVjet_test2)
frVjet_test2 = modelVjet_test2.fitTo(pseudo_data_SB, RooFit.SumW2Error(True), RooFit.Range("LSBrange,HSBrange"), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.Save(1), RooFit.PrintLevel(1 if VERBOSE else -1))
# frVjet_test2 = modelVjet_test2.fitTo(pseudo_data_SB, RooFit.SumW2Error(True), RooFit.Range("h_reasonable_range"), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.Save(1), RooFit.PrintLevel(1 if VERBOSE else -1))
constVjet_value_fit_pseudo_data_SB = constVjet_test2.getVal()
offsetVjet_value_fit_pseudo_data_SB = offsetVjet_test2.getVal()
widthVjet_value_fit_pseudo_data_SB = widthVjet_test2.getVal()
print "constVjet_value_fit_pseudo_data_SB:", constVjet_value_fit_pseudo_data_SB, "offsetVjet_value_fit_pseudo_data_SB:",offsetVjet_value_fit_pseudo_data_SB,"widthVjet_value_fit_pseudo_data_SB:",widthVjet_value_fit_pseudo_data_SB
Jmass_frame3 = J_mass.frame(RooFit.Title("test frame3, fit the pseudo-data in SB only"))
pseudo_data_SB.plotOn(Jmass_frame3)
modelVjet_test2.plotOn(Jmass_frame3,RooFit.LineColor(4),RooFit.Range("h_reasonable_range"))
# -------------------------------------------------------------------
# calculate the Gen_value, the Fit_value and the Bias= ( Fit_value - Gen_value)/Gen_value
iGen_value = modelVjet_test.createIntegral(RooArgSet(J_mass), RooFit.Range("VRrange,SRrange"))
print "iGen_value:", iGen_value.getVal()
iFit_value = modelVjet_test2.createIntegral(RooArgSet(J_mass), RooFit.Range("VRrange,SRrange"))
print "iFit_value:", iFit_value.getVal()
Bias_value = ( iFit_value.getVal() - iGen_value.getVal() ) / iGen_value.getVal()
print "Bias_value of VR+SR:", Bias_value
# --------------
iGen_value = modelVjet_test.createIntegral(RooArgSet(J_mass), RooFit.Range("SRrange"))
print "iGen_value:", iGen_value.getVal()
iFit_value = modelVjet_test2.createIntegral(RooArgSet(J_mass), RooFit.Range("SRrange"))
print "iFit_value:", iFit_value.getVal()
Bias_value = ( iFit_value.getVal() - iGen_value.getVal() ) / iGen_value.getVal()
print "Bias_value of SR:", Bias_value
# iGen_value = modelVjet_test.createIntegral(RooArgSet(J_mass),RooFit.NormSet(RooArgSet(J_mass)), RooFit.Range("VRrange,SRrange"))
# print "iGen_value:", iGen_value.getVal()
# iGen_value = modelVjet_test.createIntegral(RooArgSet(J_mass),RooFit.NormSet(RooArgSet(J_mass)), RooFit.Range("VRrange,SRrange"))
# print "iGen_value:", iGen_value.getVal()
# iGen_value = modelVjet_test.createIntegral(RooArgSet(J_mass), RooFit.Range("h_reasonable_range"))
# print "iGen_value:", iGen_value.getVal()
# iGen_value = modelVjet_test.createIntegral(RooArgSet(J_mass))
# print "iGen_value:", iGen_value.getVal()
# -------------------------------------------------------------------
# repeat thousand times to see bias distribution
h_Bias = TH1D("h_Bias","h_Bias",80,-1,1);
Jmass_frame4 = J_mass.frame(RooFit.Title("test frame4"))
times_max = 50000
constVjet_test.setConstant(True)
offsetVjet_test.setConstant(True)
widthVjet_test.setConstant(True)
constVjet_test3 = RooRealVar("constVjet_test3", "slope of the exp", constVjet_value_fit_MC , -1., 0.)
offsetVjet_test3 = RooRealVar("offsetVjet_test3", "offset of the erf", offsetVjet_value_fit_MC , -50., 200.)
widthVjet_test3 = RooRealVar("widthVjet_test3", "width of the erf", widthVjet_value_fit_MC , 1., 200.)
for times in range(0,times_max):
# inside loop
# print "times:", times
if times % 10 == 0 :
print "Processing times:", times+1 ,"of", times_max
# generate pseudo-data
# n_1_prime = gRandom->Poisson(n_1);
Entries_pseudo_data_fluc = gRandom.Poisson( Entries_pseudo_data )
# print "Entries_pseudo_data:", Entries_pseudo_data
# print "Entries_pseudo_data_fluc:", Entries_pseudo_data_fluc
# pseudo_data2 = modelVjet_test.generate(RooArgSet(J_mass),Entries_pseudo_data )
pseudo_data2 = modelVjet_test.generate(RooArgSet(J_mass),Entries_pseudo_data_fluc )
# pseudo_data2.plotOn(Jmass_frame3,RooFit.LineColor(4),RooFit.Range("h_reasonable_range"))
# take out VR+SR
pseudo_data_SB2 = RooDataSet("pseudo_data_SB2", "pseudo_data_SB2", RooArgSet(J_mass), RooFit.Import(pseudo_data2), RooFit.Cut("fatjet1_prunedMassCorr<65 || fatjet1_prunedMassCorr>135") )
# use other PDF to fit
# print "constVjet_value_fit_MC:",constVjet_value_fit_MC
constVjet_test3.setVal(constVjet_value_fit_MC)
offsetVjet_test3.setVal(offsetVjet_value_fit_MC)
widthVjet_test3.setVal(widthVjet_value_fit_MC)
modelVjet_test3 = RooErfExpPdf("modelVjet_test3", "error function for V+jets mass", J_mass, constVjet_test3, offsetVjet_test3, widthVjet_test3)
frVjet_test3 = modelVjet_test3.fitTo(pseudo_data_SB2, RooFit.SumW2Error(True), RooFit.Range("LSBrange,HSBrange"), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.Save(1), RooFit.PrintLevel(1 if VERBOSE else -1))
# calculate the bias
iGen_value2 = modelVjet_test.createIntegral(jetMassArg,RooFit.NormSet(jetMassArg), RooFit.Range("SRrange"))
# print "iGen_value2:", iGen_value2.getVal()
iFit_value2 = modelVjet_test3.createIntegral(jetMassArg,RooFit.NormSet(jetMassArg), RooFit.Range("SRrange"))
# print "iFit_value2:", iFit_value2.getVal()
Bias_value2 = ( iFit_value2.getVal() - iGen_value2.getVal() ) / iGen_value2.getVal()
# print "Bias_value2 of VR+SR:", Bias_value2
h_Bias.Fill(Bias_value2)
# -------------------------------------------------------------------
# plot and save
Save_Dir = "/afs/cern.ch/user/y/yuchang/www/jacopo_plotsAlpha/yu_hsiang_bias_study"
c_test = TCanvas("test","test draw",800,600)
c_test.cd()
Jmass_frame.Draw()
c_test.SaveAs(Save_Dir+"/"+"VJet_MC_fit_get_shape.pdf")
c_test2 = TCanvas("test2","test draw 2",800,600)
c_test2.cd()
Jmass_frame2.Draw()
c_test2.SaveAs(Save_Dir+"/"+"use_shape_to_generate_pseudo_data.pdf")
# c_test2.SaveAs(Save_Dir+"/"+"use_shape_to_generate_pseudo_data_test.pdf")
c_test3 = TCanvas("test3","test draw 3",800,600)
c_test3.cd()
Jmass_frame3.Draw()
c_test3.SaveAs(Save_Dir+"/"+"fit_pseudo_data_in_SB_only.pdf")
c_test4 = TCanvas("test4","test draw 4",800,600)
c_test4.cd()
h_Bias.Draw()
c_test4.SaveAs(Save_Dir+"/"+"h_Bias.pdf")
"GeV")
mumuMass = RooRealVar("mumuMass", "mumuMass", 0, 6)
mumuMassE = RooRealVar("mumuMassE", "mumuMassE", 0, 10000)
tagB0 = RooRealVar("tagB0", "tagB0", 0, 2)
tagged_mass.setRange("full", 5.0, 5.6)
thevars = RooArgSet()
thevars.add(tagged_mass)
thevars.add(mumuMass)
thevars.add(mumuMassE)
thevars.add(tagB0)
fulldata = RooDataSet('fulldata', 'fulldataset', tData, RooArgSet(thevars))
## add to the data dataset a random variable, in order to scale it to desired stat
nDataEntries = fulldata.sumEntries()
randVar = RooRealVar("rand", "rand", 0, 1)
p0 = RooPolynomial("px", "px", randVar)
rDataset = p0.generate(RooArgSet(randVar), int(nDataEntries))
fulldata.merge(rDataset)
## add to the input tree the combination of the variables, to be used for the cuts on the dimuon mass
deltaB0Mfunc = RooFormulaVar("deltaB0M", "deltaB0M", "@0 - @1",
RooArgList(tagged_mass, B0Mass))
deltaJMfunc = RooFormulaVar("deltaJpsiM", "deltaJpsiM", "@0 - @1",
RooArgList(mumuMass, JPsiMass))
deltaPMfunc = RooFormulaVar("deltaPsiPM", "deltaPsiPM", "@0 - @1",
RooArgList(mumuMass, PsiPMass))
deltaB0M = fulldata.addColumn(deltaB0Mfunc)
deltaJpsiM = fulldata.addColumn(deltaJMfunc)
deltaPsiPM = fulldata.addColumn(deltaPMfunc)
def readData( filePath, dataSetName, NTuple = False, observables = None, **kwargs ) :
"""reads data from file (RooDataSet or TTree(s))
"""
from ROOT import RooFit
noNAN = ( ' && '.join( '( %s==%s )' % ( obs, obs ) for obs in observables ) ) if hasattr( observables, '__iter__' ) else ''
cuts = kwargs.pop( 'cuts', '' )
tmp_file = None
if observables :
print 'P2VV - INFO: readData: reading data for observables [ %s ]' % ', '.join( obs.GetName() for obs in observables )
dataSetArgs = { }
if 'WeightVar' in kwargs : dataSetArgs['WeightVar'] = kwargs.pop('WeightVar')
if NTuple :
from ROOT import RooDataSet, TFile
assert observables != None, 'P2VV - ERROR: readData: set of observables is required for reading an n-tuple'
# create data set from NTuple file(s)
print 'P2VV - INFO: readData: reading NTuple "%s" from file "%s"' % ( dataSetName, filePath )
ntupleFile = TFile.Open(filePath)
ntupleOrig = ntupleFile.Get(dataSetName)
if not ntupleOrig : raise RuntimeError( 'P2VV - ERROR: could not locate tree "%s" in file "%s"' % ( dataSetName, filePath ) )
if 'ntupleCuts' in kwargs :
ntupleCuts = kwargs.pop( 'ntupleCuts', '' )
print 'P2VV - INFO: readData: applying cuts on n-tuple: %s' % ntupleCuts
import tempfile
import os
from ROOT import TFile, gFile
orig_file = gFile
d = None
if 'TMP' in os.environ:
d = os.environ['TMP']
elif 'TMPDIR' in os.environ:
d = os.environ['TMPDIR']
elif os.access(os.path.dirname(filePath), os.W_OK):
d = os.path.dirname(filePath)
else:
d = '/tmp'
fd, temp_name = tempfile.mkstemp(suffix = '.root', dir = d)
os.close(fd)
os.remove(temp_name)
tmp_file = TFile.Open(temp_name, 'recreate')
ntuple = ntupleOrig.CopyTree(ntupleCuts)
else :
ntuple = ntupleOrig
if cuts : print 'P2VV - INFO: readData: applying cuts on data set: %s' % cuts
data = RooDataSet( dataSetName, dataSetName
, [ obs._var for obs in observables ]
, Import = ntuple
, Cut = noNAN + ' && ' + cuts if cuts else noNAN
, **dataSetArgs
)
else :
from ROOT import TFile
# get data set from file
print 'P2VV - INFO: readData: reading RooDataset "%s" from file "%s"' % ( dataSetName, filePath )
file = TFile.Open( filePath, 'READ' )
assert file, 'P2VV - ERROR: readData: file "%s" could not be opened' % filePath
if cuts : print 'P2VV - INFO: readData: applying cuts: %s' % cuts
# loop over category states
states = tuple( [ [ ( cat[0], ind ) for ind in cat[1] ] for cat in kwargs.pop( 'Categories', [ ( '', [ '' ] ) ] ) ] )
from itertools import product
for it, state in enumerate( product(*states) ) :
# get data set
dsName = '_'.join( str(catSt[0]) + str(catSt[1]) for catSt in state )
dsName = dataSetName + ( ( '_' + dsName ) if dsName else '' )
dataSet = file.Get(dsName)
assert dataSet, 'P2VV - ERROR: data set "%s" not found' % dsName
if it == 0 :
if observables :
from ROOT import RooDataSet
data = RooDataSet( dataSetName, dataSetName
, [ obs._var for obs in observables ]
, Import = dataSet
, Cut = noNAN + ' && ' + cuts if cuts else noNAN
, **dataSetArgs
)
else :
data = dataSet
else :
data.append(dataSet)
file.Close()
print 'P2VV - INFO: read dataset with %s entries (%.1f weighted)' % ( data.numEntries(), data.sumEntries() )
# import data set into current workspace
from P2VV.RooFitWrappers import RooObject
importIntoWS = kwargs.pop( 'ImportIntoWS', True )
rData = None
if importIntoWS :
# import data set into current workspace
from P2VV.RooFitWrappers import RooObject
wsData = RooObject().ws().put( data, **kwargs )
rData = wsData
else :
rData = data
if tmp_file:
tmp_file.Close()
os.remove(tmp_file.GetName())
if orig_file: orig_file.cd()
return rData
def alpha(channel):
nElec = channel.count("e")
nMuon = channel.count("m")
nLept = nElec + nMuon
nBtag = channel.count("b")
# Channel-dependent settings
# Background function. Semi-working options are: EXP, EXP2, EXPN, EXPTAIL
if nLept == 0:
treeName = "SR"
signName = "XZh"
colorVjet = sample["DYJetsToNuNu"]["linecolor"]
triName = "HLT_PFMET"
leptCut = "0==0"
topVeto = selection["TopVetocut"]
massVar = "X_cmass"
binFact = 1
fitFunc = "EXPN" if nBtag < 2 else "EXPN"
fitAltFunc = "EXPTAIL" if nBtag < 2 else "EXPTAIL"
fitFuncVjet = "ERFEXP" if nBtag < 2 else "EXP"
fitAltFuncVjet = "POL" if nBtag < 2 else "POL"
fitFuncVV = "EXPGAUS" if nBtag < 2 else "EXPGAUS"
fitFuncTop = "GAUS2"
elif nLept == 1:
treeName = "WCR"
signName = "XWh"
colorVjet = sample["WJetsToLNu"]["linecolor"]
triName = "HLT_Ele" if nElec > 0 else "HLT_Mu"
leptCut = "isWtoEN" if nElec > 0 else "isWtoMN"
topVeto = selection["TopVetocut"]
massVar = "X_mass"
binFact = 2
if nElec > 0:
fitFunc = "EXPTAIL" if nBtag < 2 else "EXPN"
fitAltFunc = "EXPN" if nBtag < 2 else "POW"
else:
fitFunc = "EXPN" if nBtag < 2 else "EXPN"
fitAltFunc = "EXPTAIL" if nBtag < 2 else "POW"
fitFuncVjet = "ERFEXP" if nBtag < 2 else "EXP"
fitAltFuncVjet = "POL" if nBtag < 2 else "POL"
fitFuncVV = "EXPGAUS" if nBtag < 2 else "EXPGAUS"
fitFuncTop = "GAUS3" if nBtag < 2 else "GAUS2"
else:
treeName = "XZh"
signName = "XZh"
colorVjet = sample["DYJetsToLL"]["linecolor"]
triName = "HLT_Ele" if nElec > 0 else "HLT_Mu"
leptCut = "isZtoEE" if nElec > 0 else "isZtoMM"
topVeto = "X_dPhi>2.5"
massVar = "X_mass"
binFact = 2
if nElec > 0:
fitFunc = "EXPTAIL" if nBtag < 2 else "EXPTAIL"
fitAltFunc = "POW" if nBtag < 2 else "POW"
else:
fitFunc = "EXPTAIL" if nBtag < 2 else "EXPTAIL"
fitAltFunc = "POW" if nBtag < 2 else "POW"
fitFuncVjet = "ERFEXP" if nBtag < 2 and nElec < 1 else "EXP"
fitAltFuncVjet = "POL" if nBtag < 2 else "POL"
fitFuncVV = "EXPGAUS2" if nBtag < 2 else "EXPGAUS2"
fitFuncTop = "GAUS"
btagCut = selection["2Btag"] if nBtag == 2 else selection["1Btag"]
print "--- Channel", channel, "---"
print " number of electrons:", nElec, " muons:", nMuon, " b-tags:", nBtag
print " read tree:", treeName, "and trigger:", triName
if ALTERNATIVE:
print " using ALTERNATIVE fit functions"
print "-" * 11 * 2
# Silent RooFit
RooMsgService.instance().setGlobalKillBelow(RooFit.FATAL)
# *******************************************************#
# #
# Variables and selections #
# #
# *******************************************************#
# Define all the variables from the trees that will be used in the cuts and fits
# this steps actually perform a "projection" of the entire tree on the variables in thei ranges, so be careful once setting the limits
X_mass = RooRealVar(massVar, "m_{X}" if nLept > 0 else "m_{T}^{X}", XBINMIN, XBINMAX, "GeV")
J_mass = RooRealVar("fatjet1_prunedMassCorr", "jet corrected pruned mass", HBINMIN, HBINMAX, "GeV")
CSV1 = RooRealVar("fatjet1_CSVR1", "", -1.0e99, 1.0e4)
CSV2 = RooRealVar("fatjet1_CSVR2", "", -1.0e99, 1.0e4)
nB = RooRealVar("fatjet1_nBtag", "", 0.0, 4)
CSVTop = RooRealVar("bjet1_CSVR", "", -1.0e99, 1.0e4)
X_dPhi = RooRealVar("X_dPhi", "", 0.0, 3.15)
isZtoEE = RooRealVar("isZtoEE", "", 0.0, 2)
isZtoMM = RooRealVar("isZtoMM", "", 0.0, 2)
isWtoEN = RooRealVar("isWtoEN", "", 0.0, 2)
isWtoMN = RooRealVar("isWtoMN", "", 0.0, 2)
weight = RooRealVar("eventWeightLumi", "", -1.0e9, 1.0)
# Define the RooArgSet which will include all the variables defined before
# there is a maximum of 9 variables in the declaration, so the others need to be added with 'add'
variables = RooArgSet(X_mass, J_mass, CSV1, CSV2, nB, CSVTop, X_dPhi)
variables.add(RooArgSet(isZtoEE, isZtoMM, isWtoEN, isWtoMN, weight))
# set reasonable ranges for J_mass and X_mass
# these are used in the fit in order to avoid ROOFIT to look in regions very far away from where we are fitting
# (honestly, it is not clear to me why it is necessary, but without them the fit often explodes)
J_mass.setRange("h_reasonable_range", LOWMIN, HIGMAX)
X_mass.setRange("X_reasonable_range", XBINMIN, XBINMAX)
# Set RooArgSets once for all, see https://root.cern.ch/phpBB3/viewtopic.php?t=11758
jetMassArg = RooArgSet(J_mass)
# Define the ranges in fatJetMass - these will be used to define SB and SR
J_mass.setRange("LSBrange", LOWMIN, LOWMAX)
J_mass.setRange("HSBrange", HIGMIN, HIGMAX)
J_mass.setRange("VRrange", LOWMAX, SIGMIN)
J_mass.setRange("SRrange", SIGMIN, SIGMAX)
# Set binning for plots
J_mass.setBins(HBINS)
X_mass.setBins(binFact * XBINS)
# Define the selection for the various categories (base + SR / LSBcut / HSBcut )
baseCut = leptCut + " && " + btagCut + "&&" + topVeto
massCut = massVar + ">%d" % XBINMIN
baseCut += " && " + massCut
# Cuts
SRcut = baseCut + " && %s>%d && %s<%d" % (J_mass.GetName(), SIGMIN, J_mass.GetName(), SIGMAX)
LSBcut = baseCut + " && %s>%d && %s<%d" % (J_mass.GetName(), LOWMIN, J_mass.GetName(), LOWMAX)
HSBcut = baseCut + " && %s>%d && %s<%d" % (J_mass.GetName(), HIGMIN, J_mass.GetName(), HIGMAX)
SBcut = baseCut + " && ((%s>%d && %s<%d) || (%s>%d && %s<%d))" % (
J_mass.GetName(),
LOWMIN,
J_mass.GetName(),
LOWMAX,
J_mass.GetName(),
HIGMIN,
J_mass.GetName(),
HIGMAX,
)
VRcut = baseCut + " && %s>%d && %s<%d" % (J_mass.GetName(), LOWMAX, J_mass.GetName(), SIGMIN)
# Binning
binsJmass = RooBinning(HBINS, HBINMIN, HBINMAX)
# binsJmass.addUniform(HBINS, HBINMIN, HBINMAX)
binsXmass = RooBinning(binFact * XBINS, XBINMIN, XBINMAX)
# binsXmass.addUniform(binFact*XBINS, XBINMIN, XBINMAX)
# *******************************************************#
# #
# Input files #
# #
# *******************************************************#
# Import the files using TChains (separately for the bkg "classes" that we want to describe: here DY and VV+ST+TT)
treeData = TChain(treeName)
treeMC = TChain(treeName)
treeVjet = TChain(treeName)
treeVV = TChain(treeName)
treeTop = TChain(treeName)
treeSign = {}
nevtSign = {}
for i, m in enumerate(massPoints):
treeSign[m] = TChain(treeName)
# Read data
pd = getPrimaryDataset(triName)
if len(pd) == 0:
raw_input("Warning: Primary Dataset not recognized, continue?")
for i, s in enumerate(pd):
treeData.Add(NTUPLEDIR + s + ".root")
# Read V+jets backgrounds
for i, s in enumerate(["WJetsToLNu_HT", "DYJetsToNuNu_HT", "DYJetsToLL_HT"]):
for j, ss in enumerate(sample[s]["files"]):
treeVjet.Add(NTUPLEDIR + ss + ".root")
# Read VV backgrounds
for i, s in enumerate(["VV"]):
for j, ss in enumerate(sample[s]["files"]):
treeVV.Add(NTUPLEDIR + ss + ".root")
# Read Top backgrounds
for i, s in enumerate(["ST", "TTbar"]):
for j, ss in enumerate(sample[s]["files"]):
treeTop.Add(NTUPLEDIR + ss + ".root")
# Read signals
for i, m in enumerate(massPoints):
for j, ss in enumerate(sample["%s_M%d" % (signName, m)]["files"]):
treeSign[m].Add(NTUPLEDIR + ss + ".root")
sfile = TFile(NTUPLEDIR + ss + ".root", "READ")
shist = sfile.Get("Counters/Counter")
nevtSign[m] = shist.GetBinContent(1)
sfile.Close()
# Sum all background MC
treeMC.Add(treeVjet)
treeMC.Add(treeVV)
treeMC.Add(treeTop)
# create a dataset to host data in sideband (using this dataset we are automatically blind in the SR!)
setDataSB = RooDataSet(
"setDataSB", "setDataSB", variables, RooFit.Cut(SBcut), RooFit.WeightVar(weight), RooFit.Import(treeData)
)
setDataLSB = RooDataSet(
"setDataLSB", "setDataLSB", variables, RooFit.Import(setDataSB), RooFit.Cut(LSBcut), RooFit.WeightVar(weight)
)
setDataHSB = RooDataSet(
"setDataHSB", "setDataHSB", variables, RooFit.Import(setDataSB), RooFit.Cut(HSBcut), RooFit.WeightVar(weight)
)
# Observed data (WARNING, BLIND!)
setDataSR = RooDataSet(
"setDataSR", "setDataSR", variables, RooFit.Cut(SRcut), RooFit.WeightVar(weight), RooFit.Import(treeData)
)
setDataVR = RooDataSet(
"setDataVR", "setDataVR", variables, RooFit.Cut(VRcut), RooFit.WeightVar(weight), RooFit.Import(treeData)
) # Observed in the VV mass, just for plotting purposes
setDataSRSB = RooDataSet(
"setDataSRSB",
"setDataSRSB",
variables,
RooFit.Cut("(" + SRcut + ") || (" + SBcut + ")"),
RooFit.WeightVar(weight),
RooFit.Import(treeData),
)
# same for the bkg datasets from MC, where we just apply the base selections (not blind)
setVjet = RooDataSet(
"setVjet", "setVjet", variables, RooFit.Cut(baseCut), RooFit.WeightVar(weight), RooFit.Import(treeVjet)
)
setVjetSB = RooDataSet(
"setVjetSB", "setVjetSB", variables, RooFit.Import(setVjet), RooFit.Cut(SBcut), RooFit.WeightVar(weight)
)
setVjetSR = RooDataSet(
"setVjetSR", "setVjetSR", variables, RooFit.Import(setVjet), RooFit.Cut(SRcut), RooFit.WeightVar(weight)
)
setVV = RooDataSet(
"setVV", "setVV", variables, RooFit.Cut(baseCut), RooFit.WeightVar(weight), RooFit.Import(treeVV)
)
setVVSB = RooDataSet(
"setVVSB", "setVVSB", variables, RooFit.Import(setVV), RooFit.Cut(SBcut), RooFit.WeightVar(weight)
)
setVVSR = RooDataSet(
"setVVSR", "setVVSR", variables, RooFit.Import(setVV), RooFit.Cut(SRcut), RooFit.WeightVar(weight)
)
setTop = RooDataSet(
"setTop", "setTop", variables, RooFit.Cut(baseCut), RooFit.WeightVar(weight), RooFit.Import(treeTop)
)
setTopSB = RooDataSet(
"setTopSB", "setTopSB", variables, RooFit.Import(setTop), RooFit.Cut(SBcut), RooFit.WeightVar(weight)
)
setTopSR = RooDataSet(
"setTopSR", "setTopSR", variables, RooFit.Import(setTop), RooFit.Cut(SRcut), RooFit.WeightVar(weight)
)
print " Data events SB: %.2f" % setDataSB.sumEntries()
print " V+jets entries: %.2f" % setVjet.sumEntries()
print " VV, VH entries: %.2f" % setVV.sumEntries()
print " Top,ST entries: %.2f" % setTop.sumEntries()
nVV = RooRealVar("nVV", "VV normalization", setVV.sumEntries(SBcut), 0.0, 2 * setVV.sumEntries(SBcut))
nTop = RooRealVar("nTop", "Top normalization", setTop.sumEntries(SBcut), 0.0, 2 * setTop.sumEntries(SBcut))
nVjet = RooRealVar("nVjet", "Vjet normalization", setDataSB.sumEntries(), 0.0, 2 * setDataSB.sumEntries(SBcut))
nVjet2 = RooRealVar("nVjet2", "Vjet2 normalization", setDataSB.sumEntries(), 0.0, 2 * setDataSB.sumEntries(SBcut))
# Apply Top SF
nTop.setVal(nTop.getVal() * topSF[nLept][nBtag])
nTop.setError(nTop.getVal() * topSFErr[nLept][nBtag])
# Define entries
entryVjet = RooRealVar("entryVjets", "V+jets normalization", setVjet.sumEntries(), 0.0, 1.0e6)
entryVV = RooRealVar("entryVV", "VV normalization", setVV.sumEntries(), 0.0, 1.0e6)
entryTop = RooRealVar("entryTop", "Top normalization", setTop.sumEntries(), 0.0, 1.0e6)
entrySB = RooRealVar("entrySB", "Data SB normalization", setDataSB.sumEntries(SBcut), 0.0, 1.0e6)
entrySB.setError(math.sqrt(entrySB.getVal()))
entryLSB = RooRealVar("entryLSB", "Data LSB normalization", setDataSB.sumEntries(LSBcut), 0.0, 1.0e6)
entryLSB.setError(math.sqrt(entryLSB.getVal()))
entryHSB = RooRealVar("entryHSB", "Data HSB normalization", setDataSB.sumEntries(HSBcut), 0.0, 1.0e6)
entryHSB.setError(math.sqrt(entryHSB.getVal()))
###################################################################################
# _ _ #
# | \ | | | (_) | | (_) #
# | \| | ___ _ __ _ __ ___ __ _| |_ ___ __ _| |_ _ ___ _ __ #
# | . ` |/ _ \| '__| '_ ` _ \ / _` | | / __|/ _` | __| |/ _ \| '_ \ #
# | |\ | (_) | | | | | | | | (_| | | \__ \ (_| | |_| | (_) | | | | #
# |_| \_|\___/|_| |_| |_| |_|\__,_|_|_|___/\__,_|\__|_|\___/|_| |_| #
# #
###################################################################################
# fancy ASCII art thanks to, I guess, Jose
# start by creating the fit models to get the normalization:
# * MAIN and SECONDARY bkg are taken from MC by fitting the whole J_mass range
# * The two PDFs are added together using the relative normalizations of the two bkg from MC
# * DATA is then fit in the sidebands only using the combined bkg PDF
# * The results of the fit are then estrapolated in the SR and the integral is evaluated.
# * This defines the bkg normalization in the SR
# *******************************************************#
# #
# V+jets normalization #
# #
# *******************************************************#
# Variables for V+jets
constVjet = RooRealVar("constVjet", "slope of the exp", -0.020, -1.0, 0.0)
offsetVjet = RooRealVar("offsetVjet", "offset of the erf", 30.0, -50.0, 400.0)
widthVjet = RooRealVar("widthVjet", "width of the erf", 100.0, 1.0, 200.0) # 0, 400
a0Vjet = RooRealVar("a0Vjet", "width of the erf", -0.1, -5, 0)
a1Vjet = RooRealVar("a1Vjet", "width of the erf", 0.6, 0, 5)
a2Vjet = RooRealVar("a2Vjet", "width of the erf", -0.1, -1, 1)
if channel == "XZhnnb":
offsetVjet = RooRealVar("offsetVjet", "offset of the erf", 500.0, 200.0, 1000.0)
if channel == "XZhnnbb":
offsetVjet = RooRealVar("offsetVjet", "offset of the erf", 350.0, 200.0, 500.0)
# if channel == "XWhenb" or channel == "XZheeb":
# offsetVjet.setVal(120.)
# offsetVjet.setConstant(True)
if channel == "XWhenb":
offsetVjet = RooRealVar("offsetVjet", "offset of the erf", 120.0, 80.0, 155.0)
if channel == "XWhenbb" or channel == "XZhmmb":
offsetVjet = RooRealVar("offsetVjet", "offset of the erf", 67.0, 50.0, 100.0)
if channel == "XWhmnb":
offsetVjet = RooRealVar("offsetVjet", "offset of the erf", 30.0, -50.0, 600.0)
if channel == "XZheeb":
offsetVjet.setMin(-400)
offsetVjet.setVal(0.0)
offsetVjet.setMax(1000)
widthVjet.setVal(1.0)
# Define V+jets model
if fitFuncVjet == "ERFEXP":
VjetMass = RooErfExpPdf("VjetMass", fitFuncVjet, J_mass, constVjet, offsetVjet, widthVjet)
elif fitFuncVjet == "EXP":
VjetMass = RooExponential("VjetMass", fitFuncVjet, J_mass, constVjet)
elif fitFuncVjet == "GAUS":
VjetMass = RooGaussian("VjetMass", fitFuncVjet, J_mass, offsetVjet, widthVjet)
elif fitFuncVjet == "POL":
VjetMass = RooChebychev("VjetMass", fitFuncVjet, J_mass, RooArgList(a0Vjet, a1Vjet, a2Vjet))
elif fitFuncVjet == "POW":
VjetMass = RooGenericPdf("VjetMass", fitFuncVjet, "@0^@1", RooArgList(J_mass, a0Vjet))
else:
print " ERROR! Pdf", fitFuncVjet, "is not implemented for Vjets"
exit()
if fitAltFuncVjet == "POL":
VjetMass2 = RooChebychev("VjetMass2", "polynomial for V+jets mass", J_mass, RooArgList(a0Vjet, a1Vjet, a2Vjet))
else:
print " ERROR! Pdf", fitAltFuncVjet, "is not implemented for Vjets"
exit()
# fit to main bkg in MC (whole range)
frVjet = VjetMass.fitTo(
setVjet,
RooFit.SumW2Error(True),
RooFit.Range("h_reasonable_range"),
RooFit.Strategy(2),
RooFit.Minimizer("Minuit2"),
RooFit.Save(1),
RooFit.PrintLevel(1 if VERBOSE else -1),
)
frVjet2 = VjetMass2.fitTo(
setVjet,
RooFit.SumW2Error(True),
RooFit.Range("h_reasonable_range"),
RooFit.Strategy(2),
RooFit.Minimizer("Minuit2"),
RooFit.Save(1),
RooFit.PrintLevel(1 if VERBOSE else -1),
)
if VERBOSE:
print "********** Fit result [JET MASS Vjets] *" + "*" * 40, "\n", frVjet.Print(), "\n", "*" * 80
# likelihoodScan(VjetMass, setVjet, [constVjet, offsetVjet, widthVjet])
# *******************************************************#
# #
# VV, VH normalization #
# #
# *******************************************************#
# Variables for VV
# Error function and exponential to model the bulk
constVV = RooRealVar("constVV", "slope of the exp", -0.030, -0.1, 0.0)
offsetVV = RooRealVar("offsetVV", "offset of the erf", 90.0, 1.0, 300.0)
widthVV = RooRealVar("widthVV", "width of the erf", 50.0, 1.0, 100.0)
erfrVV = RooErfExpPdf("baseVV", "error function for VV jet mass", J_mass, constVV, offsetVV, widthVV)
expoVV = RooExponential("baseVV", "error function for VV jet mass", J_mass, constVV)
# gaussian for the V mass peak
meanVV = RooRealVar("meanVV", "mean of the gaussian", 90.0, 60.0, 100.0)
sigmaVV = RooRealVar("sigmaVV", "sigma of the gaussian", 10.0, 6.0, 30.0)
fracVV = RooRealVar("fracVV", "fraction of gaussian wrt erfexp", 3.2e-1, 0.0, 1.0)
gausVV = RooGaussian("gausVV", "gaus for VV jet mass", J_mass, meanVV, sigmaVV)
# gaussian for the H mass peak
meanVH = RooRealVar("meanVH", "mean of the gaussian", 125.0, 100.0, 150.0)
sigmaVH = RooRealVar("sigmaVH", "sigma of the gaussian", 10.0, 5.0, 50.0)
fracVH = RooRealVar("fracVH", "fraction of gaussian wrt erfexp", 1.5e-2, 0.0, 1.0)
gausVH = RooGaussian("gausVH", "gaus for VH jet mass", J_mass, meanVH, sigmaVH)
# Define VV model
if fitFuncVV == "ERFEXPGAUS":
VVMass = RooAddPdf("VVMass", fitFuncVV, RooArgList(gausVV, erfrVV), RooArgList(fracVV))
elif fitFuncVV == "ERFEXPGAUS2":
VVMass = RooAddPdf("VVMass", fitFuncVV, RooArgList(gausVH, gausVV, erfrVV), RooArgList(fracVH, fracVV))
elif fitFuncVV == "EXPGAUS":
VVMass = RooAddPdf("VVMass", fitFuncVV, RooArgList(gausVV, expoVV), RooArgList(fracVV))
elif fitFuncVV == "EXPGAUS2":
VVMass = RooAddPdf("VVMass", fitFuncVV, RooArgList(gausVH, gausVV, expoVV), RooArgList(fracVH, fracVV))
else:
print " ERROR! Pdf", fitFuncVV, "is not implemented for VV"
exit()
# fit to secondary bkg in MC (whole range)
frVV = VVMass.fitTo(
setVV,
RooFit.SumW2Error(True),
RooFit.Range("h_reasonable_range"),
RooFit.Strategy(2),
RooFit.Minimizer("Minuit2"),
RooFit.Save(1),
RooFit.PrintLevel(1 if VERBOSE else -1),
)
if VERBOSE:
print "********** Fit result [JET MASS VV] ****" + "*" * 40, "\n", frVV.Print(), "\n", "*" * 80
# *******************************************************#
# #
# Top, ST normalization #
# #
# *******************************************************#
# Variables for Top
# Error Function * Exponential to model the bulk
constTop = RooRealVar("constTop", "slope of the exp", -0.030, -1.0, 0.0)
offsetTop = RooRealVar("offsetTop", "offset of the erf", 175.0, 50.0, 250.0)
widthTop = RooRealVar("widthTop", "width of the erf", 100.0, 1.0, 300.0)
gausTop = RooGaussian("baseTop", "gaus for Top jet mass", J_mass, offsetTop, widthTop)
erfrTop = RooErfExpPdf("baseTop", "error function for Top jet mass", J_mass, constTop, offsetTop, widthTop)
# gaussian for the W mass peak
meanW = RooRealVar("meanW", "mean of the gaussian", 80.0, 70.0, 90.0)
sigmaW = RooRealVar("sigmaW", "sigma of the gaussian", 10.0, 2.0, 20.0)
fracW = RooRealVar("fracW", "fraction of gaussian wrt erfexp", 0.1, 0.0, 1.0)
gausW = RooGaussian("gausW", "gaus for W jet mass", J_mass, meanW, sigmaW)
# gaussian for the Top mass peak
meanT = RooRealVar("meanT", "mean of the gaussian", 175.0, 150.0, 200.0)
sigmaT = RooRealVar("sigmaT", "sigma of the gaussian", 12.0, 5.0, 30.0)
fracT = RooRealVar("fracT", "fraction of gaussian wrt erfexp", 0.1, 0.0, 1.0)
gausT = RooGaussian("gausT", "gaus for T jet mass", J_mass, meanT, sigmaT)
if channel == "XZheeb" or channel == "XZheebb" or channel == "XZhmmb" or channel == "XZhmmbb":
offsetTop = RooRealVar("offsetTop", "offset of the erf", 200.0, -50.0, 450.0)
widthTop = RooRealVar("widthTop", "width of the erf", 100.0, 1.0, 1000.0)
# Define Top model
if fitFuncTop == "ERFEXPGAUS2":
TopMass = RooAddPdf("TopMass", fitFuncTop, RooArgList(gausW, gausT, erfrTop), RooArgList(fracW, fracT))
elif fitFuncTop == "ERFEXPGAUS":
TopMass = RooAddPdf("TopMass", fitFuncTop, RooArgList(gausT, erfrTop), RooArgList(fracT))
elif fitFuncTop == "GAUS3":
TopMass = RooAddPdf("TopMass", fitFuncTop, RooArgList(gausW, gausT, gausTop), RooArgList(fracW, fracT))
elif fitFuncTop == "GAUS2":
TopMass = RooAddPdf("TopMass", fitFuncTop, RooArgList(gausT, gausTop), RooArgList(fracT))
elif fitFuncTop == "GAUS":
TopMass = RooGaussian("TopMass", fitFuncTop, J_mass, offsetTop, widthTop)
else:
print " ERROR! Pdf", fitFuncTop, "is not implemented for Top"
exit()
# fit to secondary bkg in MC (whole range)
frTop = TopMass.fitTo(
setTop,
RooFit.SumW2Error(True),
RooFit.Range("h_reasonable_range"),
RooFit.Strategy(2),
RooFit.Minimizer("Minuit2"),
RooFit.Save(1),
RooFit.PrintLevel(1 if VERBOSE else -1),
)
if VERBOSE:
print "********** Fit result [JET MASS TOP] ***" + "*" * 40, "\n", frTop.Print(), "\n", "*" * 80
# likelihoodScan(TopMass, setTop, [offsetTop, widthTop])
# *******************************************************#
# #
# All bkg normalization #
# #
# *******************************************************#
# nVjet.setConstant(False)
# nVjet2.setConstant(False)
#
# constVjet.setConstant(False)
# offsetVjet.setConstant(False)
# widthVjet.setConstant(False)
# a0Vjet.setConstant(False)
# a1Vjet.setConstant(False)
# a2Vjet.setConstant(False)
constVV.setConstant(True)
offsetVV.setConstant(True)
widthVV.setConstant(True)
meanVV.setConstant(True)
sigmaVV.setConstant(True)
fracVV.setConstant(True)
meanVH.setConstant(True)
sigmaVH.setConstant(True)
fracVH.setConstant(True)
constTop.setConstant(True)
offsetTop.setConstant(True)
widthTop.setConstant(True)
meanW.setConstant(True)
sigmaW.setConstant(True)
fracW.setConstant(True)
meanT.setConstant(True)
sigmaT.setConstant(True)
fracT.setConstant(True)
nVV.setConstant(True)
nTop.setConstant(True)
nVjet.setConstant(False)
nVjet2.setConstant(False)
# Final background model by adding the main+secondary pdfs (using 'coef': ratio of the secondary/main, from MC)
TopMass_ext = RooExtendPdf("TopMass_ext", "extended p.d.f", TopMass, nTop)
VVMass_ext = RooExtendPdf("VVMass_ext", "extended p.d.f", VVMass, nVV)
VjetMass_ext = RooExtendPdf("VjetMass_ext", "extended p.d.f", VjetMass, nVjet)
VjetMass2_ext = RooExtendPdf("VjetMass_ext", "extended p.d.f", VjetMass, nVjet2)
BkgMass = RooAddPdf(
"BkgMass", "BkgMass", RooArgList(TopMass_ext, VVMass_ext, VjetMass_ext), RooArgList(nTop, nVV, nVjet)
)
BkgMass2 = RooAddPdf(
"BkgMass2", "BkgMass2", RooArgList(TopMass_ext, VVMass_ext, VjetMass2_ext), RooArgList(nTop, nVV, nVjet2)
)
BkgMass.fixAddCoefRange("h_reasonable_range")
BkgMass2.fixAddCoefRange("h_reasonable_range")
# Extended fit model to data in SB
frMass = BkgMass.fitTo(
setDataSB,
RooFit.SumW2Error(True),
RooFit.Extended(True),
RooFit.Range("LSBrange,HSBrange"),
RooFit.Strategy(2),
RooFit.Minimizer("Minuit"),
RooFit.Save(1),
RooFit.PrintLevel(1 if VERBOSE else -1),
) # , RooFit.NumCPU(10)
if VERBOSE:
print "********** Fit result [JET MASS DATA] **" + "*" * 40, "\n", frMass.Print(), "\n", "*" * 80
frMass2 = BkgMass2.fitTo(
setDataSB,
RooFit.SumW2Error(True),
RooFit.Extended(True),
RooFit.Range("LSBrange,HSBrange"),
RooFit.Strategy(2),
RooFit.Minimizer("Minuit"),
RooFit.Save(1),
RooFit.PrintLevel(1 if VERBOSE else -1),
)
if VERBOSE:
print "********** Fit result [JET MASS DATA] **" + "*" * 40, "\n", frMass2.Print(), "\n", "*" * 80
# if SCAN:
# likelihoodScan(VjetMass, setVjet, [constVjet, offsetVjet, widthVjet])
# Fix normalization and parameters of V+jets after the fit to data
nVjet.setConstant(True)
nVjet2.setConstant(True)
constVjet.setConstant(True)
offsetVjet.setConstant(True)
widthVjet.setConstant(True)
a0Vjet.setConstant(True)
a1Vjet.setConstant(True)
a2Vjet.setConstant(True)
# integrals for global normalization
# do not integrate the composte model: results have no sense
# integral for normalization in the SB
iSBVjet = VjetMass.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange,HSBrange"))
iSBVV = VVMass.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange,HSBrange"))
iSBTop = TopMass.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange,HSBrange"))
# integral for normalization in the SR
iSRVjet = VjetMass.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("SRrange"))
iSRVV = VVMass.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("SRrange"))
iSRTop = TopMass.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("SRrange"))
# integral for normalization in the VR
iVRVjet = VjetMass.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("VRrange"))
iVRVV = VVMass.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("VRrange"))
iVRTop = TopMass.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("VRrange"))
# formual vars
SByield = RooFormulaVar(
"SByield", "extrapolation to SR", "@0*@1 + @2*@3 + @4*@5", RooArgList(iSBVjet, nVjet, iSBVV, nVV, iSBTop, nTop)
)
VRyield = RooFormulaVar(
"VRyield", "extrapolation to VR", "@0*@1 + @2*@3 + @4*@5", RooArgList(iVRVjet, nVjet, iVRVV, nVV, iVRTop, nTop)
)
SRyield = RooFormulaVar(
"SRyield", "extrapolation to SR", "@0*@1 + @2*@3 + @4*@5", RooArgList(iSRVjet, nVjet, iSRVV, nVV, iSRTop, nTop)
)
# fractions
fSBVjet = RooRealVar(
"fVjet", "Fraction of Vjet events in SB", iSBVjet.getVal() * nVjet.getVal() / SByield.getVal(), 0.0, 1.0
)
fSBVV = RooRealVar(
"fSBVV", "Fraction of VV events in SB", iSBVV.getVal() * nVV.getVal() / SByield.getVal(), 0.0, 1.0
)
fSBTop = RooRealVar(
"fSBTop", "Fraction of Top events in SB", iSBTop.getVal() * nTop.getVal() / SByield.getVal(), 0.0, 1.0
)
fSRVjet = RooRealVar(
"fSRVjet", "Fraction of Vjet events in SR", iSRVjet.getVal() * nVjet.getVal() / SRyield.getVal(), 0.0, 1.0
)
fSRVV = RooRealVar(
"fSRVV", "Fraction of VV events in SR", iSRVV.getVal() * nVV.getVal() / SRyield.getVal(), 0.0, 1.0
)
fSRTop = RooRealVar(
"fSRTop", "Fraction of Top events in SR", iSRTop.getVal() * nTop.getVal() / SRyield.getVal(), 0.0, 1.0
)
# final normalization values
bkgYield = SRyield.getVal()
bkgYield2 = (
(VjetMass2.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("SRrange"))).getVal()
* nVjet2.getVal()
+ iSRVV.getVal() * nVV.getVal()
+ iSRTop.getVal() * nTop.getVal()
)
bkgYield_syst = math.sqrt(SRyield.getPropagatedError(frVV) ** 2 + SRyield.getPropagatedError(frTop) ** 2)
bkgYield_stat = math.sqrt(SRyield.getPropagatedError(frMass) ** 2)
bkgYield_alte = abs(bkgYield - bkgYield2) # /bkgYield
bkgYield_eig_norm = RooRealVar("predSR_eig_norm", "expected yield in SR", bkgYield, 0.0, 1.0e6)
print "Events in channel", channel, ": V+jets %.3f (%.1f%%), VV %.3f (%.1f%%), Top %.3f (%.1f%%)" % (
iSRVjet.getVal() * nVjet.getVal(),
fSRVjet.getVal() * 100,
iSRVV.getVal() * nVV.getVal(),
fSRVV.getVal() * 100,
iSRTop.getVal() * nTop.getVal(),
fSRTop.getVal() * 100,
)
print "Events in channel", channel, ": Integral = $%.3f$ & $\pm %.3f$ & $\pm %.3f$ & $\pm %.3f$, observed = %.0f" % (
bkgYield,
bkgYield_stat,
bkgYield_syst,
bkgYield_alte,
setDataSR.sumEntries() if not False else -1,
)
rdataset4fit_mlvj.add(RooArgSet(rrv_mass_lvj),tmp_event_weight/tmp_scale_to_lumi);
### signal over convolution plot
mplot_sig = rrv_mass_lvj.frame(RooFit.Title(""),RooFit.Bins(rrv_mass_lvj.getBins()));
rdataset4fit_mlvj.plotOn(mplot_sig,RooFit.Name("data_invisible"),RooFit.MarkerSize(1.5),RooFit.DataError(RooAbsData.SumW2), RooFit.XErrorSize(0));
doubleCB_sig = ROOT.RooDoubleCrystalBall("DoubleCB_BulkG_WW_mlvj","DoubleCB_BulkG_WW_mlvj",rrv_mass_lvj,rrv_mean_CB,rrv_total_sigma_CB,rrv_alpha1_CB,rrv_n1_CB,rrv_alpha2_CB,rrv_n2_CB);
bw_sig = RooBreitWigner("bw_"+options.channel,"bw_"+options.channel,rrv_mass_lvj,rrv_total_mean_CB,rrv_width_BW);
original_bin = rrv_mass_lvj.getBins();
rrv_mass_lvj.setBins(1000,"cache");
model_pdf_sig = RooFFTConvPdf("sig_xww_%s_%s"%(options.channel,options.category),"sigxww_%s_%s"%(options.channel,options.category),rrv_mass_lvj,bw_sig,doubleCB_sig);
model_pdf_sig.setBufferFraction(1.0);
rrv_mass_lvj.setBins(int(original_bin));
model_pdf_sig.plotOn(mplot_sig,RooFit.Name("total_MC"),RooFit.Normalization((rrv_number_signal.getVal()/tmp_scale_to_lumi)/(6.25*rdataset4fit_mlvj.sumEntries())),RooFit.DrawOption("L"), RooFit.LineColor(kBlue), RooFit.VLines(),RooFit.LineWidth(2),RooFit.LineStyle(1));
mplot_pull = get_pull(rrv_mass_lvj,mplot_sig);
mplot_sig.GetYaxis().SetRangeUser(0.,mplot_sig.GetMaximum()*1.2);
draw_canvas_with_pull(mplot_sig,mplot_pull,"plots_signal_width/","signal_width_plot_%d_W%d"%(mass[iMass],mass[iMass]*gammaVal),"",0);
new_file.Close();
iMass = iMass +1 ;
os.system("rm %s/%s/temp_datacard_list.txt"%(options.inPath,options.datacardPath));
os.system("rm %s/%s/temp_workspace_list.txt"%(options.inPath,options.datacardPath));
dataset.plotOn(myFrame, RooFit.Name('data'))
myPDF.plotOn(myFrame,RooFit.LineColor(2),RooFit.LineWidth(1), RooFit.Name('totModel'))
myFrame.Draw()
canv.SaveAs('tmpLbL0.pdf')
SaveResult(
origPlot=myFrame,
origVar=mass,
data={'content':dataset},
totPDF={'content':myPDF},
fitres=fitres,
label=fitLabel,
fitDir=fitDir,
figDir=figDir,
absNumNormalize=dataset.sumEntries()
)
# fit lbl0Mass in Lb MC end }}}
# fit lbloMass in LbLo MC {{{
if fitToLbMass_LbLoMC:
fitLabel='lbloDist_lbloMC'
mass=space.var('lbl0Mass')
mass.setRange(fitLabel,5.5,5.75)
mass.setBins(50)
inN=inF.Get('nLbL0/LbLo')
dataset=RooDataSet('dataset','dataset',inN,RooArgSet(mass))
def getData(workspace,
mean1 = 1., sigma1 = 0.01,
mean2 = 1., sigma2 = 0.01, nevents = 5000):
## Make a local workspace to use as a factory.
w = RooWorkspace('w', 'w')
## Define the PDF's for m, f1 and f2 in m*sqrt(f1*f2)
mPdf = w.factory("BreitWigner::mPdf(m[50,130], MZ[91.12], GammaZ[2.5])")
f1Pdf = w.factory("Gaussian::f1Pdf(f1[0.5, 2], mean1[%f], sigma1[%f])" %
(mean1, sigma1))
f2Pdf = w.factory("Gaussian::f2Pdf(f2[0.5, 2], mean2[%f], sigma2[%f])" %
(mean2, sigma2))
## Import the PDF's in the given workspace.
workspace.Import(mPdf, RenameAllVariables("True"))
workspace.Import(f1Pdf, RenameAllVariables("True"))
workspace.Import(f2Pdf, RenameAllVariables("True"))
## Generate samples of M, F1 and F2 with a 10% margin for boundaries.
moreEvents = int(2*nevents)
mData = mPdf.generate(RooArgSet(w.var("m")), moreEvents, NumCPU(3))
f1Data = f1Pdf.generate(RooArgSet(w.var("f1")), moreEvents, NumCPU(3))
f2Data = f2Pdf.generate(RooArgSet(w.var("f2")), moreEvents, NumCPU(3))
## Create the new data with toy reco mass
data = RooDataSet('data', 'toy reco Z->ll mass data',
RooArgSet(w.factory('mass[40,140]')))
entry = data.get()
## Loop over the generated values and fill the new reco mass data.
for i in range(moreEvents):
## Do we have enough entries already?
if data.sumEntries() >= nevents:
break
## Get the values of the random variables m, f1, f2.
m = mData.get(i).first().getVal()
f1 = f1Data.get(i).first().getVal()
f2 = f2Data.get(i).first().getVal()
## Here comes the formula!!
mass = m * sqrt(f1*f2)
## Is the reco mass within its range?
if 60. < mass and mass < 120.:
## Add the reco mass to the data
entry.first().setVal(mass)
data.addFast(entry)
## End of loop over the generated values
workspace.Import(data)
return data
