Exemplo n.º 1
0
def main():
    inputs = effectiveModel.getInputs(options.input)
    for i in inputs:
        i[2] = unit  # This function has to be pickle'able. Lambda functions are not allowed.

    x = [bins[0], plotRange[0], plotRange[2]]
    y = [bins[1], plotRange[1], plotRange[3]]
    h = ROOT.TH2F(
        "muTmuW",
        "(#mu^{f}_{ggF+ttH},#mu^{f}_{VBF+VH}) plane;#mu^{f}_{ggF+ttH};#mu^{f}_{VBF+VH};-2 ln #Lambda",
        x[0], x[1], x[2], y[0], y[1], y[2])

    npHistograms = {}
    effectiveModel.fillHist(h,
                            x,
                            y,
                            inputs,
                            options,
                            npHistograms=npHistograms)
    PyROOTUtils.subtractMinFromHist(h)

    outF = effectiveModel.outFileName(options.output, options)
    fOut = ROOT.TFile.Open(outF, "RECREATE")
    h.Write()
    for npH in npHistograms.values():
        npH.Write()
    fOut.Close()
    print("Output written to: " + outF)
def main():
    f = ROOT.TFile.Open(options.input, "READ")
    w = f.Get(options.wsName)
    mc = w.obj(options.mcName)
    data = w.data(options.dataName)

    # prepare model
    w.var("mu").setVal(1.0)
    w.var("mu").setConstant()

    # get nll
    nll = getNll(mc.GetPdf(), data)

    kGam = [100, plotRange[0], plotRange[2]]
    kGlu = [100, plotRange[1], plotRange[3]]
    h = ROOT.TH2F(
        "kGlukGamma",
        "Couplings in (k_{g},k_{#gamma});#kappa_{#gamma};#kappa_{g};-2 ln #Lambda",
        kGam[0], kGam[1], kGam[2], kGlu[0], kGlu[1], kGlu[2])

    for x in range(kGam[0]):
        kGamVal = kGam[1] + (x + 0.5) * (kGam[2] - kGam[1]) / kGam[0]
        print("Progress: %.0f%%" % (100.0 * x / kGam[0]))
        for y in range(kGlu[0]):
            kGluVal = kGlu[1] + (y + 0.5) * (kGlu[2] - kGlu[1]) / kGlu[0]

            muTmuW2ph = kGlukGamma.map_2ph(kGamVal, kGluVal)
            w.var("muT_2ph").setVal(muTmuW2ph[0])
            w.var("muW_2ph").setVal(muTmuW2ph[1])

            muTmuW4l = kGlukGamma.map_4l(kGamVal, kGluVal)
            w.var("muT_4l").setVal(muTmuW4l[0])
            w.var("muW_4l").setVal(muTmuW4l[1])

            muTmuWlvlv = kGlukGamma.map_lvlv(kGamVal, kGluVal)
            w.var("muT_lvlv").setVal(muTmuWlvlv[0])
            w.var("muW_lvlv").setVal(muTmuWlvlv[1])

            minimize(nll)
            h.SetBinContent(h.FindBin(kGamVal, kGluVal), 2.0 * nll.getVal())

    PyROOTUtils.subtractMinFromHist(h)

    fOut = ROOT.TFile.Open(options.output, "RECREATE")
    h.Write()
    fOut.Close()
    print("Output written to: " + options.output)
def main():
	f = ROOT.TFile.Open( options.input, "READ" )
	w = f.Get( options.wsName )
	mc = w.obj( options.mcName )
	data = w.data( options.dataName )

	# prepare model
	w.var("mu").setVal( 1.0 )
	w.var("mu").setConstant()

	# get nll
	nll = getNll( mc.GetPdf(), data )


	kGam = [100, plotRange[0], plotRange[2]]
	kGlu = [100, plotRange[1], plotRange[3]]
	h = ROOT.TH2F( "kGlukGamma", "Couplings in (k_{g},k_{#gamma});#kappa_{#gamma};#kappa_{g};-2 ln #Lambda",  kGam[0], kGam[1], kGam[2],  kGlu[0], kGlu[1], kGlu[2] )

	for x in range( kGam[0] ):
		kGamVal = kGam[1] + (x+0.5)*(kGam[2]-kGam[1]) / kGam[0]
		print( "Progress: %.0f%%" % (100.0*x/kGam[0]) )
		for y in range( kGlu[0] ):
			kGluVal = kGlu[1] + (y+0.5)*(kGlu[2]-kGlu[1]) / kGlu[0]

			muTmuW2ph = kGlukGamma.map_2ph( kGamVal, kGluVal )
			w.var("muT_2ph").setVal( muTmuW2ph[0] )
			w.var("muW_2ph").setVal( muTmuW2ph[1] )

			muTmuW4l = kGlukGamma.map_4l( kGamVal, kGluVal )
			w.var("muT_4l").setVal( muTmuW4l[0] )
			w.var("muW_4l").setVal( muTmuW4l[1] )

			muTmuWlvlv = kGlukGamma.map_lvlv( kGamVal, kGluVal )
			w.var("muT_lvlv").setVal( muTmuWlvlv[0] )
			w.var("muW_lvlv").setVal( muTmuWlvlv[1] )

			minimize( nll )
			h.SetBinContent( h.FindBin( kGamVal, kGluVal ), 2.0*nll.getVal() )


	PyROOTUtils.subtractMinFromHist( h )

	fOut = ROOT.TFile.Open( options.output, "RECREATE" )
	h.Write()
	fOut.Close()
	print( "Output written to: "+options.output )
Exemplo n.º 4
0
def main():
	inputs = effectiveModel.getInputs( options.input )
	for i in inputs: i[2] = unit   # This function has to be pickle'able. Lambda functions are not allowed.

	x = [bins[0], plotRange[0], plotRange[2]]
	y = [bins[1], plotRange[1], plotRange[3]]
	h  = ROOT.TH2F( "muTmuW", "(#mu^{f}_{ggF+ttH},#mu^{f}_{VBF+VH}) plane;#mu^{f}_{ggF+ttH};#mu^{f}_{VBF+VH};-2 ln #Lambda",  x[0], x[1], x[2],  y[0], y[1], y[2] )

	npHistograms = {}
	effectiveModel.fillHist( h,x,y,inputs, options, npHistograms=npHistograms )
	PyROOTUtils.subtractMinFromHist( h )


	outF = effectiveModel.outFileName( options.output, options )
	fOut = ROOT.TFile.Open( outF, "RECREATE" )
	h.Write()
	for npH in npHistograms.values(): npH.Write()
	fOut.Close()
	print( "Output written to: "+outF )
Exemplo n.º 5
0
def main():
	inputs = effectiveModel.getInputs( options.input )
	for i in inputs:
		if "2ph" in i[2]: i[2] = map_2ph
		elif "4l" in i[2]: i[2] = map_4l
		elif "lvlv" in i[2]: i[2] = map_lvlv
		else:
			print( "WARNING: Didn't find functional replacement for "+i[2] )

	kGam = [bins[0], plotRange[0], plotRange[2]]
	kGlu = [bins[1], plotRange[1], plotRange[3]]
	h = ROOT.TH2F( "kGlukGamma", "Couplings in (k_{g},k_{#gamma});#kappa_{#gamma};#kappa_{g};-2 ln #Lambda",  kGam[0], kGam[1], kGam[2],  kGlu[0], kGlu[1], kGlu[2] )

	npHistograms = {}
	effectiveModel.fillHist( h,kGam,kGlu,inputs, options, npHistograms=npHistograms )
	PyROOTUtils.subtractMinFromHist( h )


	outF = effectiveModel.outFileName( options.output, options )
	fOut = ROOT.TFile.Open( outF, "RECREATE" )
	h.Write()
	for npH in npHistograms.values(): npH.Write()
	fOut.Close()
	print( "Output written to: "+outF )