Пример #1
0
    def drawGraph(self, g):
        '''
        output graph to file
        '''
        title = g.GetTitle()
        name = g.GetName()
        pdf = self.figDir + name + '.pdf'

        xsize, ysize = 1100, 850  # landscape style
        noPopUp = True
        if noPopUp: gROOT.ProcessLine("gROOT->SetBatch()")
        canvas = TCanvas(pdf, title, xsize, ysize)

        g.Draw()

        canvas.Draw()
        canvas.SetGrid(1)
        canvas.SetTicks(1)
        canvas.cd()
        canvas.Modified()
        canvas.Update()
        canvas.Print(pdf, 'pdf')
        return
    def getLBDataStruct(self):

        #
        # Define LBDATA tree
        # Time is in ms
        structStr = "struct LBDataStruct {\
                ULong64_t fStartTime;\
                ULong64_t fEndTime;\
                UInt_t fRun;\
                UInt_t fLB;\
                UInt_t fStable;\
                Float_t fAvgBeam1;\
                Float_t fAvgBeam2;\
                Float_t fPmtA;\
                Float_t fPmtC;\
                Float_t fFibA;\
                Float_t fFibC;\
            };"

        # Replace sizes if needed
        gROOT.ProcessLine(structStr)
        from ROOT import LBDataStruct
        return LBDataStruct()
Пример #3
0
def waitRootCmdX(defaultSaveName='test',
                 saveDirectly=False,
                 updateFirst=True,
                 pad=gPad):
    if not pad:
        print("pad is None. Will do nothing.")
    else:
        if updateFirst: pad.Update()
        if saveDirectly: return savePad(defaultSaveName, pad)

    print('defaultSaveName:', defaultSaveName)
    ### code records if the figure is saved.
    code = 0
    while True:
        x = input('root: ').rstrip()
        if x.lower() == 'e' or x.lower() == 'end' or x.lower(
        ) == 'q' or x.lower() == 'quit' or x.lower() == '.q':
            sys.exit()
        elif x == '' or x.lower() == 'n' or x.lower() == 'next':
            break
        args = x.split()
        if args[0] == 's' or args[0] == 'save':
            if pad is None:
                print("pad is None. Can not save!!!!")
            if len(args) < 2: args.append(defaultSaveName)
            savePad(args[1:], pad)
            code |= (1 << 1)
            continue
        elif args[0] == 'p' or args[0] == 'pass':
            return args[1:]
        try:
            print('root processing "' + x + '"')
            gROOT.ProcessLine(x)
        except:
            print('command not recognized')
            continue
    return code
Пример #4
0
    def __init__(self, logfile=""):
        ## initialize DB
        self.db = datamon_db()

        self.BASE_ONLINEMON_DIR = "/work/halld/online_monitoring"
        self.PROCESSED_RUN_LIST_FILE = "processedrun.lst.online"
        self.ONLINE_ROOT_DIR = self.BASE_ONLINEMON_DIR + '/root'
        self.ONLINE_CONDITION_DIR = self.BASE_ONLINEMON_DIR + '/conditions'

        self.MIN_RUN_NUMBER = 30001
        #self.MAX_RUN_NUMBER = 9000
        self.MAX_RUN_NUMBER = 1000000
        self.VERSION_NUMBER  =  88  ## hardcode default - need to change this
        self.MONITORING_OUTPUT_DIR = "/work/halld2/data_monitoring"
        self.RUN_PERIOD = "RunPeriod-2017-01"

        self.MAKE_PLOTS = True
        self.MAKE_DB_SUMMARY = True
        #self.MAKE_PLOTS = False
        #self.MAKE_DB_SUMMARY = False
        #self.MAKE_RUN_CONDITIONS = False
        self.MAKE_RUN_CONDITIONS = True

        self.NEWDIR_MODE = "775"
        self.VERBOSE = 1
        self.FORCE_PROCESSING = False

        # limit ROOT output
        gROOT.ProcessLine("gErrorIgnoreLevel = 2001;")   # only output at least "Error" level messages

        # optionally log the output to a file
        # use separate log files for ROOT and all other output
        # append by default
        self.LOGFILE = logfile
        if self.LOGFILE is not "":
            logging.basicConfig(filename=self.LOGFILE)
            gSystem.RedirectOutput(self.LOGFILE)
Пример #5
0
def waitRootCmdMore(padlist, saveDirectly=False):
    if saveDirectly:
        for p, c in padlist.iteritems():
            savePad(p, c)
    while True:
        x = raw_input('root: ')
        if x.lower() == 'e' or x.lower() == 'end' or x.lower(
        ) == 'q' or x.lower() == 'quit' or x.lower() == '.q':
            sys.exit()
        elif x == '' or x.lower() == 'n' or x.lower() == 'next':
            break
        args = x.split()
        if args[0] == 's' or args[0] == 'save':
            if len(args) < 2:
                for p, c in padlist.iteritems():
                    savePad(p, c)
            else:
                savePad(args[1:], gPad)
            continue
        try:
            gROOT.ProcessLine(x)
        except:
            print 'command not recognized'
            continue
Пример #6
0
def SavePlots(sum_hists, sum_dir, hists_to_plot, macros_to_run):
    global WEB_OUTPUT
    # plot individual histograms
    if(len(sum_hists) > 0):
        for (hnamepath,h) in sum_hists.items():
            #if not match_hnamepaths(hists_to_plot, hnamepath):
            if (h.GetName() not in hists_to_plot) and (hnamepath not in hists_to_plot): 
                continue
            if(isinstance(h,TH2)):
                plot_2dhist(h)
            else:
                plot_hist(h)
            
            # Output canvas
            #print_canvas_pdf()
            if(WEB_OUTPUT):
                print_canvas_png("_"+hnamepath)  ## name hack for backward compatability

    # plot RootSpy macros
    if(len(macros_to_run) > 0):
        for macro_file in macros_to_run: 
            if os.path.isfile(macro_file):
                if VERBOSE:
                    print "running macro = " + macro_file
                # run the macro
                ClearPad(c1)
                sum_dir.cd()
                gROOT.ProcessLine(".x " + macro_file)
                # save the canvas - the name depends just on the file name
                img_fname = macro_file.split('/')[-1]
                #print "SPLIT =  " +  img_fname[0:-2] + " / " + img_fname[-2:]
                if img_fname[-2:] == ".C":
                    img_fname = img_fname[0:-2]
                print_canvas_png(img_fname)
            else:
                print "could not find macro = " + macro_file + " !"
    def __init__(self):
        # ROOT
        gROOT.LoadMacro("tdrstyle.C")
        gROOT.LoadMacro("../interface/HelperMath.h")
        gROOT.LoadMacro("../../AMSimulationIO/src/AMSimulationIOLinkDef.h")
        gROOT.ProcessLine("setTDRStyle()")

        gStyle.SetEndErrorSize(2)
        gStyle.SetPadRightMargin(0.05)
        gStyle.SetTitleOffset(1.1, "Y")
        gStyle.SetLabelSize(0.04, "Y")
        gStyle.SetLabelSize(0.04, "Z")
        gStyle.SetNdivisions(505, "XY")

        gStyle.SetPalette(55)  # rainbow color map
        gStyle.SetNumberContours(100)

        gStyle.SetOptStat(111110)
        gStyle.SetStatX(0.94)
        gStyle.SetStatY(0.93)
        gStyle.SetStatH(0.30)
        gStyle.SetStatW(0.28)

        TH1.SetDefaultSumw2()
Пример #8
0
def setup_analysis(filename='analysis.root'):
    from ROOT import gROOT, TFile, AliAnalysisManager

    tfile = TFile.Open(str(filename), "RECREATE")

    mgr = AliAnalysisManager("mgr")

    gROOT.Macro("$ALICE_ROOT/ANALYSIS/macros/train/AddAODHandler.C")

    gROOT.Macro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C")
    gROOT.Macro(
        "$ALICE_PHYSICS/OADB/COMMON/MULTIPLICITY/macros/AddTaskMultSelection.C"
    )

    gROOT.LoadMacro("$ALICE_PHYSICS/PWGCF/FEMTOSCOPY/macros/AddTaskFemto.C")
    macro_config_path = (Path(__file__).parent /
                         "ConfigFemtoAnalysis.C").absolute()

    gROOT.ProcessLine(f'AddTaskFemto("{macro_config_path}")')

    # gROOT.LoadMacro("$ALICE_PHYSICS/PWGCF/FEMTOSCOPY/macros/Train/PionPionFemto/AddNuTaskPionPionRoot6.C")
    # gROOT.ProcessLine("""AddNuTaskPionPionRoot6(
    #     "container1",
    #     "",
    #     "{30:40:50}; (0.2:0.3:0.4:0.5:0.6:0.7:0.8:1.0);"
    #     "~do_kt_ylm_cf=true; ~do_kt_qinv_cf=true; ~do_kt_pqq3d_cf=true;"
    #     "~do_sharequality_cf=true;  ~do_avg_sep_cf=true; ~do_detadphistar_cf=true;"
    #     "~q3d_bin_count=47; ~q3d_maxq = 0.141;"
    #     "@enable_pair_monitors=false;"
    #     "@num_events_to_mix=3;"
    #     "$pion_1_min_tpc_chi_ndof=0.33; $pion_1_max_its_chi_ndof=1.8;"
    #     "$pion_1_max_tpc_chi_ndof=1.8;"
    #  )""")

    mgr.Write()
    tfile.Close()
Пример #9
0
def main():

    gROOT.ProcessLine(
        "gErrorIgnoreLevel = kError;"
    )  # Surpress info messages below Error or Fatal levels (IE info or warning)

    args = input_arguments()
    if (args.freq == '160') or (args.freq == '160MHz'):
        freq = '160MHz'  # Ensures consistent formatting
    elif (args.freq == '120') or (args.freq == '120MHz'):
        freq = '120MHz'  # IE does the user enter '120', or '120MHz'?
    if (args.temp == '18') or (args.temp == '18deg'):
        temp = '18deg'  # Resolve it either way
    elif (args.temp == '9') or (args.temp == '9deg'):
        temp = '9deg'  # blahblah licht mehr licht

    if not args.directory.endswith('/'):
        args.directory += '/'  # For consistency, makes sure '/directory/path/ends/with/' <-- a '/'

    name_base = "ECAL_H4_Oct2018_" + freq + "_" + temp + "_"
    # Get position and energy info on all files in the directory, and sort them into the mastertable (dict)
    for filei in os.listdir(
            args.directory):  # Iterate over all files in the given directory
        if filei.endswith(".root"):  # Only includes .root files
            print "Found file:", filei, "\t\t",
            tfile = TFile(args.directory + filei)
            infotree = tfile.Get("info")
            try:
                infotree.GetEntry(1)
            except AtributeError:
                print "file " + filei + "is missing info!"
            Energy = int(infotree.Energy)
            Position = str(infotree.Positions)

            print "Position: {0:9} \t Energy: {1}".format(Position, Energy)
    print
Пример #10
0
 def __init__(self, year=2017, dozpt=True):
     """Load correction tool."""
     assert year in [
         2016, 2017, 2018
     ], "RecoilCorrectionTool: You must choose a year from: 2016, 2017, or 2018."
     if year == 2016:
         filename = rcpath + "TypeI-PFMet_Run2016BtoH.root"  #"TypeI-PFMet_Run2016_legacy.root"
     elif year == 2017:
         filename = rcpath + "Type1_PFMET_2017.root"
     else:
         filename = rcpath + "TypeI-PFMet_Run2018.root"
     print "Loading RecoilCorrectionTool for %s..." % filename
     CMSSW_BASE = os.environ.get("CMSSW_BASE", None)
     recoil_h = "%s/src/HTT-utilities/RecoilCorrections/interface/RecoilCorrector.h" % (
         CMSSW_BASE)
     assert CMSSW_BASE, "RecoilCorrectionTool: Did not find $CMSSW_BASE"
     assert os.path.isfile(
         recoil_h
     ), "RecoilCorrectionTool: Did not find RecoilCorrection header: %s" % recoil_h
     gROOT.ProcessLine('#include "%s"' % recoil_h)
     gSystem.Load("libHTT-utilitiesRecoilCorrections.so")
     corrector = ROOT.RecoilCorrector(filename)
     self.corrector = corrector
     self.filename = filename
Пример #11
0
    def makeNameSpaceSingleFakes(self):
            # import sfr_hist
            f = TFile('modules/DDE_singlefake.root')
            sfr_hist = f.Get('ptCone_eta').GetPrimitive("pt_eta_T_012")

            #prepare a .h file to implement the fakerates into the ROOT namespace
            sfr_namespace_dir = "/home/dehuazhu/HNL/CMSSW_9_4_6_patch1/src/PlotFactory/DataBkgPlots/modules/DDE_singlefake.h"
            with open(sfr_namespace_dir, "w") as sfr_namespace:
                    sfr_namespace.write("// This namespace prepares the singlefakerate measured via DDE.py to be implementable in dataframe for the main plotting tool.\n")
                    sfr_namespace.write("namespace sfr_namespace {\n")
                    sfr_namespace.write("\tdouble getSingleFakeRate(double ptCone, double eta){\n")
                    for xbin_i in np.arange(sfr_hist.GetNbinsX()): 
                        for ybin_i in np.arange(sfr_hist.GetNbinsY()): 
                            xbin_low = sfr_hist.GetXaxis().GetXbins()[xbin_i]
                            xbin_up  = sfr_hist.GetXaxis().GetXbins()[xbin_i+1]
                            ybin_low = sfr_hist.GetYaxis().GetXbins()[ybin_i]
                            ybin_up  = sfr_hist.GetYaxis().GetXbins()[ybin_i+1]
                            result   = sfr_hist.GetBinContent(xbin_i+1, ybin_i+1)
                            sfr_namespace.write("\t\tif (ptCone >= %f && ptCone < %f && eta >= %f && eta < %f) return %f;\n"%(xbin_low,xbin_up,ybin_low,ybin_up,result))
                    sfr_namespace.write("\t\treturn 0.;\n")
                    sfr_namespace.write("\t}\n")
                    sfr_namespace.write("}\n")
            print ('FakeRateNamespace saved in "%s"'%(sfr_namespace_dir))
            gROOT.ProcessLine(".L modules/DDE_singlefake.h+")
Пример #12
0
    def initBunchData(self):

        #
        # Define BUNCHDATA tree
        gROOT.ProcessLine("struct BunchDataStruct {\
            UInt_t  fValidBPTX;\
            Float_t fB1BunchAverageBPTX;\
            Float_t fB2BunchAverageBPTX;\
            Int_t   fB1BunchesBPTX;\
            Int_t   fB2BunchesBPTX;\
            Float_t fB1BunchIntensitiesBPTX[3564];\
            Int_t   fB1BCIDsBPTX[3564];\
            Float_t fB2BunchIntensitiesBPTX[3564];\
            Int_t   fB2BCIDsBPTX[3564];\
            UInt_t  fValidBCT;\
            Float_t fB1BunchAverageBCT;\
            Float_t fB2BunchAverageBCT;\
            Int_t   fB1BunchesBCT;\
            Int_t   fB2BunchesBCT;\
            Int_t   fB1BCIDsBCT[3564];\
            Float_t fB1BunchIntensitiesBCT[3564];\
            Int_t   fB2BCIDsBCT[3564];\
            Float_t fB2BunchIntensitiesBCT[3564];\
        };")
        from ROOT import BunchDataStruct
        self.bunchDataStruct = BunchDataStruct()

        # Not sure why this is necessary
        self.bunchDataStruct.fB1BunchesBPTX = 0
        self.bunchDataStruct.fB2BunchesBPTX = 0
        self.bunchDataStruct.fB1BunchesBCT = 0
        self.bunchDataStruct.fB2BunchesBCT = 0

        self.tree.Branch(
            'BCT_BUNCHDATA', AddressOf(self.bunchDataStruct, 'fValidBCT'),
            'BCT_Valid/i:BCT_B1BunchAverage/F:BCT_B2BunchAverage/F:BCT_B1Bunches/I:BCT_B2Bunches/I'
        )
        self.tree.Branch('BCT_B1BCID',
                         AddressOf(self.bunchDataStruct, 'fB1BCIDsBCT'),
                         'BCT_B1BCID[BCT_B1Bunches]/I')
        self.tree.Branch('BCT_B2BCID',
                         AddressOf(self.bunchDataStruct, 'fB2BCIDsBCT'),
                         'BCT_B2BCID[BCT_B2Bunches]/I')
        self.tree.Branch(
            'BCT_B1BunchIntensity',
            AddressOf(self.bunchDataStruct, 'fB1BunchIntensitiesBCT'),
            'BCT_B1BunchIntensity[BCT_B1Bunches]/F')
        self.tree.Branch(
            'BCT_B2BunchIntensity',
            AddressOf(self.bunchDataStruct, 'fB2BunchIntensitiesBCT'),
            'BCT_B2BunchIntensity[BCT_B2Bunches]/F')

        self.tree.Branch(
            'BPTX_BUNCHDATA', AddressOf(self.bunchDataStruct, 'fValidBPTX'),
            'BPTX_Valid/i:BPTX_B1BunchAverage/F:BPTX_B2BunchAverage/F:BPTX_B1Bunches/I:BPTX_B2Bunches/I'
        )
        self.tree.Branch('BPTX_B1BCID',
                         AddressOf(self.bunchDataStruct, 'fB1BCIDsBPTX'),
                         'BPTX_B1BCID[BPTX_B1Bunches]/I')
        self.tree.Branch('BPTX_B2BCID',
                         AddressOf(self.bunchDataStruct, 'fB2BCIDsBPTX'),
                         'BPTX_B2BCID[BPTX_B2Bunches]/I')
        self.tree.Branch(
            'BPTX_B1BunchIntensity',
            AddressOf(self.bunchDataStruct, 'fB1BunchIntensitiesBPTX'),
            'BPTX_B1BunchIntensity[BPTX_B1Bunches]/F')
        self.tree.Branch(
            'BPTX_B2BunchIntensity',
            AddressOf(self.bunchDataStruct, 'fB2BunchIntensitiesBPTX'),
            'BPTX_B2BunchIntensity[BPTX_B2Bunches]/F')
Пример #13
0
def plotter(plotdir,
            plot,
            xTitle,
            logY,
            channels=['VV'],
            includeData=False,
            scaleSignal=0,
            UserRange=[None, None, None, None],
            initPath=''):

    # channelTex={'WPWP':'W^{+}W^{+}', 'WPWM':'W^{+}W^{-}','WMWM':'W^{-}W^{-}','WPZ':'W^{+}Z','WMZ':'W^{-}Z','ZZ':'ZZ'}
    channelTex = {'ZZ': 'ZZ'}
    # plotstyle=[(1,1),(1,2),(2,1),(2,2),(4,1),(4,2)]
    plotstyle = [(1, 1)]
    #             0              1                       2                        3             4              5             6
    # Backgrounds=['QCD',     'WJetsToQQ_HT600ToInf', 'ZJetsToQQ_HT600ToInf',     'TT',         'WW',          'WZ',         'ZZ']
    # BGColors=   [rt.kAzure+7,   rt.kRed-4,              rt.kOrange-2,            rt.kGreen+2,  rt.kOrange+7,  rt.kBlue+1,   rt.kMagenta+2]
    # BGTeX=      ['QCD',        'W+JetsToQQ',           'Z+JetsToQQ',             'TTbar'],      'WW',          'WZ',         'ZZ']
    #stackOrder= [4,5,6,2,1,3,0]
    Backgrounds = [
        'QCD'
    ]  # 'WJetsToQQ_HT600ToInf', 'ZJetsToQQ_HT600ToInf', 'ZZ']  'TT',         'WW',          'WZ',         'ZZ']
    BGColors = [
        rt.kAzure + 7
    ]  #,              rt.kOrange-2,            rt.kGreen+2],  rt.kOrange+7,  rt.kBlue+1,   rt.kMagenta+2]
    BGTeX = ['QCD']  #

    stackOrder = [0]

    PreSelection = [
        'nocuts', 'common', 'corrections', 'cleaner', 'softdropmassCorr',
        'AK4pfidfilter', 'AK8pfidfilter', 'invMAk8sel', 'detaAk8sel',
        'AK8N2sel'
    ]
    Selection = [
        'preselection', 'softdropAK8sel', 'tau21sel', 'deltaR48', 'VVRegion',
        'AK4N2sel', 'OpSignsel', 'detaAk4sel', 'invMAk4sel_1p0', 'Kin_AK8'
    ]

    cutnames = [
        'cleaner', 'AK8N2sel', 'invMAk8sel', 'detaAk8sel', 'softdropAK8sel',
        'tau21sel', 'AK4cleaner', 'AK4N2sel', 'OpSignsel', 'detaAk4sel',
        'invMAk4sel_1p0'
    ]

    cuts = {
        'cleaner':
        '#splitline{p_{T-AK8} > 200 GeV, |#eta_{AK8}| < 2.5}{p_{T-AK4} > 30 GeV, |#eta_{AK4}| < 5.0}',
        'AK8N2sel': 'N_{AK8} #geq 2',
        'invMAk8sel': 'M_{jj-AK8} > 1050 GeV',
        'detaAk8sel': '|#Delta#eta_{jj-AK8}|<1.3',
        'softdropAK8sel': '65 GeV <M_{SD}< 105 GeV',
        'tau21sel': '0 #leq #tau_{2}/#tau_{1}<0.45',
        # 'AK4cleaner':'p_{T-AK4} > 30 GeV, |#eta_{AK4}| < 5.0',
        'AK4cleaner': '',
        'AK4N2sel': 'N_{AK4} #geq 2',
        'OpSignsel': '#eta_{1-AK4} #eta_{2-AK4} < 0',
        'detaAk4sel': '|#Delta#eta_{jj-AK4}| > 3.0',
        'invMAk4sel_1p0': 'M_{jj-AK4} > 1.0 TeV'
    }

    VV = ('VV' in channels)
    seperate = (not VV)
    if VV:
        #channels=["WPWP","WPWM","WMWM","WPZ","WMZ","ZZ"]
        channels = ["ZZ"]

    plottitle = plotdir + '_' + plot

    lumi = 36.814
    xLabelSize = 18.
    yLabelSize = 18.
    xTitleSize = 20.
    yTitleSize = 22.
    xTitleOffset = 4.
    yTitleOffset = 1.3

    printout = False
    Portrait = True
    cutname = False
    ratio = includeData

    if ('highbin' in plot):
        binning = 'dijetbinning'
    else:
        binning = 'default'

    if (Portrait):
        canvX = 600
        canvY = 600
    else:
        canvX = 900
        canvY = 675

    if (plotdir in PreSelection):
        region = 'PreSelection'
        initPath = ''
        referenceHistPath = 'detaAk8sel/N_pv'
        if (PreSelection.index(plotdir) < 4 and ('softdrop' in plot)):
            return 'SofdropMass not filled yet!'
    else:
        region = 'SignalRegion'
        referenceHistPath = 'tau21sel/N_pv'
    referenceHistPath = plotdir + '/' + plot

    if (initPath == ''):
        path = '/nfs/dust/cms/user/loemkerj/bachelor/CMSSW_10_2_16/src/UHH2/aQGCVVjjhadronic/%s' % region
    else:
        path = initPath
    outputPath = path.replace(
        '/nfs/dust/cms/user/loemkerj/bachelor/CMSSW_10_2_16/src/UHH2/aQGCVVjjhadronic/SignalRegion',
        'plots/')
    if (plotdir in PreSelection):
        CutNumber = PreSelection.index(plotdir)
    else:
        CutNumber = Selection.index(plotdir)
    outputPath = outputPath + '/%02i_%s' % (CutNumber, plotdir) + '/'
    if (printout):
        print('InputPath:', path)
        print('OutputPath:', outputPath)
    #check if OutputPath exists - and if not create it!
    if not os.path.exists(outputPath):
        os.makedirs(outputPath)
    # path='/home/albrec/Master/signal/'
    scaleVV = (scaleSignal != 0)
    VVScale = scaleSignal

    if (UserRange[2] == None or UserRange[3] == None):
        YRangeUser = False
        Ymin = UserRange[2]
        Ymax = UserRange[3]
    else:
        YRangeUser = True
        Ymin = UserRange[2]
        Ymax = UserRange[3]

    if (UserRange[0] == None or UserRange[1] == None):
        XRangeUser = False
        Xmin = UserRange[0]
        Xmax = UserRange[1]
    else:
        XRangeUser = True
        Xmin = UserRange[0]
        Xmax = UserRange[1]

    # YRangeUser=False
    # Ymin=0.11
    # Ymax=9*10**3

    # XRangeUser=False
    # Xmin=0
    # Xmax=6000.

    gROOT.ProcessLine("gErrorIgnoreLevel = 2001;")
    SFiles = []
    for i in range(len(channels)):
        SFiles.append(
            TFile(
                path +
                "/uhh2.AnalysisModuleRunner.MC.MC_aQGC_%sjj_hadronic_2016v3.root"
                % channels[i]))
#uhh2.AnalysisModuleRunner.MC.MC_aQGC_ZZjj_hadronic_2016v3.root
##Open Files to get BackgroundHist:
    BFiles = []
    for i in range(len(Backgrounds)):
        BFiles.append(
            TFile(path +
                  "/uhh2.AnalysisModuleRunner.MC.MC_%s.root" % Backgrounds[i]))

    #Open File to get DataHist:

# DataFile = TFile(path+"/uhh2.AnalysisModuleRunner.Data.DATA.root")

#gROOT.ProcessLine( "gErrorIgnoreLevel = 0;")

    if (includeData == True):
        #calculate QCDscale with Integrals from the following Histogram:
        # referenceHistPath = 'tau21sel/N_AK4'
        # referenceHistPath = 'detaAk8sel/N_pv'
        # referenceHistPath = 'tau21sel/met_pt_over_sumptAK8_2'
        QCDscale = float(DataFile.Get(referenceHistPath).Integral())
        QCDNorm = 1
        for i in range(len(BFiles)):
            if ('QCD' in BFiles[i].GetName()):
                QCDNorm = float(BFiles[i].Get(referenceHistPath).Integral())
            else:
                QCDscale -= float(BFiles[i].Get(referenceHistPath).Integral())
        QCDscale /= QCDNorm
    else:
        QCDscale = 1.0
    if (printout):
        print('using QCDscale:', QCDscale)

    SHists = []
    for i in range(len(channels)):
        SHists.append(SFiles[i].Get(plotdir + '/' + plot))

    BHists = []
    for i in range(len(BFiles)):
        BHists.append(BFiles[i].Get(plotdir + '/' + plot))
        if ('QCD' in BFiles[i].GetName()):
            BHists[-1].Scale(QCDscale)

    #if(includeData):
    #    DataHist=DataFile.Get(plotdir+'/'+plot)

    if (binning == 'dijetbinning'):
        fitbinning = array('d')
        binwidth = 200
        NBins = (14000 / binwidth) - ((1040 / binwidth) + 1)
        NBins = int(NBins)
        for i in range(NBins + 1):
            fitbinning.append(1050 + i * binwidth)

        for i in range(len(channels)):
            SHists[i] = SHists[i].Rebin(NBins, "new binning", fitbinning)
        for i in range(len(Backgrounds)):
            BHists[i] = BHists[i].Rebin(NBins, "new binning", fitbinning)

        if (includeData):
            DataHist = DataHist.Rebin(NBins, "new binning", fitbinning)

    canv = TCanvas(plottitle, plottitle, canvX, canvY)

    yplot = 0.7
    yratio = 0.3
    ymax = 1.0
    xmax = 1.0
    xmin = 0.0
    if (ratio):
        plotpad = TPad("plotpad", "Plot", xmin, ymax - yplot, xmax, ymax)
        ratiopad = TPad("ratiopad", "Ratio", xmin, ymax - yplot - yratio, xmax,
                        ymax - yplot)
    else:
        plotpad = TPad("plotpad", "Plot", xmin, ymax - yplot - yratio, xmax,
                       ymax)

    plotpad.SetTopMargin(0.08)
    plotpad.SetLeftMargin(0.1)
    plotpad.SetRightMargin(0.05)
    plotpad.SetTicks()
    plotpad.Draw()

    if (ratio):
        plotpad.SetBottomMargin(0.016)
        ratiopad.SetTopMargin(0.016)
        ratiopad.SetBottomMargin(0.35)
        ratiopad.SetLeftMargin(0.1)
        ratiopad.SetRightMargin(0.05)
        ratiopad.SetTicks()
        ratiopad.Draw()
    else:
        plotpad.SetBottomMargin(0.1)

    if (logY):
        plotpad.SetLogy()
        canv.SetLogy()
    if ('-logX' in xTitle):
        plotpad.SetLogx()
        if (ratio):
            ratiopad.SetLogx()
        canv.SetLogx()

    drawOptions = "HE"

    stack = THStack(plottitle, plottitle)

    BHist = THStack(plottitle, plottitle)

    # for i in range(len(Backgrounds)):
    for i in stackOrder:
        # BHists[i].SetFillColor(BGColors[i])
        BHists[i].SetLineColor(BGColors[i])
        BHist.Add(BHists[i], 'Hist')

    BHist.SetTitle(plottitle)

    BHistErr = BHists[0].Clone()
    for i in range(1, len(Backgrounds)):
        BHistErr.Add(BHists[i])

    BHistErr.SetFillStyle(3204)
    BHistErr.SetFillColor(rt.kGray + 2)
    BHistErr.SetLineColor(1)

    BGMax = BHist.GetMaximum()
    SIGMax = 0
    #if(VV):       #new
    #    SIGMax=VVsum.GetMaximum()
    #else:
    for i in range(len(channels)):
        tmpmax = SHists[i].GetMaximum()
        if (tmpmax > SIGMax):
            SIGMax = tmpmax
    if (scaleVV):
        SIGMax = SIGMax * VVScale
    if (logY):
        MAX = 0.9 * float(10**(magnitude(max(BGMax, SIGMax)) + 1))
        MIN = float(10**(magnitude(max(BGMax, SIGMax)) - 5))
        MIN += float(10**(magnitude(MIN)))
        legendMIN = math.log(max(BGMax, SIGMax)) / math.log(MAX)
    else:
        MAX = (1.0 / 0.8) * max(BGMax, SIGMax)
        legendMIN = 0.7
        MIN = 0.
    legendMIN = (legendMIN * 0.7) + 0.3 - 0.016

    legend = TLegend(0.5, 0.75, 0.85, 0.89)
    legend.SetFillStyle(0)
    legend.SetTextSize(0.02)
    legend.SetMargin(0.4)
    legend.SetNColumns(2)
    legend.SetColumnSeparation(0.3)

    if (includeData):
        DataHist.SetMarkerStyle(8)
        DataHist.SetLineColor(1)
        DataHist.SetTitle(plottitle)

    if VV:
        for i in range(len(channels)):
            if (i == 0):
                VVsum = SHists[i].Clone()
            else:
                VVsum.Add(SHists[i])
        legentry = 'VVjj'
        if (scaleVV):
            VVsum.Scale(VVScale)
            legentry += ' *%0.f' % VVScale
        VVsum.SetLineColor(1)
        VVsum.SetLineStyle(plotstyle[0][1])
        VVsum.SetLineWidth(2)
        legend.AddEntry(VVsum, legentry)
    else:
        for i in range(len(channels)):
            SHists[i].SetLineColor(plotstyle[i][0])
            SHists[i].SetLineStyle(plotstyle[i][1])
            SHists[i].SetLineWidth(2)
            legentry = "%sjj" % channelTex[channels[i]]
            if (scaleVV):
                SHists[i].Scale(VVScale)
                legentry += ' *%.2E' % VVScale
            legend.AddEntry(SHists[i], legentry)

    for i in stackOrder:
        legend.AddEntry(BHists[i], BGTeX[i], "f")
    legend.AddEntry(BHistErr, "stat. Uncertainty", "f")

    if (includeData):
        legend.AddEntry(DataHist, "Data", "lep")

    canv.SetTitle(plottitle)

    BHistErr.GetYaxis().SetTitle('Events')
    BHistErr.GetYaxis().SetRangeUser(MIN, MAX)
    BHistErr.GetYaxis().SetTitleFont(43)
    BHistErr.GetYaxis().SetTitleSize(yTitleSize)
    BHistErr.GetYaxis().SetTitleOffset(yTitleOffset)
    BHistErr.GetYaxis().SetLabelFont(43)
    BHistErr.GetYaxis().SetLabelSize(yLabelSize)
    if (ratio):
        BHistErr.GetXaxis().SetTitleSize(0.0)
        BHistErr.GetXaxis().SetLabelSize(0.0)
    else:
        BHistErr.GetXaxis().SetTitle(xTitle)
        BHistErr.GetXaxis().SetTitleFont(43)
        BHistErr.GetXaxis().SetTitleSize(xTitleSize)
        # BHistErr.GetXaxis().SetTitleOffset(xTitleOffset)
        BHistErr.GetXaxis().SetTitleOffset(1.2)
        BHistErr.GetXaxis().SetLabelFont(43)
        BHistErr.GetXaxis().SetLabelSize(xLabelSize)
        # BHistErr.GetXaxis().SetTickLength(0.08)
        # BHistErr.GetXaxis().SetNdivisions(506)

    if (YRangeUser):
        BHistErr.GetYaxis().SetRangeUser(Ymin, Ymax)
    if (XRangeUser):
        BHistErr.GetXaxis().SetRangeUser(Xmin, Xmax)

    plotpad.cd()

    BHistErr.Draw("E2")
    BHist.Draw("HistSAME")
    BHistErr.Draw("E2SAME")

    if (VV):
        VVsum.Draw("SAME" + drawOptions)
    elif ('-noSig' not in xTitle):
        for i in range(len(channels)):
            SHists[i].Draw("SAME" + drawOptions)

    if (includeData):
        DataHist.Draw("APE1SAME")

    plotpad.RedrawAxis()
    if (ratio):
        ratiopad.cd()

        if (includeData):
            ratioHist = DataHist.Clone()
        else:
            ratioHist = BHistErr.Clone()
        ratioHist.SetLineColor(rt.kBlack)
        # ratioHist.Sumw2()
        ratioHist.SetStats(0)
        ratioHist.Divide(BHistErr)
        ratioHist.SetMarkerStyle(21)
        ratioHist.SetMarkerSize(0.7)

        #Yaxis
        ratioHist.GetYaxis().SetRangeUser(0.3, 1.7)
        ratioHist.GetYaxis().SetTitle("Data/BG")
        ratioHist.GetYaxis().CenterTitle()
        ratioHist.GetYaxis().SetTitleFont(43)
        ratioHist.GetYaxis().SetTitleSize(yTitleSize)
        ratioHist.GetYaxis().SetTitleOffset(yTitleOffset)
        ratioHist.GetYaxis().SetLabelFont(43)
        ratioHist.GetYaxis().SetLabelSize(yLabelSize)
        ratioHist.GetYaxis().SetNdivisions(506)
        #Xaxis
        ratioHist.GetXaxis().SetTitle(xTitle)
        ratioHist.GetXaxis().SetTitleFont(43)
        ratioHist.GetXaxis().SetTitleSize(xTitleSize)
        ratioHist.GetXaxis().SetTitleOffset(xTitleOffset)
        ratioHist.GetXaxis().SetLabelFont(43)
        ratioHist.GetXaxis().SetLabelSize(xLabelSize)
        ratioHist.GetXaxis().SetTickLength(0.08)
        ratioHist.GetXaxis().SetNdivisions(506)

        # if(YRangeUser):
        #     ratioHist.GetYaxis().SetRangeUser(Ymin,Ymax)
        if (XRangeUser):
            ratioHist.GetXaxis().SetRangeUser(Xmin, Xmax)
            ratioXMin = Xmin
            ratioXMax = Xmax
        else:
            ratioXMin = ratioHist.GetXaxis().GetXmin()
            ratioXMax = ratioHist.GetXaxis().GetXmax()
        ratioHist.Draw("ep")

        zeropercent = TLine(ratioXMin, 1, ratioXMax, 1)
        zeropercent.Draw()
        plus10percent = TLine(ratioXMin, 1.1, ratioXMax, 1.1)
        plus10percent.SetLineStyle(rt.kDashed)
        plus10percent.Draw()
        minus10percent = TLine(ratioXMin, 0.9, ratioXMax, 0.9)
        minus10percent.SetLineStyle(rt.kDashed)
        minus10percent.Draw()

    canv.cd()
    gPad.RedrawAxis()
    legend.Draw()

    latex = TLatex()
    latex.SetNDC(kTRUE)
    latex.SetTextSize(20)
    latex.DrawLatex(0.69, 0.953, "%.2f fb^{-1} (13 TeV)" % lumi)
    latex.DrawLatex(0.1, 0.953, "private work")

    lastcut = 'nocuts'
    for cut in cutnames:
        if cut in plotdir:
            lastcut = cut

    if (not (lastcut == 'nocuts') and cutname):
        # latex.SetTextSize(0.03)
        latex.SetTextSize(15)
        for l in range(cutnames.index(lastcut) + 1):
            latex.DrawLatex(0.12, 0.8 - l * 0.04, cuts[cutnames[l]])

    canv.Update()
    canv.Print(outputPath + '/%s_%s.pdf' % (plotdir, plot))
    #prevents memory leak in Canvas Creation/Deletion
    #see: https://root.cern.ch/root/roottalk/roottalk04/2484.html
    gSystem.ProcessEvents()
    if (ratio):
        del ratiopad
    del plotpad, canv
    # gc.collect()
    return 'done!'
def saveToFile(correctionFactors, analysisType, bjetbin):
    stringForFile = ''
    fileName = fileTemplate % (analysisType, bjetbin)
    stringForFile += str(correctionFactors) + '\n'
    import json
    stringForFile =  json.dumps(correctionFactors, sort_keys=True, indent=4)
    outputFile = open(fileName, 'w')
    outputFile.write(stringForFile)
    outputFile.close()
        
    
if __name__ == "__main__":
    from optparse import OptionParser
    gROOT.SetBatch(True)
    gROOT.ProcessLine('gErrorIgnoreLevel = 1001;')
   
    
    parser = OptionParser()
    parser.add_option("-b", "--bjetbin", dest="bjetbin", default='2m',
                  help="set b-jet multiplicity for analysis. Options: exclusive: 0-3, inclusive (N or more): 0m, 1m, 2m, 3m, 4m")
    parser.add_option("-a", "--analysisType", dest="analysisType", default='EPlusJets',
                  help="set analysis type: EPlusJets or MuPlusJets")
    parser.add_option("-t", "--test",
                  action="store_true", dest="test", default=False,
                  help="Run test")
    translateOptions = {
                        '0':'0btag',
                        '1':'1btag',
                        '2':'2btags',
                        '3':'3btags',
Пример #15
0
def main():
    ##Both conservative and not conservative will give same efficiency shapes for SM
    get_tot_eff()
    #get_tot_eff_alternate_model(scenario, model_indx, conservative)


if __name__ == '__main__':
    scenario = sys.argv[1]
    model_indx = sys.argv[2]
    variation_range = sys.argv[3]

    conservative = None
    if variation_range == 'large':
        conservative = True
    elif variation_range == 'one_sigma':
        conservative = False
    else:
        raise Exception(
            "The value of variation_range not recognised, only 'large' or 'one_sigma' allowed!"
        )

    print(scenario, model_indx, variation_range, conservative)

    scenarios = ['CVR', 'CSR', 'CSL', 'CT', 'SM']
    if scenario not in scenarios:
        raise Exception('Scenario not in Scenarios')

    gROOT.ProcessLine(".x lhcbStyle2D.C")
    gStyle.SetPaintTextFormat("1.3f")
    main()
Пример #16
0
    def write_root(self, path):
        gROOT.ProcessLine('struct TreeStruct {\
				int runNo;\
				int layer;\
				int gemroc;\
				int tiger;\
				int channel;\
				int tac;\
				float tcoarse;\
				float tcoarse_10b;\
				float ecoarse;\
				float tfine;\
				float efine;\
				float charge_SH;\
				int count;\
				int count_ori;\
				int count_new;\
				int timestamp;\
				int l1ts_min_tcoarse;\
				int lasttigerframenum;\
				int local_l1_count;\
				int count_mismatch;\
				float delta_coarse;\
				int count_missing_trailer;\
				int subRunNo;\
                                int l1_framenum;\
                                int trailer_tiger;\
				};')
        from ROOT import TreeStruct

        rname = path.replace(".dat", ".root")

        # subRunNo = int(path.split("_")[7])
        subRunNo = self.SUBRUN

        # run = int(path.split("_")[6].split("/")[0])
        # print run

        rootFile = ROOT.TFile(rname, 'recreate')
        tree = ROOT.TTree('tree', '')
        mystruct = TreeStruct()

        for key in TreeStruct.__dict__.keys():
            if '__' not in key:
                formstring = '/F'
                if isinstance(mystruct.__getattribute__(key), int):
                    formstring = '/I'
                tree.Branch(key, AddressOf(mystruct, key), key + formstring)

        statinfo = os.stat(path)
        packet_header = -1
        packet_tailer = -1
        packet_udp = -1
        l1count = -1

        l1count_new = []
        lschannel = []
        lstac = []
        lstcoarse = []
        lstcoarse_10b = []
        lsecoarse = []
        lstfine = []
        lsefine = []
        lscharge_SH = []
        lstigerid = []
        lsl1ts_min_tcoarse = []
        lslasttigerframenum = []
        lscount_mismatch = []
        lsdelta_coarse = []
        l1timestamp = -1
        gemroc = -1
        l1framenum = -1
        trailer_tiger = -1

        pre_timestamp = 0
        pre_pretimestamp = 0

        tiger_framenum = -1
        prev_tiger_framenum = -1
        prev2_tiger_framenum = -1
        prev3_tiger_framenum = -1

        count_missing_trailer = 0

        hitcounter = 0
        max_hitcount = 1000000000
        flag_swap1 = False
        flag_swap2 = False
        firstPacket = True

        firstData = False
        print_debug = False

        with open(path, 'rb') as f:
            for i in range(0, statinfo.st_size // 8):
                data = f.read(8)
                # hexdata = binascii.hexlify(data)
                if sys.version_info[0] == 2:
                    hexdata = str(binascii.hexlify(data))
                else:
                    hexdata = str(binascii.hexlify(data), 'ascii')
                string = "{:064b}".format(int(hexdata, 16))
                inverted = []
                for i in range(8, 0, -1):
                    inverted.append(string[(i - 1) * 8:i * 8])
                string_inv = "".join(inverted)
                int_x = int(string_inv, 2)

                # for x in range(0, len(hexdata) - 1, 16):
                #     int_x = 0
                #     for b in range(7, 0, -1):
                #         hex_to_int = (int(str(hexdata[x + b * 2]), 16)) * 16 + int(str(hexdata[x + b * 2 + 1]), 16)
                #         int_x = (int_x + hex_to_int) << 8
                #
                #     hex_to_int = (int(str(hexdata[x]), 16)) * 16 + int(str(hexdata[x + 1]), 16)  # acr 2017-11-17 this should fix the problem
                #     int_x = (int_x + hex_to_int)

                ##############################################################################################
                ##																							##
                ##								TRIGGER-LESS DECODE											##
                ##																							##
                ##############################################################################################

                if (((int_x & 0xFF00000000000000) >> 59) == 0x00
                        and self.MODE == 0):
                    mystruct.runNo = self.RUN
                    mystruct.gemroc = self.GEMROC_ID
                    mystruct.tiger = (int_x >> 56) & 0x7
                    mystruct.channel = (int_x >> 48) & 0x3F
                    mystruct.tac = (int_x >> 46) & 0x3
                    mystruct.tcoarse = (int_x >> 30) & 0xFFFF
                    mystruct.ecoarse = (int_x >> 20) & 0x3FF
                    mystruct.tfine = (int_x >> 10) & 0x3FF
                    mystruct.efine = int_x & 0x3FF
                    mystruct.tcoarse_10b = (int_x >> 30) & 0x3FF

                    if (((int_x >> 20) & 0x3FF) - ((int_x >> 30) & 0x3FF)) > 0:
                        mystruct.delta_coarse = (((int_x >> 20) & 0x3FF) -
                                                 ((int_x >> 30) & 0x3FF))
                    else:
                        mystruct.delta_coarse = (((int_x >> 20) & 0x3FF) - (
                            (int_x >> 30) & 0x3FF)) + 1024
                    temp_ecoarse = mystruct.ecoarse
                    mystruct.charge_SH = int_x & 0x3FF

                    if (self.GEMROC_ID < 4):
                        mystruct.layer = 1
                    elif (self.GEMROC_ID > 3):
                        mystruct.layer = 2
                    if (self.GEMROC_ID > 11):
                        mystruct.layer = 0

                    tree.Fill()

                ##############################################################################################
                ##############################################################################################
                ##############################################################################################
                ##############################################################################################

                ##############################################################################################
                ##																							##
                ##								TRIGGER-MATCH DECODE										##
                ##																							##
                ##############################################################################################

                if (self.MODE == 1):
                    if (((int_x & 0xE000000000000000) >> 61) == 0x6):
                        # print "enter header"
                        packet_header = 1
                        LOCAL_L1_COUNT_31_6 = int_x >> 32 & 0x3FFFFFF
                        LOCAL_L1_COUNT_5_0 = int_x >> 24 & 0x3F
                        LOCAL_L1_COUNT = (
                            LOCAL_L1_COUNT_31_6 << 6) + LOCAL_L1_COUNT_5_0
                        LOCAL_L1_TIMESTAMP = int_x & 0xFFFF
                        # print("local l1 count {}".format(LOCAL_L1_COUNT))
                        pre_pretimestamp = pre_timestamp
                        pre_timestamp = l1timestamp
                        # pre_l1count = l1count
                        l1count = LOCAL_L1_COUNT
                        l1timestamp = LOCAL_L1_TIMESTAMP

                        if firstData:
                            if print_debug:
                                print(
                                    "WARNING: not able to record last tiger frame number of previous packet: no hits from TIGER 0-3 (L1_count={})!!!!!!!!!!!!!!!"
                                    .format(LOCAL_L1_COUNT))

                        firstData = True  ## Header flags that next line will be first data word of the packet

                        if len(lschannel) > 0:
                            lschannel = []
                            lstac = []
                            lstcoarse = []
                            lsecoarse = []
                            lstfine = []
                            lsefine = []
                            lstcoarse_10b = []
                            lscharge_SH = []
                            lstigerid = []
                            lsl1ts_min_tcoarse = []
                            lslasttigerframenum = []
                            lscount_mismatch = []
                            l1count_new = []
                            lsdelta_coarse = []

                    if (((int_x & 0xC000000000000000) >> 62) == 0x0
                            and packet_header == 1
                            and packet_udp != 1):  ## DATA word
                        LOCAL_L1_TS_minus_TIGER_COARSE_TS = LOCAL_L1_TIMESTAMP - (
                            (int_x >> 32) & 0xFFFF)
                        # print "enter DATA"
                        lstigerid.append((int_x >> 59) & 0x7)
                        lschannel.append((int_x >> 50) & 0x3F)
                        lstac.append((int_x >> 48) & 0x3)
                        lsecoarse.append((int_x >> 20) & 0x3FF)
                        lstfine.append((int_x >> 10) & 0x3FF)
                        lsefine.append(int_x & 0x3FF)
                        lslasttigerframenum.append((int_x >> 56) & 0x7)

                        lscharge_SH.append(int_x & 0x3FF)
                        temp_ecoarse = (int_x >> 20) & 0x3FF
                        lstcoarse_10b.append(((int_x >> 32) & 0x3FF))
                        temp_tcoarse = ((int_x >> 32) & 0x3FF)

                        tcoarse = (int_x >> 32) & 0xFFFF
                        ecoarse = (int_x >> 20) & 0x3FF
                        if (((int_x >> 20) & 0x3FF) -
                            ((int_x >> 32) & 0x3FF)) > 0:
                            lsdelta_coarse.append(((int_x >> 20) & 0x3FF) -
                                                  ((int_x >> 32) & 0x3FF))
                        else:
                            lsdelta_coarse.append(((int_x >> 20) & 0x3FF) -
                                                  ((int_x >> 32) & 0x3FF) +
                                                  1024)

                        lstcoarse.append(tcoarse)

                        count_mismatch = 0

                        lsl1ts_min_tcoarse_to_append = LOCAL_L1_TIMESTAMP - tcoarse
                        l1count_new_to_append = l1count

                        if int_x == 0:
                            print(
                                "WARNING: DATA with all zeros (subRun = {}, L1_count = {})"
                                .format(subRunNo, LOCAL_L1_COUNT))
                        else:
                            tiger_framenum = (int_x >> 56) & 0x7
                            if firstData:
                                prev3_tiger_framenum = prev2_tiger_framenum
                                prev2_tiger_framenum = prev_tiger_framenum
                                if (
                                        int_x >> 59
                                ) & 0x7 < 4:  ## store 2 previous tiger frame number (only from TIGER 0-3)
                                    prev_tiger_framenum = tiger_framenum
                                else:
                                    if print_debug:
                                        print(
                                            "WARNING: not able to record last tiger frame number of this packet: no hits from TIGER 0-3 (L1_count={})!!!!!!!!!!!!!!!"
                                            .format(LOCAL_L1_COUNT))

                                firstData = False

                            ########################################
                            ##         PACKETS MATCHING           ##
                            ########################################

                            ## Start from alignment of previous packet
                            if ((int_x >> 59) & 0x7 > 3):
                                if flag_swap1:
                                    temp_diff = pre_timestamp - tcoarse
                                elif flag_swap2:
                                    temp_diff = pre_pretimestamp - tcoarse
                                else:
                                    temp_diff = LOCAL_L1_TIMESTAMP - tcoarse
                            else:
                                temp_diff = lsl1ts_min_tcoarse_to_append  ## TIGER 0-3 always take the current l1ts

                            ## Find correct packet
                            ## performed only when lsl1ts_min_tcoarse is not inside the trigger window (roll-over taken into account)
                            if (not (
                                (temp_diff > 1299 and temp_diff < 1567) or
                                (temp_diff < -63960 and temp_diff > -64240))):

                                if firstPacket:  ## avoid packets correction for first packet
                                    pass  ## wrong entries in first packet should be discarded since they cannot be corrected
                                else:
                                    # print("Try SWAP 0")         					## try swap packets by 0
                                    temp_diff = LOCAL_L1_TIMESTAMP - tcoarse
                                    if ((temp_diff > 1299 and temp_diff < 1567)
                                            or (temp_diff < -63960
                                                and temp_diff > -64240)):
                                        if flag_swap1 == True or flag_swap2 == True:
                                            print(
                                                "SWAP 0 activated (L1_count={})"
                                                .format(LOCAL_L1_COUNT))
                                        flag_swap1 = False
                                        flag_swap2 = False
                                    else:
                                        # print("Try SWAP 1")         					## try swap packets by 1
                                        temp_diff = pre_timestamp - tcoarse
                                        if ((temp_diff > 1299
                                             and temp_diff < 1567)
                                                or (temp_diff < -63960
                                                    and temp_diff > -64240)):
                                            if flag_swap1 == False:
                                                print(
                                                    "SWAP 1 activated (L1_count={})"
                                                    .format(LOCAL_L1_COUNT))
                                            flag_swap1 = True
                                            flag_swap2 = False
                                        else:
                                            # print("Try SWAP 2")       					## try swap packets by 2
                                            temp_diff = pre_pretimestamp - tcoarse
                                            if ((temp_diff > 1299
                                                 and temp_diff < 1567) or
                                                (temp_diff < -63960
                                                 and temp_diff > -64240)):
                                                if flag_swap2 == False:
                                                    print(
                                                        "SWAP 2 activated (L1_count={})"
                                                        .format(
                                                            LOCAL_L1_COUNT))
                                                flag_swap1 = False
                                                flag_swap2 = True
                                            else:
                                                if self.warning_print_MAX != 0:
                                                    print(
                                                        "WARNING: not able to correct packet (L1_count={}) !!!!!!!!!!!!!!!"
                                                        .format(
                                                            LOCAL_L1_COUNT))
                                                    self.warning_print_MAX = self.warning_print_MAX - 1

                            ## Apply packet correction to data of TIGER 4-7
                            if ((int_x >> 59) & 0x7 > 3
                                ):  ## correct packet for data of TIGER 4-7
                                if not (flag_swap1 or
                                        flag_swap2):  ## apply SWAP by 0 packet
                                    lsl1ts_min_tcoarse_to_append = LOCAL_L1_TIMESTAMP - tcoarse  ## use l1ts of current packet
                                    l1count_new_to_append = l1count  ## use l1count of current packet
                                    count_mismatch = 0
                                elif flag_swap1:  ## apply SWAP by 1 packet
                                    lsl1ts_min_tcoarse_to_append = pre_timestamp - tcoarse  ## use l1ts of previous packet
                                    l1count_new_to_append = l1count - 1  ## use l1count of previous packet
                                    count_mismatch = 1
                                    if tiger_framenum != prev2_tiger_framenum:
                                        if print_debug:
                                            print(
                                                "TIGER framecount not matched (SWAP1: L1_count={}: {} vs {}) !!!!!!!!!!!!!!!"
                                                .format(
                                                    LOCAL_L1_COUNT,
                                                    tiger_framenum,
                                                    prev2_tiger_framenum))
                                elif flag_swap2:  ## apply SWAP by 2 packets
                                    lsl1ts_min_tcoarse_to_append = pre_pretimestamp - tcoarse  ## use l1ts of 2 previous packet
                                    l1count_new_to_append = l1count - 2  ## use l1count of 2 previous packet
                                    count_mismatch = 2
                                    if tiger_framenum != prev3_tiger_framenum:
                                        if print_debug:
                                            print(
                                                "TIGER framecount not matched (SWAP2: L1_count={}: {} vs {}) !!!!!!!!!!!!!!!"
                                                .format(
                                                    LOCAL_L1_COUNT,
                                                    tiger_framenum,
                                                    prev3_tiger_framenum))
                                else:
                                    print(
                                        "Swap ERROR: a problem occurred in swap logic (subRun={}, L1_count={}) !!!!!!!!!!!!!!!"
                                        .format(subRunNo, LOCAL_L1_COUNT))

                            ## Correct counters roll-over
                            if (lsl1ts_min_tcoarse_to_append < 0):
                                if ((int_x >> 59) & 0x7 > 3):
                                    if flag_swap1:
                                        lsl1ts_min_tcoarse_to_append = pre_timestamp - tcoarse + 2**16
                                    if flag_swap2:
                                        lsl1ts_min_tcoarse_to_append = pre_pretimestamp - tcoarse + 2**16
                                    if not (flag_swap1 or flag_swap2):
                                        lsl1ts_min_tcoarse_to_append = LOCAL_L1_TIMESTAMP - tcoarse + 2**16
                                else:
                                    lsl1ts_min_tcoarse_to_append = LOCAL_L1_TIMESTAMP - tcoarse + 2**16

                        #####################################################################################################################
                        #####################################################################################################################
                        #####################################################################################################################

                        lsl1ts_min_tcoarse.append(lsl1ts_min_tcoarse_to_append)
                        l1count_new.append(l1count_new_to_append)

                        lscount_mismatch.append(count_mismatch)

                    if (
                        ((int_x & 0xE000000000000000) >> 61) == 0x7
                    ):  ## TRAILER WORD --> sometimes is missing --> DO NOT USE
                        # print "enter trailer"
                        packet_tailer = 1
                        l1framenum = (int_x >> 37) & 0xFFFFFF
                        trailer_tiger = (int_x >> 27) & 0x7
                        gemroc = (int_x >> 32) & 0x1F

                    if (((int_x & 0xF000000000000000) >> 60
                         ) == 0x4):  ## UDP WORD --> used to flag end of packet
                        # print "enter UDP"
                        if packet_tailer == 0:
                            count_missing_trailer = count_missing_trailer + 1
                            print(
                                "WARNING: missing trailer word (subRun = {}, L1 count = {})!!!!!!!!!!!!!!!"
                                .format(subRunNo, LOCAL_L1_COUNT))
                        packet_udp = 1
                    # pre_udp_packet = udp_packet
                    # udp_packet = (((int_x >> 32)&0xFFFFF) + ((int_x >> 0) & 0xFFFFFFF))

                    if (packet_header == 1
                            and packet_udp == 1):  ## Fill ROOT file
                        for x in range(len(lstac)):
                            mystruct.channel = lschannel.pop()
                            mystruct.tac = lstac.pop()
                            mystruct.tcoarse = lstcoarse.pop()
                            mystruct.ecoarse = lsecoarse.pop()
                            mystruct.tfine = lstfine.pop()
                            mystruct.efine = lsefine.pop()
                            mystruct.tcoarse_10b = lstcoarse_10b.pop()
                            mystruct.charge_SH = lscharge_SH.pop()
                            mystruct.tiger = lstigerid.pop()
                            mystruct.l1ts_min_tcoarse = lsl1ts_min_tcoarse.pop(
                            )
                            mystruct.lasttigerframenum = lslasttigerframenum.pop(
                            )
                            mystruct.count_mismatch = lscount_mismatch.pop()
                            mystruct.count_new = l1count_new.pop()
                            mystruct.delta_coarse = lsdelta_coarse.pop()

                            mystruct.count_missing_trailer = count_missing_trailer
                            mystruct.local_l1_count = LOCAL_L1_COUNT
                            mystruct.count_ori = l1count
                            mystruct.count = mystruct.count_new
                            mystruct.timestamp = l1timestamp
                            mystruct.gemroc = self.GEMROC_ID  # previously was gemroc value from trailer word
                            mystruct.runNo = self.RUN
                            mystruct.subRunNo = subRunNo
                            mystruct.l1_framenum = l1framenum
                            mystruct.trailer_tiger = trailer_tiger
                            """
                            if(gemrocid<4):
                                mystruct.layer_id = 1
                            elif(gemrocid>3):
                                mystruct.layer_id = 2
                            if(gemrocid>11):
                                mystruct.layer_id = 0
                            """

                            if (self.GEMROC_ID < 4):
                                mystruct.layer = 1
                            elif (self.GEMROC_ID > 3):
                                mystruct.layer = 2
                            if (self.GEMROC_ID > 11):
                                mystruct.layer = 0

                            hitcounter = hitcounter + 1
                            if (hitcounter > max_hitcount):
                                sys.stderr.write("Increase max hit counter \n")
                                continue
                            # print "PRE FILL"
                            tree.Fill()
                        # print "POST FILL"
                        packet_header = 0
                        packet_tailer = 0
                        packet_udp = 0
                        firstPacket = False

        # print("Writing to ROOT file...")
        rootFile.Write()
        rootFile.Close()
Пример #17
0
import sys, os

from ROOT import gROOT
gROOT.ProcessLine(".x " + os.environ['MYSW_DIR'] + "/Utils/rootlogon.C")

from ROOT import Main

maker = Main.Maker()

# BNBComisc

maker.SetInputFile(
    "/Users/deltutto/RealWork/CCInclusiveEventSelection/Files/Input/ubxsec_output_mc_bnbcosmic_mcc8.9_500k.root"
)
maker.SetOutputFile(
    "/Users/deltutto/RealWork/CCInclusiveEventSelection/Files/Output/ubxsecana_output_bnbcosmic_mcc8.9_500k.root"
)

maker.SetEntries(50000)
maker.SetInitialEntry(0)

maker.SetBeamSpillStart(3.2)
maker.SetBeamSpillEnd(4.8)
maker.SetFlashShift(0.)
maker.SetGainCalibration(198)
maker.SetCalculatePOT(True)
maker.SetIsData(False)
maker.SetExtraWeight(1.028)
# Flux correction

maker.SetTargetFluxSystematic("total")
Пример #18
0
    def test1NestedNamespace(self):
        """Test nested namespace lookup"""

        gROOT.ProcessLine('#include "NestedNamespace.h"')
        self.assert_(ROOT.ABCDEFG.ABCD.Nested)
Пример #19
0
                    '--timerequest',
                    help='Time request for running a job at HTCondor',
                    required=False)
parser.add_argument('-memory',
                    '--memoryrequest',
                    help='Memory request for running a job at HTCondor',
                    required=False)

memoryrequest = ""
timerequest = ""

### Getting changes for requests in memory and time than default ones and other options stated beforehand
args = parser.parse_args()

### Switch off recovery mode in ROOT, if file is corrupted we don't want to keep even its ashes.
gROOT.ProcessLine("gEnv->SetValue(\"TFile.Recover\", 0);")


###### Method for creating HTCondor submission script
###########################################################
def CreateSubmissionScript(Pathtodirectory, DirectoryName, CMSSW_BASE,
                           cmsRunCommand, FileName,
                           CreateEndOfSubmissionScript):
    '''Create job submission file for HTCondor in sample subdirectory'''
    file = open(DirectoryName + "/" + FileName + ".submit", "w")
    file.write("universe            = vanilla\n \n")
    file.write(
        "transfer_executable = True \nshould_transfer_files   = IF_NEEDED \nwhen_to_transfer_output = ON_EXIT\n"
    )
    file.write("requirements = OpSysAndVer == \"SL6\"\ngetenv = true \n")
    file.write("batch_name = " + FileName + "\n")
Пример #20
0
def loadFWLite():
    gSystem.Load("libFWCoreFWLite")
    gROOT.ProcessLine('AutoLibraryLoader::enable();')
    gSystem.Load("libFWCoreFWLite")
Пример #21
0
def main(argv):

    print "========================================"
    print "LAT2 started:", time.strftime('%X %x %Z')
    startT = time.clock()
    gROOT.ProcessLine(
        "gErrorIgnoreLevel = 3001;")  # suppress ROOT error messages

    dsNum, subNum, runNum = None, None, None
    fCal, fUpd, fBat, fFor, fPlt, fRaw, fCalPath = 0, 0, 0, 0, 0, 0, 0
    fPaths = [".", "."]
    if len(argv) == 0: return
    for i, opt in enumerate(argv):
        if opt == "-cal":
            fCal = True
            print "Calibration mode."
        if opt == "-upd":
            fUpd = True
            print "File update mode."
        if opt == "-p":
            fPlt = True
            print "Writing plots mode."
        if opt == "-debug":
            debugFiles()
            stopT = time.clock()
            print "Stopped:", time.strftime(
                '%X %x %Z'), "\nProcess time (min):", (stopT - startT) / 60
            exit()
        if opt == "-fitRN":
            fitDBRiseNoise()
            # stopT = time.clock()
            # print "Stopped:",time.strftime('%X %x %Z'),"\nProcess time (min):",(stopT - startT)/60
            exit()
        if opt == "-force":
            fFor = True
            print "Force DB update mode."
        if opt == "-raw":
            fRaw = True
            print "Printing raw peakfinder plots."
        if opt == "-d":
            dsNum = int(argv[i + 1])
            print "Scanning DS-%d" % (dsNum)
        if opt == "-c":
            fCalPath = True
            print "pointing to cal path"
        if opt == "-f":
            print "Scanning DS-%d, run %d" % (dsNum, runNum)
        if opt == "-s":
            dsNum, subNum = int(argv[i + 1]), int(argv[i + 2])
            print "Scanning DS-%d sub-range %d" % (dsNum, subNum)
        if opt == "-p":
            fPaths = [argv[i + 1], argv[i + 2]]
            print "Manual I/O paths set."
        if opt == "-test":
            testDB()
        if opt == "-b":
            fBat = True
            import matplotlib
            if os.environ.get('DISPLAY', '') == '':
                print "No display found. Using non-interactive Agg backend"
                matplotlib.use('Agg')
            print "Batch mode selected."
    global plt
    import matplotlib.pyplot as plt

    if fCal:
        rec = calibrateRuns(dsNum, subNum, fPaths, fBat, fPlt, fRaw)
        ds.setDBRecord(rec, fFor)

    if fUpd:
        updateFile(dsNum, fCalPath)

    stopT = time.clock()
    print "Stopped:", time.strftime(
        '%X %x %Z'), "\nProcess time (min):", (stopT - startT) / 60
Пример #22
0
def setupROOT():
    gSystem.Load("libFWCoreFWLite")
    gROOT.ProcessLine('FWLiteEnabler::enable();')
Пример #23
0
    def ProcessCommandline(self, args, options, db):
        """
        Set configuration variables based on command line options
        """
        # these three arguments are required to be set for every invocation
        self.REVISION = args[1]
        self.INPUT_DIRECTORY = args[2]
        self.INPUT_SMALLFILE_DIRECTORY = args[3]
        self.OUTPUT_DIRECTORY = args[4]

        # fix directories used in MC production
        if self.REVISION == "mc":
            self.ROOTFILE_DIR = "hd_root"
            self.COPY_REST_FILES = False  # sanity check

        # set up output logging
        if options.logfile:
            logging.basicConfig(filename=options.logfile, level=logging.INFO)
            gSystem.RedirectOutput(options.logfile)
        else:
            logging.basicConfig(level=logging.INFO)
        # limit ROOT output
        gROOT.ProcessLine("gErrorIgnoreLevel = 2001;"
                          )  # only output at least "Error" level messages

        # see if we should disable any processing steps
        if (options.disable_plotting):
            self.MAKE_PLOTS = False
        if (options.disable_db_summary):
            self.MAKE_DB_SUMMARY = False
        #if(options.process_run_conditions):
        #    MAKE_RUN_CONDITIONS = True
        if (options.disable_hadd):
            self.MAKE_SUMMED_ROOTFILE = False
        if (options.force):
            self.FORCE_PROCESSING = True
        if (options.save_rest):
            self.COPY_REST_FILES = True
        if (options.merge_increment):
            self.MERGE_INCREMENT = True
        if (options.batch_tempdir):
            self.BATCH_TEMP_DIR = True

        # should we process only one run?
        if (options.run_number):
            try:
                self.RUN_NUMBER = int(options.run_number)
            except ValueError:
                logging.error("Invalid run number = " + options.run_number)
                sys.exit(0)
            if self.RUN_NUMBER <= 0:
                logging.error("Invalid run number = " + options.run_number)
                sys.exit(0)

        # set which data version in the DB this processing run corresponds to
        if (options.version_string):
            try:
                revision = -1
                (run_period, revision_str) = options.version_string.split(",")
                try:
                    revision = int(revision_str)
                except ValueError:
                    logging.error("Invalid revision = " + revision)
                    sys.exit(0)
                self.VERSION_NUMBER = db.GetVersionIDRunPeriod(
                    run_period, revision)
                if (self.VERSION_NUMBER < 0):
                    logging.error("version not found in DB = " +
                                  options.version_string)
                    sys.exit(0)
            except:
                logging.error("Invalid version specification = " +
                              options.version_string)
                raise
                sys.exit(0)
            logging.info(
                "Configured RunPeriod = %s  Revision = %d  ->  VersionID = %d"
                % (run_period, revision, self.VERSION_NUMBER))

        if (options.version_number):
            try:
                self.VERSION_NUMBER = int(options.version_number)
            except ValueError:
                logging.error("Invalid version number = " +
                              options.version_number)
                sys.exit(0)
            if self.VERSION_NUMBER <= 0:
                logging.error("Invalid version number = " +
                              options.version_number)
                sys.exit(0)

        # process a range of runs?
        if options.min_run:
            self.MIN_RUN = int(options.min_run)
            logging.info("Minimum run = %d" % self.MIN_RUN)
        if options.max_run:
            self.MAX_RUN = int(options.max_run)
            logging.info("Maximum run = %d" % self.MAX_RUN)

        if options.nthreads:
            self.NTHREADS = options.nthreads

        if options.noendofjob_processing:
            self.EOR_PROCESSING = False

        if options.root_output_dir:
            self.MERGED_ROOTFILE_OUTPUT_DIRECTORY = options.root_output_dir

        if options.root_trees_to_merge:
            self.ROOT_TREES_TO_MERGE = options.root_trees_to_merge.split(",")
        if options.evio_skims_to_merge:
            self.EVIO_SKIMS_TO_MERGE = options.evio_skims_to_merge.split(",")
        if options.hddm_files_to_merge:
            self.HDDM_FILES_TO_MERGE = options.hddm_files_to_merge.split(",")
Пример #24
0
def GeneralSettings(paintformat="4.2f"):
    gROOT.SetBatch(True)
    gStyle.SetOptStat(0)
    tdr.setTDRStyle()
    gStyle.SetPaintTextFormat(paintformat)
    gROOT.ProcessLine("gErrorIgnoreLevel = 1001;")
Пример #25
0
			liczba2=generator.Gaus(300,60)/1;
			liczba2=int(liczba2)
			if liczba2>liczba:
				self.stworzDane([bool(0)],i,liczba2)
				self.stworzDane([bool(1)],i,liczba)
			else:
				self.stworzDane([bool(0)],i,liczba)
				self.stworzDane([bool(1)],i,liczba2)

struktura="struct DaneZKanalow {"
for i in range(52):
	struktura=struktura+"Bool_t kanal"+str(i)+"op[32]; "
	struktura=struktura+"Bool_t kanal"+str(i)+"nar[32]; "
struktura=struktura+"};"

gROOT.ProcessLine(struktura)
from ROOT import DaneZKanalow

czas=time.strftime("%d.%m.%Y %H:%M:%S")
plik=TFile('daneGener ['+czas+'].root', 'RECREATE')

gener=TRandom3(0)

drzewo=TTree("Zestawy","Drzewo z wygenerowanymi zestawami.")
kanaly=DaneZKanalow()
struktura="kanal0op[32]/B:kanal0nar[32]"
for i in range(51):
	struktura=struktura+":kanal"+str(i+1)+"op[32]"
	struktura=struktura+":kanal"+str(i+1)+"nar[32]"
galaz=drzewo.Branch("Zestaw",kanaly,struktura)
galaz.SetBasketSize(240)
Пример #26
0
   
#
# create dictionary with ratio of smoothed / raw efficiencies
#   argument: dictionary with raw efficiencies
#
from optparse import OptionParser
parser = OptionParser()
parser.add_option("--m3Ratio", dest="m3Ratio", default=-1., type="float", action="store", help="ratio for intermediate mass in SMS models")
parser.add_option("-f", dest="force", default=False, action="store_true", help="replace output file")
(options, args) = parser.parse_args()

filename = args[0]
mydic = pickle.load(file(filename))

from ROOT import gROOT
gROOT.ProcessLine(".L SmoothingUtils.C+")

# output dictionary
newdic = {}

m0s = [ ]
m12s = [ ]
labels = [ ]
# loop over all ht and met values
# in input dictionary
model = None
suffix = None
for btag in mydic:
  for ht in mydic[btag]:
    for met in mydic[btag][ht]:
      # create lists of M0 and M12 values and
                   label='Ratio',
                   xlog=False,
                   outputDir=WORKPATH + 'SymmetryResults/',
                   maxYnumbers=maxY)

    print('>>>>>>>>>> KOLMOGOROV test for ' + labela)
    print('>>>>>>>>>> ' + str(histo1.KolmogorovTest(histo2)))
    print('>>>>>>>>>> Chi2 test for ' + labela)
    print('>>>>>>>>>> ' + str(histo1.Chi2Test(histo2, "WWP")))

    return


if __name__ == "__main__":

    gROOT.ProcessLine('.L ' + GALAPAGOPATH + 'include/tdrstyle.C')
    gROOT.SetBatch(1)
    print('WORKPATH: ' + WORKPATH)
    r.setTDRStyle()

    ###########################
    ####   Parser object   ####
    ###########################
    parser = optparse.OptionParser(
        usage='usage: %prog [opts] FilenameWithSamples', version='%prog 1.0')
    parser.add_option('-t',
                      '--tag',
                      action='store',
                      type=str,
                      dest='tag',
                      default='',
Пример #28
0
import os
import ROOT
from ROOT import gSystem, gROOT

from CMGTools.H2TauTau.proto.plotter.PlotConfigs import SampleCfg
from CMGTools.H2TauTau.proto.plotter.HistCreator import setSumWeights
from CMGTools.H2TauTau.proto.samples.spring16.sms_xsec import get_xsec

from CMGTools.H2TauTau.proto.samples.spring16.htt_common import TT_pow_ext, DYJetsToLL_M50_LO, DYNJets, WJetsToLNu,  WNJets, WWTo2L2Nu, T_tWch, TBar_tWch, VVTo2L2Nu, ZZTo4L, WZTo1L3Nu, WWTo1L1Nu2Q, ZZTo2L2Q, WZTo2L2Q, WZTo1L1Nu2Q, TBarToLeptons_tch_powheg, TToLeptons_tch_powheg, mssm_signals, dy_weight_dict, w_weight_dict

# WJetsToLNu_LO, TToLeptons_tch_amcatnlo, WZTo3LNu_amcatnlo, , WJetsToLNu_HT100to200, WJetsToLNu_HT200to400, WJetsToLNu_HT400to600, WJetsToLNu_HT600toInf, QCD_Mu15, DYJetsToTauTau_M150_LO, DYJetsToLL_M10to50_ext1

if "/sDYReweighting_cc.so" not in gSystem.GetLibraries(): 
    gROOT.ProcessLine(".L %s/src/CMGTools/H2TauTau/python/proto/plotter/DYReweighting.cc+" % os.environ['CMSSW_BASE']);
    from ROOT import getDYWeight

splitDY = False
useDYWeight = False
# data2016G = True

if useDYWeight:
    dy_exps = []
    for njet in xrange(0, 5):
        weight = dy_weight_dict[(njet, 0)]
        dy_exps.append('(geninfo_nup == {njet})*{weight}'.format(njet=njet, weight=weight))
        # dy_exps.append('(geninfo_nup == {njet} && (geninfo_invmass<150. || !(l2_gen_match==5 || l1_gen_lepfromtau)))*{weight}'.format(njet=njet, weight=weight))
        # weight = dy_weight_dict[(njet, 150)]
        # dy_exps.append('(geninfo_nup == {njet} && (geninfo_invmass>=150. && (l2_gen_match==5 || l1_gen_lepfromtau)))*{weight}'.format(njet=njet, weight=weight))

    dy_exp = '*({})'.format(' + '.join(dy_exps))
Пример #29
0
def getCommonInfo(rootfile):

    commoninfo = {}

    gROOT.ProcessLine('gSystem->Load("libRootEventData.so");')
    gROOT.ProcessLine('TFile file("%s");' % rootfile)
    gROOT.ProcessLine('TTree* tree =(TTree*)file.Get("JobInfoTree");')
    gROOT.ProcessLine('TTree* tree1 =(TTree*)file.Get("Event");')
    gROOT.ProcessLine('TBranch* branch =(TBranch*)tree->GetBranch("JobInfo");')
    gROOT.ProcessLine(
        'TBranch* branch1 =(TBranch*)tree1->GetBranch("TEvtHeader");')
    gROOT.ProcessLine('TJobInfo* jobInfo = new TJobInfo();')
    gROOT.ProcessLine('TEvtHeader* evtHeader = new TEvtHeader();')
    gROOT.ProcessLine('branch->SetAddress(&jobInfo);')
    gROOT.ProcessLine('branch1->SetAddress(&evtHeader);')
    gROOT.ProcessLine('branch->GetEntry(0);')
    gROOT.ProcessLine('branch1->GetEntry(0);')
    gROOT.ProcessLine('Int_t num=tree1.GetEntries()')

    #get Boss Version
    commoninfo["bossVer"] = ROOT.jobInfo.getBossVer()
    #get RunId
    commoninfo["runId"] = abs(ROOT.evtHeader.getRunId())
    #get all entries
    commoninfo["eventNum"] = ROOT.num
    #get TotEvtNo
    #commoninfo["TotEvtNo"] = list(i for i in ROOT.jobInfo.getTotEvtNo())
    #get JobOption
    commoninfo["jobOptions"] = list(i for i in ROOT.jobInfo.getJobOptions())

    #set DataType
    commoninfo["dataType"] = 'dst'

    return commoninfo
Пример #30
0
print "Setup complete \nOpened file " + str(
    sys.argv[1]
) + "  \nConverting to .root format and outputing to " + output_file_name

# Setup output branches
PID_v = r.vector('Int_t')()
P_X_v = r.vector('Double_t')()
P_Y_v = r.vector('Double_t')()
P_Z_v = r.vector('Double_t')()
E_v = r.vector('Double_t')()
M_v = r.vector('Double_t')()
P4_v = r.vector('ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float>>')()
Wgt_v = r.vector('Double_t')()

# Create a struct which acts as the TBranch for non-vectors
gROOT.ProcessLine("struct MyStruct{ Int_t n_particles; };")
gROOT.ProcessLine("struct MyFloat{ Float_t weight; };")
from ROOT import MyStruct
from ROOT import MyFloat

# Assign the variables to the struct
s = MyStruct()
event_wgt = MyFloat()
output_tree.Branch('n_particles', AddressOf(s, 'n_particles'), 'n_particles/I')
output_tree.Branch("PID", PID_v)
output_tree.Branch("P_X", P_X_v)
output_tree.Branch("P_Y", P_Y_v)
output_tree.Branch("P_Z", P_Z_v)
output_tree.Branch("E", E_v)
output_tree.Branch("M", M_v)
output_tree.Branch("P4", P4_v)