def func_altSP(args):
""" Set fs to 5% instead of 0% """
setupFinalAltSPFitter = deepcopy(fitCollection.setupFinalFitter)
setupFinalAltSPFitter.update({
'argAliasInDB': {'afb': 'afb_altSP', 'fl': 'fl_altSP', 'fs': 'fs_altSP', 'as': 'as_altSP'},
'saveToDB': False,
})
finalAltSPFitter = StdFitter(setupFinalAltSPFitter)
def _preFitSteps_vetoSmallFs_altSP(self):
""" fs is usually negligible, set the alternative fraction to 0.05 """
if "fs" in self.cfg.get('argPattern'):
fs = self.args.find("fs")
transAs = self.args.find("transAs")
fs.setVal(0.05)
fs.setConstant(True)
transAs.setVal(0)
transAs.setConstant(False)
finalAltSPFitter._preFitSteps_vetoSmallFs = types.MethodType(_preFitSteps_vetoSmallFs_altSP, finalAltSPFitter)
p.setSequence([
pdfCollection.stdWspaceReader,
dataCollection.dataReader,
finalAltSPFitter,
])
try:
p.beginSeq()
p.runSeq()
updateToDB_altShape(args, "altSP")
finally:
p.endSeq()
def func_vetoJpsiX(args):
""" Remvoe LSB from Fit region """
dataReaderCfg = deepcopy(dataCollection.dataReaderCfg)
dataReaderCfg.update({
'preloadFile': None
})
dataReader = DataReader(dataReaderCfg)
dataReader.customize = types.MethodType(
functools.partial(dataCollection.customizeOne,
targetBMassRegion=['altFit_vetoJpsiX'],
extraCuts=cut_kshortWindow),
dataReader
)
fitterCfg = deepcopy(fitCollection.setupFinalFitter)
fitterCfg.update({
'data': "dataReader.altFit_vetoJpsiX",
'saveToDB': False
})
fitter = StdFitter(fitterCfg)
p.setSequence([
pdfCollection.stdWspaceReader,
dataReader,
fitter,
])
try:
p.beginSeq()
p.runSeq()
updateToDB_altShape(args, "vetoJpsiX")
finally:
p.endSeq()
def func_simMismodel(args):
p.setSequence([])
try:
p.beginSeq()
db = shelve.open(p.dbplayer.odbfile)
fl_GEN = unboundFlToFl(db['unboundFl_GEN']['getVal'])
fl_RECO = unboundFlToFl(db['unboundFl_RECO']['getVal'])
afb_GEN = unboundAfbToAfb(db['unboundAfb_GEN']['getVal'], fl_GEN)
afb_RECO = unboundAfbToAfb(db['unboundAfb_RECO']['getVal'], fl_RECO)
db.close()
syst_simMismodel = {
'syst_simMismodel_fl': {
'getError': math.fabs(fl_GEN - fl_RECO),
'getErrorHi': math.fabs(fl_GEN - fl_RECO),
'getErrorLo': -math.fabs(fl_GEN - fl_RECO),
},
'syst_simMismodel_afb': {
'getError': math.fabs(afb_GEN - afb_RECO),
'getErrorHi': math.fabs(afb_GEN - afb_RECO),
'getErrorLo': -math.fabs(afb_GEN - afb_RECO),
}
}
print(syst_simMismodel)
if args.updateDB:
FitDBPlayer.UpdateToDB(p.dbplayer.odbfile, syst_simMismodel)
finally:
p.endSeq()
def func_altSigM(args):
""" Not used """
setupFinalAltSigMFitter = deepcopy(fitCollection.setupFinalFitter)
setupFinalAltSigMFitter.update({
'argAliasInDB': {'afb': 'afb_altSigM', 'fl': 'fl_altSigM', 'fs': 'fs_altSigM', 'as': 'as_altSigM'},
'saveToDB': False,
})
finalAltSigMFitter = StdFitter(setupFinalAltSigMFitter)
def _preFitSteps_altSigM(self):
StdFitter._preFitSteps(self)
sigM_frac = self.args.find("sigM_frac")
sigM_frac.setVal(0)
finalAltSigMFitter._preFitSteps = types.MethodType(_preFitSteps_altSigM, finalAltSigMFitter)
p.setSequence([
pdfCollection.stdWspaceReader,
dataCollection.dataReader,
finalAltSigMFitter,
])
try:
p.beginSeq()
p.runSeq()
updateToDB_altShape(args, "altSigM")
finally:
p.endSeq()
def func_altEffi(args):
""" Typically less than 1% """
setupFinalAltEffiFitter = deepcopy(fitCollection.setupFinalFitter)
setupFinalAltEffiFitter.update({
'argAliasInDB': {'afb': 'afb_altEffi', 'fl': 'fl_altEffi', 'fs': 'fs_altEffi', 'as': 'as_altEffi'},
'saveToDB': False,
})
finalAltEffiFitter = StdFitter(setupFinalAltEffiFitter)
def _preFitSteps_altEffi(self):
StdFitter._preFitSteps(self)
hasXTerm = self.args.find("hasXTerm")
hasXTerm.setVal(0)
finalAltEffiFitter._preFitSteps = types.MethodType(_preFitSteps_altEffi, finalAltEffiFitter)
p.setSequence([
pdfCollection.stdWspaceReader,
dataCollection.dataReader,
finalAltEffiFitter,
])
try:
p.beginSeq()
p.runSeq()
updateToDB_altShape(args, "altEffi")
finally:
p.endSeq()
def runSimSequences():
for Year in [2016, 2017, 2018]:
p.cfg['args'].Year = Year
GetInputFiles(p)
sequence = Instantiate(p,
predefined_sequence[args.seqKey][0])
p.setSequence(sequence)
p.beginSeq()
p.runSeq()
p.cfg['args'].Year = args.Year
def func_altBkgCombM(args):
""" Not used """
setupFinalAltBkgCombMFitter = deepcopy(fitCollection.setupFinalFitter)
setupFinalAltBkgCombMFitter.update({
'pdf': "f_finalAltBkgCombM",
'argAliasInDB': {'afb': 'afb_altBkgCombM', 'fl': 'fl_altBkgCombM', 'fs': 'fs_altBkgCombM', 'as': 'as_altBkgCombM'},
'saveToDB': False,
})
finalAltBkgCombMFitter = StdFitter(setupFinalAltBkgCombMFitter)
p.setSequence([
pdfCollection.stdWspaceReader,
dataCollection.dataReader,
finalAltBkgCombMFitter,
])
try:
p.beginSeq()
p.runSeq()
updateToDB_altShape(args, "altBkgCombM")
finally:
p.endSeq()
for Year in [2016, 2017, 2018]:
p.cfg['args'].Year = Year
GetInputFiles(p)
sequence = Instantiate(p,
predefined_sequence[args.seqKey][0])
p.setSequence(sequence)
p.beginSeq()
p.runSeq()
p.cfg['args'].Year = args.Year
if args.SimFit and not (args.Function_name
in ['submit', 'run', 'postproc']):
print("INFO: Processing simultaneously over three year data")
runSimSequences()
sequence = Instantiate(p, predefined_sequence[args.seqKey][1])
p.setSequence(sequence)
p.beginSeq()
elif args.Function_name in ['submit', 'run', 'postproc']:
print("INFO: Processing {0} year data".format(args.Year))
from BsToPhiMuMuFitter.anaSetup import modulePath
if args.seqKey == 'sigMCValidation':
import BsToPhiMuMuFitter.script.batchTask_sigMCValidation as batchTask_sigMCValidation
wrappedTask = batchTask_sigMCValidation.BatchTaskWrapper(
"myBatchTask",
os.path.join(modulePath, "batchTask_sigMCValidation"),
cfg=batchTask_sigMCValidation.setupBatchTask)
elif args.seqKey == 'mixedToyValidation':
import BsToPhiMuMuFitter.script.batchTask_mixedToyValidation as batchTask_mixedToyValidation
wrappedTask = batchTask_mixedToyValidation.BatchTaskWrapper(
"myBatchTask_MixedToy",
os.path.join(modulePath,
ROOT.RooFit.Range("Fit"),
ROOT.RooFit.Components('f_sig3D'))
],
[
"f_final",
plotCollection.plotterCfg_styles['bkgStyleBase'] +
(ROOT.RooFit.ProjectionRange("Fit"),
ROOT.RooFit.Range("Fit"),
ROOT.RooFit.Components('f_bkgComb'))
],
],
'marks':
None,
})
p.setSequence([
dataCollection.dataReader, pdfCollection.stdWspaceReader, profiler,
plotCollection.plotter
])
setupBatchTaskProfile['work_dir'] = profilePoints
setupBatchTaskProfile['nJobs'] = len(profilePoints)
wrappedTask = BatchTaskWrapperProfile("myBatchTask",
"{0}".format(task_dir),
cfg=setupBatchTaskProfile)
elif args.Function_name in ["submit", "run"]:
p.setSequence([
pdfCollection.stdWspaceReader,
toyCollection.sigToyGenerator,
toyCollection.bkgCombToyGenerator,
profiledFCToyStudier,
])
setupBatchTask['nJobs'] = len(profilePoints)
wrappedTask = BatchTaskWrapper("myBatchTask",
def func_randEffi(args):
""" Typically less than 5% """
setupFinalRandEffiFitter = deepcopy(fitCollection.setupFinalFitter)
setupFinalRandEffiFitter.update({
'FitMinos': [False, ()],
'argAliasInDB': {'afb': 'afb_randEffi', 'fl': 'fl_randEffi', 'fs': 'fs_randEffi', 'as': 'as_randEffi'},
'saveToDB': False,
})
finalRandEffiFitter = StdFitter(setupFinalRandEffiFitter)
def preFitSteps_randEffi(self):
self.args = self.pdf.getParameters(self.data)
self._preFitSteps_initFromDB()
# Fluctuate cross-term correction
effiArgs = ROOT.RooArgSet()
FitterCore.ArgLooper(self.args, lambda iArg: effiArgs.add(iArg), targetArgs=[r"x\d{1,2}"])
FitDBPlayer.fluctuateFromDB(self.process.dbplayer.odbfile, effiArgs, self.cfg['argAliasInDB'])
self._preFitSteps_vetoSmallFs()
self._preFitSteps_preFit()
finalRandEffiFitter._preFitSteps = types.MethodType(preFitSteps_randEffi, finalRandEffiFitter)
foutName = "syst_randEffi_{0}.root".format(q2bins[args.binKey]['label'])
class effiStudier(AbsToyStudier):
def _preSetsLoop(self):
self.hist_afb = ROOT.TH1F("hist_afb", "", 300, -0.75, 0.75)
self.hist_afb.GetXaxis().SetTitle("A_{{FB}}")
self.hist_fl = ROOT.TH1F("hist_fl", "", 200, 0., 1.)
self.hist_fl.GetXaxis().SetTitle("F_{{L}}")
def _preRunFitSteps(self, setIndex):
pass
def _postRunFitSteps(self, setIndex):
if self.fitter.fitResult["{0}.migrad".format(self.fitter.name)]['status'] == 0:
afb = self.process.sourcemanager.get('afb')
fl = self.process.sourcemanager.get('fl')
self.hist_afb.Fill(afb.getVal())
self.hist_fl.Fill(fl.getVal())
def _postSetsLoop(self):
fout = ROOT.TFile(foutName, "RECREATE")
fout.cd()
self.hist_afb.Write()
self.hist_fl.Write()
fout.Close()
def getSubDataEntries(self, setIndex):
return 1
def getSubData(self):
while True:
yield self.data
setupStudier = deepcopy(effiStudier.templateConfig())
setupStudier.update({
'name': "effiStudier",
'data': "dataReader.Fit",
'fitter': finalRandEffiFitter,
'nSetOfToys': 200,
})
studier = effiStudier(setupStudier)
p.setSequence([
pdfCollection.stdWspaceReader,
dataCollection.dataReader,
studier,
])
try:
p.beginSeq()
if os.path.exists("{0}".format(foutName)):
print("{0} exists, skip fitting procedure".format(foutName))
else:
p.runSeq()
fin = ROOT.TFile("{0}".format(foutName))
hist_fl = fin.Get("hist_fl")
gaus_fl = ROOT.TF1("gaus_fl", "gaus(0)", 0, 1)
hist_fl.Fit(gaus_fl, "WI")
hist_afb = fin.Get("hist_afb")
gaus_afb = ROOT.TF1("gaus_afb", "gaus(0)", -0.75, 0.75)
hist_afb.Fit(gaus_afb, "WI")
syst_randEffi = {
'syst_randEffi_fl': {
'getError': gaus_fl.GetParameter(2),
'getErrorHi': gaus_fl.GetParameter(2),
'getErrorLo': -gaus_fl.GetParameter(2),
},
'syst_randEffi_afb': {
'getError': gaus_afb.GetParameter(2),
'getErrorHi': gaus_afb.GetParameter(2),
'getErrorLo': -gaus_afb.GetParameter(2),
}
}
print(syst_randEffi)
if args.updatePlot:
canvas = Plotter.canvas.cd()
hist_afb.Draw("HIST")
Plotter.latexCMSMark()
Plotter.latexCMSExtra()
Plotter.latexCMSSim()
canvas.Print("syst_randEffi_afb_{0}.pdf".format(q2bins[args.binKey]['label']))
hist_fl.GetXaxis().SetTitle("F_{{L}}")
hist_fl.Draw("HIST")
Plotter.latexCMSMark()
Plotter.latexCMSExtra()
Plotter.latexCMSSim()
canvas.Print("syst_randEffi_fl_{0}.pdf".format(q2bins[args.binKey]['label']))
if args.updateDB:
FitDBPlayer.UpdateToDB(p.dbplayer.odbfile, syst_randEffi)
finally:
p.endSeq()
# plotterCfg['switchPlots'].append('angular3D_sigM')
# plotterCfg['switchPlots'].append('angular3D_bkgCombA')
# plotterCfg['switchPlots'].append('angular3D_final')
# plotterCfg['switchPlots'].append('angular3D_summary')
# plotterCfg['switchPlots'].append('angular2D_summary_RECO2GEN')
plotter = Plotter(plotterCfg)
if __name__ == '__main__':
binKey = [
'summaryLowQ2'
] #, 'belowJpsiB', 'belowJpsiC', 'betweenPeaks', 'abovePsi2sA', 'abovePsi2sB', 'summary', 'summaryLowQ2']
for b in binKey:
p.cfg['binKey'] = b
print(p.cfg)
# plotter.cfg['switchPlots'].append('simpleSpectrum')
plotter.cfg['switchPlots'].append('effi')
# plotter.cfg['switchPlots'].append('angular3D_sigM')
# plotter.cfg['switchPlots'].append('angular3D_bkgCombA')
# plotter.cfg['switchPlots'].append('angular3D_final')
# plotter.cfg['switchPlots'].append('angular3D_summary')
# plotter.cfg['switchPlots'].append('angular2D_summary_RECO2GEN')
p.setSequence([
dataCollection.effiHistReader, dataCollection.sigMCReader,
dataCollection.dataReader, pdfCollection.stdWspaceReader, plotter
])
p.beginSeq()
p.runSeq()
p.endSeq()
'argAliasInDB': {
**ArgAliasGEN
},
'LegName':
'Data',
'argAliasSaveToDB':
False,
'fitToCmds': [
[
ROOT.RooFit.Strategy(3),
ROOT.RooFit.InitialHesse(0),
ROOT.RooFit.Minimizer('Minuit2', 'migrad'),
ROOT.RooFit.Minos(0)
],
],
})
SimultaneousFitter_mixedToyValidation = SimultaneousFitter(
Simul_mixedToyValidation_setup)
if __name__ == '__main__':
p.setSequence([
dataCollection.effiHistReader, pdfCollection.stdWspaceReader,
effiFitter
])
# p.setSequence([dataCollection.sigMCReader, pdfCollection.stdWspaceReader, sigMFitter])
# p.setSequence([dataCollection.sigMCReader, pdfCollection.stdWspaceReader, sig2DFitter])
# p.setSequence([dataCollection.dataReader, pdfCollection.stdWspaceReader, bkgCombAFitter])
p.beginSeq()
p.runSeq()
p.endSeq()
]
# For fitter validation and syst
predefined_sequence['fitSig2D'] = [
dataCollection.sigMCReader, pdfCollection.stdWspaceReader,
fitCollection.sig2DFitter
]
predefined_sequence['fitSigMCGEN'] = [
dataCollection.sigMCGENReader, pdfCollection.stdWspaceReader,
fitCollection.sigAFitter
]
if __name__ == '__main__':
# binKey = ['belowJpsiA', 'belowJpsiB', 'belowJpsiC', 'betweenPeaks', 'abovePsi2sA', 'abovePsi2sB', 'summary', 'summaryLowQ2']
binKey = ['belowJpsiC']
for b in binKey:
p.cfg['binKey'] = b
# p.setSequence(predefined_sequence['buildEfficiecyHist'])
p.setSequence(predefined_sequence['fitEfficiency'])
# p.setSequence(predefined_sequence['fitBkgCombA'])
# p.setSequence(predefined_sequence['fitFinal3D'])
# p.setSequence(predefined_sequence['stdFit'])
# p.setSequence(predefined_sequence['fitSig2D'])
# p.setSequence(predefined_sequence['fitSigMCGEN'])
try:
p.beginSeq()
p.runSeq()
finally:
p.endSeq()
def bkgCombToyGenerator_customize(self):
pass
bkgCombToyGenerator.customize = types.MethodType(bkgCombToyGenerator_customize, bkgCombToyGenerator)
# Systematics
# sigAToyGenerator - systematics
setupSigAToyGenerator = deepcopy(CFG)
setupSigAToyGenerator.update({
'name': "sigAToyGenerator",
'pdf': "f_sigA",
'argAliasInDB': setupSigAFitter['argAliasInDB'],
'saveAs': "sigAToyGenerator.root",
})
sigAToyGenerator = ToyGenerator(setupSigAToyGenerator)
@decorator_setExpectedEvents(["nSig"])
@decorator_initParameters
def sigAToyGenerator_customize(self):
pass
sigAToyGenerator.customize = types.MethodType(sigAToyGenerator_customize, sigAToyGenerator)
if __name__ == '__main__':
try:
p.setSequence([pdfCollection.stdWspaceReader, sigToyGenerator])
# p.setSequence([pdfCollection.stdWspaceReader, bkgCombToyGenerator])
p.beginSeq()
p.runSeq()
p.sourcemanager.get('ToyGenerator.mixedToy').Print()
finally:
p.endSeq()
h2_accXrec.SetBinContent(iL, iK, h2_acc.GetEfficiency(iLK) * h2_rec.GetEfficiency(iLK))
h2_accXrec.SetBinError(iL, iK, h2_accXrec.GetBinContent(iL, iK) * math.sqrt(1 / h2_acc.GetTotalHistogram().GetBinContent(iLK) + 1 / h2_acc.GetPassedHistogram().GetBinContent(iLK) + 1 / h2_rec.GetTotalHistogram().GetBinContent(iLK) + 1 / h2_rec.GetPassedHistogram().GetBinContent(iLK)))
h2_accXrec.SetXTitle("cos#theta_{l}")
h2_accXrec.SetYTitle("cos#theta_{K}")
h2_accXrec.SetZTitle("Overall efficiency")
h2_accXrec.Write("h2_accXrec_{0}".format(binKey), ROOT.TObject.kOverwrite)
self.logger.logINFO("Overall efficiency is built.")
# Register the chosen one to sourcemanager
h2_accXrec = fin.Get("h2_accXrec_{0}".format(self.process.cfg['binKey']))
self.cfg['source']['effiHistReader.h2_accXrec'] = h2_accXrec
self.cfg['source']['effiHistReader.accXrec'] = RooDataHist("accXrec", "", RooArgList(CosThetaL, CosThetaK), ROOT.RooFit.Import(h2_accXrec))
self.cfg['source']['effiHistReader.h_accXrec_fine_ProjectionX'] = fin.Get("h_accXrec_{0}_ProjectionX".format(self.process.cfg['binKey']))
self.cfg['source']['effiHistReader.h_accXrec_fine_ProjectionY'] = fin.Get("h_accXrec_{0}_ProjectionY".format(self.process.cfg['binKey']))
effiHistReader = ObjProvider({
'name': "effiHistReader",
'obj': {
'effiHistReader.h2_accXrec': [buildAccXRecEffiHist, ],
}
})
if __name__ == '__main__':
# p.setSequence([dataReader])
# p.setSequence([sigMCReader])
p.setSequence([effiHistReader])
p.beginSeq()
p.runSeq()
p.endSeq()
('f_sigA', [buildSigA]),
('f_sigM', [buildSigM]),
('f_sig3D', [buildSig]), # Include f_sig2D
('f_bkgCombA', [buildAnalyticBkgCombA]),
('f_bkgCombAAltA', [buildSmoothBkgCombA]),
('f_bkgCombM', [buildBkgCombM]),
('f_bkgCombMAltM', [buildBkgCombMAltM]),
('f_bkgComb', [buildBkgComb]), # Include all variations
('f_final', [buildFinal]), # Include all variations
])
})
stdPDFBuilder.customize = types.MethodType(customizePDFBuilder, stdPDFBuilder)
if __name__ == '__main__':
# binKey = ['belowJpsiA', 'belowJpsiB', 'belowJpsiC', 'betweenPeaks', 'abovePsi2sA','abovePsi2sB', 'summary', 'summaryLowQ2']
binKey = ['betweenPeaks']
for b in binKey:
p.cfg['binKey'] = b
p.setSequence(
[dataCollection.dataReader, stdWspaceReader, stdPDFBuilder])
p.beginSeq()
p.runSeq()
p.endSeq()
# p.reset()
dataCollection.dataReader.reset()
stdWspaceReader.reset()
stdPDFBuilder.reset()
plotCollection.plotterCfg_sigStyle, None, "Signal"
],
[
"f_final", (ROOT.RooFit.Components('f_bkgComb'), ) +
plotCollection.plotterCfg_bkgStyle, None, "Background"
],
],
'marks': ['toy'],
})
plotCollection.plotter.cfg['switchPlots'] = [
'simpleBLK',
]
p.setSequence([
pdfCollection.stdWspaceReader, toyCollection.sigToyGenerator,
toyCollection.bkgCombToyGenerator, fitCollection.finalFitter,
plotCollection.plotter
])
wrappedTask = BatchTaskWrapper(
"myBatchTask",
"/afs/cern.ch/work/p/pchen/public/BuToKstarMuMu/v2Fitter/BsToPhiMuMuFitter/batchTask_simpleToyValidation",
cfg=setupBatchTask)
elif args.Function_name in ['run_summary', 'submit_summary']:
plotCollection.plotter.cfg['plots']['angular3D_summary']['kwargs'][
'drawSM'] = False
plotCollection.plotter.cfg['plots']['angular3D_summary']['kwargs'][
'dbSetup'] = [{
'title': "Toy Data",
'dbPat': "fitResults_{binLabel}.db",
'legendOpt': "LPE"
}]
