Example #1
0
def calcSig(sigFileName):
    #    print sigFileName
    bkgFiles = [
        TFile("/afs/cern.ch/user/o/othrif/workarea/results/v48/" + Dirbase +
              "_Background/" + filename) for filename in bkgFilesNames
    ]
    sigFile = TFile(sigFileName)

    sigYield = MakeNullPointer(TH1F)
    sigFile.GetObject("hyield_weighted", sigYield)

    bkgYields = [MakeNullPointer(TH1F) for bkgFile in bkgFiles]
    for i in range(len(bkgFiles)):
        #        print bkgFilesNames[i]
        #        bkgFiles[i].GetObject("ayield_weighted",bkgYields[i])
        bkgFiles[i].GetObject("hyield_weighted", bkgYields[i])

    relativeBkgUncert = 0.3
    sigResults = []

    bin = 1
    for ilepptmax2 in range(0, len(lepptmax2_cut)):
        for ilepptmin2 in range(0, len(lepptmin2_cut)):
            for ilepptmax1 in range(0, len(lepptmax1_cut)):
                for ilepptmin1 in range(0, len(lepptmin1_cut)):
                    for ibjets in range(0, len(bjets_cut)):
                        for ibjetptmax in range(0, len(bjetptmax_cut)):
                            for ibjetptmin in range(0, len(bjetptmin_cut)):
                                for inbjets in range(0, len(nbjets_cut)):
                                    for ijetptmax in range(
                                            0, len(jetptmax_cut)):
                                        for ijetptmin in range(
                                                0, len(jetptmin_cut)):
                                            for injets in range(
                                                    0, len(njets_cut)):
                                                for imetmax in range(
                                                        0, len(metmax_cut)):
                                                    for imetmin in range(
                                                            0,
                                                            len(metmin_cut)):
                                                        baseMeff = metmin_cut[
                                                            imetmin] + njets_cut[
                                                                injets] * jetptmin_cut[
                                                                    ijetptmin] + lepptmin1_cut[
                                                                        ilepptmin1] + lepptmin2_cut[
                                                                            ilepptmin2]
                                                        for imtMmax in range(
                                                                0,
                                                                len(mtMmax_cut)
                                                        ):
                                                            for imtMmin in range(
                                                                    0,
                                                                    len(mtMmin_cut
                                                                        )):
                                                                for imeff in range(
                                                                        0,
                                                                        len(meff_cut
                                                                            )):
                                                                    for imetOmeff in range(
                                                                            0,
                                                                            len(
                                                                                metOmeff_cut
                                                                            )):
                                                                        sig = sigYield.GetAt(
                                                                            bin
                                                                        )  #*luminosity*1000
                                                                        bkg = 0.0
                                                                        statbkg = 0.0
                                                                        for ibkg in range(
                                                                                len(
                                                                                    bkgYields
                                                                                )
                                                                        ):
                                                                            #                                                                            bkgtmp = bkgYields[ibkg].GetAt(bin) #*luminosity*1000
                                                                            bkgtmp = bkgYields[
                                                                                ibkg].GetBinContent(
                                                                                    bin
                                                                                )  #*luminosity*1000
                                                                            bkgstattmp = bkgYields[
                                                                                ibkg].GetBinError(
                                                                                    bin
                                                                                )  #*luminosity*1000
                                                                            #                                                                            print bkgYields[ibkg].GetBinContent(bin), bkgYields[ibkg].GetBinError(bin)
                                                                            #    if (bkgtmp == 0):
                                                                            #        bkgtmp = useMinBkg[ibkg]
                                                                            #                                                                            print ibkg, bkgtmp
                                                                            bkg += bkgtmp
                                                                            statbkg += bkgstattmp * bkgstattmp
                                                                        statbkg = sqrt(
                                                                            statbkg
                                                                        )
                                                                        zObs = 0.0
                                                                        if (sig >=
                                                                                2
                                                                                and
                                                                                bkg
                                                                                >=
                                                                                0.8
                                                                                and
                                                                                statbkg
                                                                                /
                                                                                bkg
                                                                                <=
                                                                                0.3
                                                                            ):  # and statbkg/bkg <= 0.3
                                                                            #                                                                        if(sig>0 and bkg>0):
                                                                            zObs = RooStats.NumberCountingUtils.BinomialExpZ(
                                                                                sig,
                                                                                bkg,
                                                                                relativeBkgUncert
                                                                            )
#                                                                            print zObs, sig, bkg
                                                                        elif (bkg
                                                                              <
                                                                              0.8
                                                                              ):
                                                                            zObs = 0.01
                                                                        elif (sig
                                                                              <
                                                                              2
                                                                              ):
                                                                            zObs = 0.02
                                                                        elif (statbkg
                                                                              /
                                                                              bkg
                                                                              >
                                                                              0.3
                                                                              ):
                                                                            zObs = 0.03

#                                                                        if(zObs>0.0):
                                                                        if (zObs
                                                                                >
                                                                                0.0
                                                                                and
                                                                                inbjets
                                                                                !=
                                                                                2
                                                                            ):
                                                                            sigResults.append([
                                                                                zObs,
                                                                                [
                                                                                    lepptmax1_cut[
                                                                                        ilepptmax1],
                                                                                    lepptmin1_cut[
                                                                                        ilepptmin1],
                                                                                    lepptmax2_cut[
                                                                                        ilepptmax2],
                                                                                    lepptmin2_cut[
                                                                                        ilepptmin2],
                                                                                    bjets_cut[
                                                                                        ibjets],
                                                                                    bjetptmax_cut[
                                                                                        ibjetptmax],
                                                                                    bjetptmin_cut[
                                                                                        ibjetptmin],
                                                                                    nbjets_cut[
                                                                                        inbjets],
                                                                                    jetptmax_cut[
                                                                                        ijetptmax],
                                                                                    jetptmin_cut[
                                                                                        ijetptmin],
                                                                                    njets_cut[
                                                                                        injets],
                                                                                    metmax_cut[
                                                                                        imetmax],
                                                                                    metmin_cut[
                                                                                        imetmin],
                                                                                    mtMmax_cut[
                                                                                        imtMmax],
                                                                                    mtMmin_cut[
                                                                                        imtMmin],
                                                                                    meff_cut[
                                                                                        imeff],
                                                                                    meff_cut[
                                                                                        imeff]
                                                                                    +
                                                                                    baseMeff,
                                                                                    metOmeff_cut[
                                                                                        imetOmeff]
                                                                                ],
                                                                                sig,
                                                                                bkg
                                                                            ])
                                                                        #print bin, sig, bkg, zObs
                                                                        bin += 1
    sigResults.sort(key=lambda sig: sig[0])
    sigResults.reverse()
    return sigResults