kfactor updates

NanoAnalysis/python/nanoZZ4lAnalysis.py

@@ -46,16 +46,22 @@
 MUON_ID_BYMVA = getConf("MUON_ID_BYMVA", False) # if false - standard selection for muons ; if true - new WP (Muon_mvalowPt > -0.6, sip < 8, no iso)
 # ggH NNLOPS weight
 APPLY_QCD_GGF_UNCERT = getConf("APPLY_QCD_GGF_UNCERT", False)
-# K factors for ggZZ (and old NLO ggH samples) 0:None; 1: NNLO/LO; 2: NNLO/NLO; 3: NLO/LO
+# K factors for ggZZ (and old NLO ggH samples) 0:None; 1: NNLO/LO; 2: NNLO/NLO
 APPLY_K_NNLOQCD_ZZGG = getConf("APPLY_K_NNLOQCD_ZZGG", 0)
 # K factors for qqZZ
-APPLY_K_NNLOQCD_ZZQQB = getConf("APPLY_K_NNLOQCD_ZZQQB", False)
-APPLY_K_NNLOEW_ZZQQB  = getConf("APPLY_K_NNLOEW_ZZQQB", False)
+APPLY_K_NNLOQCD_NLOEW_ZZQQB = getConf("APPLY_K_NNLOQCD_NLOEW_ZZQQB", False)
+if getConf("APPLY_K_NNLOQCD_ZZQQB") or getConf("APPLY_K_NLOEW_ZZQQB"): 
+   print("ERROR: flags 'APPLY_K_NNLOQCD_ZZQQB' and 'APPLY_K_NLOEW_ZZQQB' no longer supported")
+   print("Please use the new all-encompassing flag 'APPLY_K_NNLOQCD_NLOEW_ZZQQB'")
+   exit(1)
 # Add separate tree with gen info for all events
 
 IsSIGNAL = getConf("IsSIGNAL", False)
 ADD_ALLEVENTS = getConf("ADD_ALLEVENTS", IsSIGNAL) # if true, add a separate tree with gen-level variables for all events (not just those passing the candidate selection); by default, this is done for signal samples
-ADD_LHE_PROB = getConf("ADD_LHE_PROB", ADD_ALLEVENTS) # Add LHE angles and probabilities. This is in general the case whenever ADD_ALLEVENTS is true (ie for signals)
+
+# Add LHE angles and probabilities. This is in general the case whenever ADD_ALLEVENTS is true (ie for signals)
+# This is also generally true when APPLY_K_NNLOQCD_NLOEW_ZZQQB is applied
+ADD_LHE_PROB = getConf("ADD_LHE_PROB", ADD_ALLEVENTS or APPLY_K_NNLOQCD_NLOEW_ZZQQB)
 JES_SPLITTING = getConf("JES_SPLITTING", True) # Whether to split JES variations into 11 components (if false, only up/down variations are produced, by summing all components in quadrature)
 
 FILTER_EVENTS = getConf("FILTER_EVENTS", 'Cands') # Filter to be applied on events. Currently supported:
@@ -250,7 +256,7 @@
 
     # Weights computation, to be placed in pre or post sequences based on the configuration
     from ZZAnalysis.NanoAnalysis.weightFiller import weightFiller
-    weights = weightFiller(XSEC, APPLY_K_NNLOQCD_ZZGG, APPLY_K_NNLOQCD_ZZQQB, APPLY_K_NNLOEW_ZZQQB, APPLY_QCD_GGF_UNCERT, LEPTON_SETUP)
+    weights = weightFiller(XSEC, APPLY_K_NNLOQCD_ZZGG, APPLY_K_NNLOQCD_NLOEW_ZZQQB, APPLY_QCD_GGF_UNCERT, LEPTON_SETUP)
 
     #Protect against writing a bunch of 1's. 
     if (genXS != 1) and (genBR != 1): 

NanoAnalysis/python/weightFiller.py

@@ -7,45 +7,70 @@
 import os
 import ROOT
 ROOT.PyConfig.IgnoreCommandLineOptions = True
+import h5py
+import scipy.interpolate as interp
 
 class weightFiller(Module):
-    def __init__(self, XS, APPLY_K_NNLOQCD_ZZGG, APPLY_K_NNLOQCD_ZZQQB, APPLY_K_NNLOEW_ZZQQB, APPLY_QCD_GGF_UNCERT, LEPTON_SETUP):
-        print("***weightFiller: XS:", XS, "K_NNLOQCD_ZZGG:", APPLY_K_NNLOQCD_ZZGG, "K_NNLOQCD_ZZQQB:", APPLY_K_NNLOQCD_ZZQQB, "GGF_NNLO_W:", APPLY_QCD_GGF_UNCERT, flush=True)
+    def __init__(self, XS, APPLY_K_NNLOQCD_ZZGG, APPLY_K_NNLOQCD_NLOEW_ZZQQB, APPLY_QCD_GGF_UNCERT, LEPTON_SETUP):
+        print(
+            "***weightFiller: XS:", XS, 
+            "APPLY_K_NNLOQCD_NLOEW_ZZQQB:", APPLY_K_NNLOQCD_ZZGG, 
+            "APPLY_QCD_GGF_UNCERT:", APPLY_QCD_GGF_UNCERT, 
+            flush=True
+        )
         self.writeHistFile = False
         self.XS = XS
         self.APPLY_K_NNLOQCD_ZZGG = APPLY_K_NNLOQCD_ZZGG
-        self.APPLY_K_NNLOQCD_ZZQQB = APPLY_K_NNLOQCD_ZZQQB
-        self.APPLY_K_NNLOEW_ZZQQB = APPLY_K_NNLOEW_ZZQQB
+        self.APPLY_K_NNLOQCD_NLOEW_ZZQQB = APPLY_K_NNLOQCD_NLOEW_ZZQQB
         self.APPLY_QCD_GGF_UNCERT = APPLY_QCD_GGF_UNCERT
         self.LEPTON_SETUP = LEPTON_SETUP
 
-        basePath='%s/src/ZZAnalysis/AnalysisStep/' % os.environ['CMSSW_BASE']
-
-        ## ggZZ QCD k-factors
-        self.spkfactor_ggzz_nnlo = [None]*9
-        self.spkfactor_ggzz_nlo  = [None]*9
-        if self.APPLY_K_NNLOQCD_ZZGG != 0 :            
-            strZZGGKFVar = ["Nominal", "PDFScaleDn", "PDFScaleUp", "QCDScaleDn", "QCDScaleUp", "AsDn", "AsUp", "PDFReplicaDn", "PDFReplicaUp"]
-            # NNLO
-            ggZZKFactorFile = ROOT.TFile.Open(basePath+'data/kfactors/Kfactor_Collected_ggHZZ_2l2l_NNLO_NNPDF_NarrowWidth_13TeV.root')
-            for i in range(0,9) :
-                 for i in range(0,9) :
-                     self.spkfactor_ggzz_nnlo[i] = (ggZZKFactorFile.Get('sp_kfactor_%s' % strZZGGKFVar[i])).Clone('sp_kfactor_%s_NNLO' % strZZGGKFVar[i])
-            ggZZKFactorFile.Close()
-            # NLO
-            ggZZKFactorFile = ROOT.TFile.Open(basePath+'data/kfactors/Kfactor_Collected_ggHZZ_2l2l_NLO_NNPDF_NarrowWidth_13TeV.root')
-            for i in range(0,9) :
-                 for i in range(0,9) :
-                     self.spkfactor_ggzz_nlo[i] = (ggZZKFactorFile.Get('sp_kfactor_%s' % strZZGGKFVar[i])).Clone('sp_kfactor_%s_NNLO' % strZZGGKFVar[i])
-            ggZZKFactorFile.Close()
-
-        if self.APPLY_K_NNLOEW_ZZQQB :
-            #FIXME: TO BE IMPLEMENTED
-            #ewkTable = EwkCorrections::readFile_and_loadEwkTable(basePath+'data/kfactors/ZZ_EwkCorrections.dat')
-            pass
+        # Just use the lepton setup as an analog for the run number
+        if LEPTON_SETUP in (2016, 2017, 2018):
+            run_number = 2
+        elif LEPTON_SETUP in (2022, 2023, 2024, 2025):
+            run_number = 3
+
+        basePath_nano=f'{os.environ['CMSSW_BASE']}/src/ZZAnalysis/NanoAnalysis/data/kFactors'
+
+        if self.APPLY_K_NNLOQCD_ZZGG in (1,2):
+            ## ggZZ QCD k-factors
+            self.spkfactor_ggzz = [None]*4
+
+            #Apart from the nominal case, the other 3 are simply up and down factors
+            strZZGGKFVar = ["nominal", "PDF", "PDF_aS", "QCD_mu"]
+            if self.APPLY_K_NNLOQCD_ZZGG == 1:
+                raw_dat = h5py.File(f"{basePath_nano}/gluonFusion/Run{run_number}-NNLO.h5")
+            elif self.APPLY_K_NNLOQCD_ZZGG == 2:
+                raw_dat = h5py.File(f"{basePath_nano}/gluonFusion/Run{run_number}-NLO-NNLO.h5")
+
+            for i, var in enumerate(strZZGGKFVar):
+                self.spkfactor_ggzz[i] = interp.make_interp_spline(
+                    raw_dat['hmass'], raw_dat[var], k=1
+                )
+            raw_dat.close()
+            del raw_dat
+        elif self.APPLY_K_NNLOQCD_ZZGG != 0:
+            print ("Unsupported: APPLY_K_NNLOQCD_ZZGG=", self.APPLY_K_NNLOQCD_ZZGG)
+            print ("Supported values are: 0 (do not apply), 1 (LO to NNLO), 2 (NLO to NNLO)")
+            exit(1)
+
+        if self.APPLY_K_NNLOQCD_NLOEW_ZZQQB :
+            strQQZZKFVar = ["nominal", "QCD_up", "QCD_dn", "EW_factor", "smoothing_factor"]
+            self.spkfactor_qqzz = [[None]*len(strQQZZKFVar)]*4
+            for i in range(4):
+                #cos(theta^*) is symmetric around 0, but
+                #the actual files go from -1 to 0, so just reverse them for aesthetic reasons
+                with h5py.File(f"{basePath_nano}/qqBarToZZ/Run{run_number}/kfac_m4l__cos{3-i}.h5") as raw_dat:
+                    for j, var in enumerate(strQQZZKFVar):
+                        self.spkfactor_qqzz[i][j] = interp.make_interp_spline(
+                            raw_dat['zzmass'], raw_dat[var], k=1
+                        )
+                del raw_dat
 
         # ggH NNLOPS weights
         if self.APPLY_QCD_GGF_UNCERT :
+            basePath = f'{os.environ['CMSSW_BASE']}/src/ZZAnalysis/AnalysisStep/'
             if self.LEPTON_SETUP >= 2022:
                 NNLOPS_weight_file = ROOT.TFile.Open(basePath+'data/ggH_NNLOPS_Weights/NNLOPS_reweight_13p6.root')
             else:
@@ -56,65 +81,77 @@ def __init__(self, XS, APPLY_K_NNLOQCD_ZZGG, APPLY_K_NNLOQCD_ZZQQB, APPLY_K_NNLO
             self.gr_NNLOPSratio_pt_powheg_3jet = NNLOPS_weight_file.Get("gr_NNLOPSratio_pt_powheg_3jet")
 
 
-    ### Imported from: https://github.com/CJLST/ZZAnalysis/blob/Run2_CutBased_UL/AnalysisStep/test/Ntuplizers/HZZ4lNtupleMaker.cc#L1950
-    def evalSpline(self, sp, xval):
-        xmin = sp.GetXmin()
-        xmax = sp.GetXmax()
-        res = 0.
-        if xval<xmin :
-            res=sp.Eval(xmin)
-            deriv=sp.Derivative(xmin)
-            res += deriv*(xval-xmin)
-        elif (xval>xmax) :
-            res=sp.Eval(xmax)
-            deriv=sp.Derivative(xmax)
-            res += deriv*(xval-xmax)
-        else :
-            res=sp.Eval(xval)
-        return res
-
+    def evalSpline(self, cStar, zzMass, j):
+        cStar = abs(cStar)
+        if cStar < 0.25:
+            i = 0
+        elif cStar < 0.5:
+            i = 1
+        elif cStar < 0.75:
+            i = 2
+        else:
+            i = 3
+        return self.spkfactor_qqzz[i][j](zzMass)
+
 
     def beginFile(self, inputFile, outputFile, inputTree, wrappedOutputTree):
         self.out = wrappedOutputTree
-        if self.APPLY_K_NNLOQCD_ZZQQB :
-           self.out.branch("KFactor_QCD_qqZZ_M_Weight", "F", title="QCD k-factor for qqZZ")
         if self.APPLY_K_NNLOQCD_ZZGG > 0 :
             self.out.branch("KFactor_QCD_ggZZ_Nominal_Weight", "F", title="QCD k-factor for ggZZ")
-        if self.APPLY_K_NNLOEW_ZZQQB :
-            self.out.branch("KFactor_EW_qqZZ_Weight", "F", title="EW k-factor for qqZZ")
+            self.out.branch("KFactor_QCD_ggZZ_PDF_Factor", "F", title="Multiplicative factor for PDF variation")
+            self.out.branch("KFactor_QCD_ggZZ_QCD_Factor", "F", title="Multiplicative factor for QCD variation")
+            self.out.branch("KFactor_QCD_ggZZ_aS_Factor", "F", title="Multiplicative factor for aS variation")
+        if self.APPLY_K_NNLOQCD_NLOEW_ZZQQB :
+            self.out.branch("KFactor_qqZZ_Nominal_Weight", "F", title="Combined EW/QCD k-factor for qqZZ, with proper treatment of EW=1 below 2mZ")
+            self.out.branch("KFactor_qqZZ_QCDup_Factor", "F", title="Multiplicative factor for QCD_up variation")
+            self.out.branch("KFactor_qqZZ_QCDdn_Factor", "F", title="Multiplicative factor for QCD_down variation")
+            self.out.branch("KFactor_qqZZ_EW_Factor", "F", title="Multiplicative factor for EW factorization variation")
+            self.out.branch("KFactor_qqZZ_smooth_Factor", "F", title="Multiplicative factor for EW smoothing variation")
         if self.APPLY_QCD_GGF_UNCERT :
             self.out.branch("ggH_NNLOPS_Weight", "F", title="Reweighting for ggH as a function of njets and pT")
 
 
         self.out.branch("overallEventWeight", "F", title="Event weight: Generator_weight*XS*puWeight*(relevant k-factors where applicable). Must be normalized by sum of genEventSumw in the Runs tree")
 
     def analyze(self, event):
-        KFactor_EW_qqZZ =1.        
-        KFactor_QCD_qqZZ_M = 1.
+        KFactor_ZZQQB_Nominal = 1.
+        KFactor_ZZQQB_QCD_up = 1.
+        KFactor_ZZQQB_QCD_dn = 1.
+        KFactor_ZZQQB_EW_factor = 1.
+        KFactor_ZZQQB_smooth_factor = 1.
+    ############ GLUON FUSION KFACTOR VALUES ##########
         KFactor_QCD_ggZZ_Nominal = 1.
+        KFactor_QCD_ggZZ_PDF = 1.
+        KFactor_QCD_ggZZ_aS = 1.
+        KFactor_QCD_ggZZ_QCD = 1.
+
         ggH_NNLOPS_Weight = 1.
 
         ### QCD weights for ggH, ggZZ
-        if self.APPLY_K_NNLOQCD_ZZGG == 1 or self.APPLY_K_NNLOQCD_ZZGG == 2 :
-            KFactor_QCD_ggZZ_Nominal = self.evalSpline(self.spkfactor_ggzz_nnlo[0], event.GenZZ_mass) #1: NNLO/LO
-            if self.APPLY_K_NNLOQCD_ZZGG == 2 : # 2:NNLO/NLO
-                denominator = self.evalSpline(self.spkfactor_ggzz_nlo[0], event.GenZZ_mass)
-                KFactor_QCD_ggZZ_Nominal /= denominator
-        elif self.APPLY_K_NNLOQCD_ZZGG == 3 :# 2:NLO/LO
-            KFactor_QCD_ggZZ_Nominal = self.evalSpline(self.spkfactor_ggzz_nlo[0], event.GenZZ_mass)
-        elif self.APPLY_K_NNLOQCD_ZZGG !=0 :
-            print ("Unsupported: APPLY_K_NNLOQCD_ZZGG=", self.APPLY_K_NNLOQCD_ZZGG) 
-            exit(1)
-
-        ### QCD and EW weights for qqZZ
-        if self.APPLY_K_NNLOQCD_ZZQQB :
-            flavor = 1 # same Z flavors
-            if event.GenZZ_FinalState == 14641 or event.GenZZ_FinalState == 28561 or event.GenZZ_FinalState == 50625 :
-                flavor = 2 # differenr Z flavors
-            KFactor_QCD_qqZZ_M = ROOT.KFactors.kfactor_qqZZ_qcd_M(event.GenZZ_mass, flavor, 2)/ROOT.KFactors.kfactor_qqZZ_qcd_M(event.GenZZ_mass, flavor, 1)
+        if self.APPLY_K_NNLOQCD_ZZGG :
+            KFactor_QCD_ggZZ_Nominal = self.spkfactor_ggzz[0](event.GenZZ_mass)
+
+            KFactor_QCD_ggZZ_PDF = self.spkfactor_ggzz[1](event.GenZZ_mass)
+            KFactor_QCD_ggZZ_aS = self.spkfactor_ggzz[2](event.GenZZ_mass)
+            KFactor_QCD_ggZZ_QCD = self.spkfactor_ggzz[3](event.GenZZ_mass)
+
+        if self.APPLY_K_NNLOQCD_NLOEW_ZZQQB:
+            KFactor_ZZQQB_Nominal = self.evalSpline(
+                event.LHEMela_costhetastar,event.GenZZ_mass, 0
+            )
+            KFactor_ZZQQB_QCD_up = self.evalSpline(
+                event.LHEMela_costhetastar,event.GenZZ_mass, 1
+            )
+            KFactor_ZZQQB_QCD_dn = self.evalSpline(
+                event.LHEMela_costhetastar,event.GenZZ_mass, 2
+            )
+            KFactor_ZZQQB_EW_factor = self.evalSpline(
+                event.LHEMela_costhetastar,event.GenZZ_mass, 3
+            )
+            KFactor_ZZQQB_smooth_factor = self.evalSpline(
+                event.LHEMela_costhetastar,event.GenZZ_mass, 4
+            )
 
-        if self.APPLY_K_NNLOEW_ZZQQB :
-            KFactor_EW_qqZZ = 1 #FIXME: this is 1 up to 2*mZ. To be implemented for higher masses.
 
         if self.APPLY_QCD_GGF_UNCERT :
             htxsNJets = event.HTXS_njets30
@@ -135,14 +172,22 @@ def analyze(self, event):
         # L1prefiringWeightDn = event.L1PreFiringWeight_Dn
 
         #FIXME: event.ZZ_dataMCWeight is not included, since that can be stored per-candidate if storeAllCands=True.
-        w_total = self.XS * event.Generator_weight * event.puWeight * KFactor_EW_qqZZ * KFactor_QCD_ggZZ_Nominal * KFactor_QCD_qqZZ_M * ggH_NNLOPS_Weight
+        w_total = self.XS * event.Generator_weight * event.puWeight * KFactor_ZZQQB_Nominal * KFactor_QCD_ggZZ_Nominal * ggH_NNLOPS_Weight
 
-        if self.APPLY_K_NNLOQCD_ZZQQB :
-            self.out.fillBranch("KFactor_QCD_qqZZ_M_Weight", KFactor_QCD_qqZZ_M)
-        if self.APPLY_K_NNLOQCD_ZZGG > 0 : 
+        if self.APPLY_K_NNLOQCD_ZZGG : 
             self.out.fillBranch("KFactor_QCD_ggZZ_Nominal_Weight", KFactor_QCD_ggZZ_Nominal)
-        if self.APPLY_K_NNLOEW_ZZQQB :
-            self.out.fillBranch("KFactor_EW_qqZZ_Weight", KFactor_EW_qqZZ)
+            #For systematic variations, multiply w_total by either (1+factor) or (1-factor)
+            self.out.fillBranch("KFactor_QCD_ggZZ_PDF_Factor", KFactor_QCD_ggZZ_PDF)
+            self.out.fillBranch("KFactor_QCD_ggZZ_aS_Factor", KFactor_QCD_ggZZ_aS)
+            self.out.fillBranch("KFactor_QCD_ggZZ_QCD_Factor", KFactor_QCD_ggZZ_QCD)
+        if self.APPLY_K_NNLOQCD_NLOEW_ZZQQB :
+            self.out.fillBranch("KFactor_qqZZ_Nominal_Weight", KFactor_ZZQQB_Nominal)
+            #for QCD variations multiply w_total by factor up or down
+            self.out.fillBranch("KFactor_qqZZ_QCDup_Factor", KFactor_ZZQQB_QCD_up)
+            self.out.fillBranch("KFactor_qqZZ_QCDdn_Factor", KFactor_ZZQQB_QCD_dn)
+            #for these variations multiply w_total by (1+factor) or (1-factor)
+            self.out.fillBranch("KFactor_qqZZ_EW_Factor", KFactor_ZZQQB_EW_factor)
+            self.out.fillBranch("KFactor_qqZZ_smooth_Factor", KFactor_ZZQQB_smooth_factor)
         if self.APPLY_QCD_GGF_UNCERT :
             self.out.fillBranch("ggH_NNLOPS_Weight", ggH_NNLOPS_Weight)
 

NanoAnalysis/test/prod/Run2_v9/samplesNano_2018preUL_MC.csv

@@ -25,8 +25,8 @@ ggH3000,,0.00101,3.33E-03,, /GluGluHToZZTo4L_M3000_13TeV_powheg2_JHUGenV7011_pyt
 
 
 ###,,,,,,,,,,,qq->ZZ background
-ZZTo4lext1,,1.256,  ,,/ZZTo4L_TuneCP5_13TeV_powheg_pythia8/RunIIAutumn18NanoAODv7-Nano02Apr2020_102X_upgrade2018_realistic_v21_ext1-v1/NANOAODSIM,dbs,/eos/cms,3,GENXSEC=1.256;GENBR=1;PROCESS_CR=True;APPLY_K_NNLOQCD_ZZQQB=True;APPLY_K_NLOEW_ZZQQB=True;NANOVERSION=7;LEPTON_SETUP=2018,,
-##ZZTo4lext2,,1.256, ,,/ZZTo4L_TuneCP5_13TeV_powheg_pythia8/RunIIAutumn18NanoAODv7-Nano02Apr2020_102X_upgrade2018_realistic_v21_ext2-v1/NANOAODSIM,dbs,root://cms-xrd-global.cern.ch/,3,GENXSEC=1.256;GENBR=1;PROCESS_CR=True;APPLY_K_NNLOQCD_ZZQQB=True;APPLY_K_NLOEW_ZZQQB=True;NANOVERSION=7;LEPTON_SETUP=2018,,
+ZZTo4lext1,,1.256,  ,,/ZZTo4L_TuneCP5_13TeV_powheg_pythia8/RunIIAutumn18NanoAODv7-Nano02Apr2020_102X_upgrade2018_realistic_v21_ext1-v1/NANOAODSIM,dbs,/eos/cms,3,GENXSEC=1.256;GENBR=1;PROCESS_CR=True;APPLY_K_NNLOQCD_NLOEW_ZZQQB=True;NANOVERSION=7;LEPTON_SETUP=2018,,
+##ZZTo4lext2,,1.256, ,,/ZZTo4L_TuneCP5_13TeV_powheg_pythia8/RunIIAutumn18NanoAODv7-Nano02Apr2020_102X_upgrade2018_realistic_v21_ext2-v1/NANOAODSIM,dbs,root://cms-xrd-global.cern.ch/,3,GENXSEC=1.256;GENBR=1;PROCESS_CR=True;APPLY_K_NNLOQCD_NLOEW_ZZQQB=True;NANOVERSION=7;LEPTON_SETUP=2018,,
 
 ###,,,,,,,,,,,gg->ZZ background - Xsec from https://twiki.cern.ch/twiki/bin/viewauth/CMS/Run2MCProductionforHiggsProperties#MCFM_ZZ_4l_l_e_mu_tau
 ggTo4e_Contin_MCFM701,,0.00158549,   ,,/GluGluToContinToZZTo4e_13TeV_MCFM701_pythia8/RunIIAutumn18NanoAODv7-Nano02Apr2020_EXT_102X_upgrade2018_realistic_v21-v1/NANOAODSIM,dbs,root://cms-xrd-global.cern.ch/,1,GENXSEC=0.00158549;GENBR=1;PROCESS_CR=False;APPLY_K_NNLOQCD_ZZGG=1;NANOVERSION=7;LEPTON_SETUP=2018,,

NanoAnalysis/test/prod/samplesNano_2018ULv15_MC.csv

@@ -12,7 +12,7 @@ VBFH125, ,3.782,0.0002745,,/VBF_HToZZTo4L_M125_TuneCP5_13TeV_powheg2_JHUGenV7011
 
 
 ###,,,,,,,,,,,qq->ZZ background
-ZZTo4l,,1.256,  ,,/ZZTo4L_TuneCP5_13TeV_powheg_pythia8/RunIISummer20UL18NanoAODv15-150X_mc2018_realistic_v1-v1/NANOAODSIM,dbs,root://cms-xrd-global.cern.ch/,3,GENXSEC=1.256;GENBR=1;PROCESS_CR=True;APPLY_K_NNLOQCD_ZZQQB=True;APPLY_K_NLOEW_ZZQQB=True;NANOVERSION=15;LEPTON_SETUP=2018,, # 99191000 events
+ZZTo4l,,1.256,  ,,/ZZTo4L_TuneCP5_13TeV_powheg_pythia8/RunIISummer20UL18NanoAODv15-150X_mc2018_realistic_v1-v1/NANOAODSIM,dbs,root://cms-xrd-global.cern.ch/,3,GENXSEC=1.256;GENBR=1;PROCESS_CR=True;APPLY_K_NNLOQCD_NLOEW_ZZQQB=True;NANOVERSION=15;LEPTON_SETUP=2018,, # 99191000 events
 
 
 ###,,,,,,,,,,,gg->ZZ background - Xsec from https://twiki.cern.ch/twiki/bin/viewauth/CMS/Run2MCProductionforHiggsProperties#MCFM_ZZ_4l_l_e_mu_tau

NanoAnalysis/test/prod/samplesNano_2022EE_MC.csv

@@ -69,7 +69,7 @@ ttH125_4l  ,,0.5700,0.0002745,,/TTH_Hto2Z_M-125_4LFilter_TuneCP5_13p6TeV_powheg2
 
 
 ###,,,,,,,,,,,qq->ZZ background - xsec taken from powheg gridpack
-ZZTo4l,,1.39,,,/ZZto4L_TuneCP5_13p6TeV_powheg-pythia8/Run3Summer22EENanoAODv12-130X_mcRun3_2022_realistic_postEE_v6-v2/NANOAODSIM,dbs,root://cms-xrd-global.cern.ch/,3,PROCESS_CR=True;PROCESS_ZL=True;APPLY_K_NNLOQCD_ZZQQB=True;APPLY_K_NLOEW_ZZQQB=True;LEPTON_SETUP=2022,,
+ZZTo4l,,1.39,,,/ZZto4L_TuneCP5_13p6TeV_powheg-pythia8/Run3Summer22EENanoAODv12-130X_mcRun3_2022_realistic_postEE_v6-v2/NANOAODSIM,dbs,root://cms-xrd-global.cern.ch/,3,PROCESS_CR=True;PROCESS_ZL=True;APPLY_K_NNLOQCD_NLOEW_ZZQQB=True;LEPTON_SETUP=2022,,
 
 ###,,,,,,,,,,,gg->ZZ background - xsec taken from gridpack
 ggTo4e_Contin_MCFM701     ,,0.00305851,,,/GluGlutoContinto2Zto4E_TuneCP5_13p6TeV_mcfm-pythia8/Run3Summer22EENanoAODv12-130X_mcRun3_2022_realistic_postEE_v6-v2/NANOAODSIM        ,dbs,root://cms-xrd-global.cern.ch/,1,PROCESS_CR=True;PROCESS_ZL=True;APPLY_K_NNLOQCD_ZZGG=1;LEPTON_SETUP=2022,,