Modify the steering for the ID Trigger ART tests

To allow easier addition of new output, the steering code have been slightly rewritten
and two duplicte tests have been added using this modified steering.

Trigger/TrigAnalysis/TrigInDetAnalysisUser/share/TIDAdata-run3-offline-vtx.dat

+// emacs: this is -*- c++ -*-
+
+#include "TIDAdata_cuts-offline.dat"
+
+VertexSelection    = 0;
+VertexSelectionRec = 0;
+
+
+
+
+//refChain = "Truth";
+refChain = "Offline";
+//refChain = "Electrons";
+//refChain = "Muons";
+//refChain = "Taus";
+
+
+MinVertices = 0;
+
+
+#include "TIDAdata-chains-run3.dat"
+
+
+InitialiseFirstEvent = 1;
+
+outputFile = "data-output.root";
+DataFiles = { "TrkNtuple-0000.root"};
+//DataSets = {"./"}
+
+
+#include "TIDAbeam.dat"

Trigger/TrigAnalysis/TrigInDetAnalysisUser/share/TIDAdata_cuts-offline.dat

@@ -24,5 +24,5 @@ dumpflag = 1;
 a0v = 10.5;
 z0v = 300.5;
 
-VertexSelection    = 0;
-VertexSelectionRec = 0;
+// VertexSelection    = 0;
+// VertexSelectionRec = 0;

Trigger/TrigAnalysis/TrigInDetAnalysisUser/share/TIDAhisto-panel-vtx.dat

+// emacs: this is -*- c++ -*-                                                                                                                                                                                 
+
+
+panels = { vtx_eff_panel, vtx_res_panel, vtx_kin_panel };
+
+vtx_eff_panel = {
+
+  "ntrax_eff",     "Tracks efficiency",           "xaxis:lin:0:200",      "Number of tracks",                  "yaxis:auto:lin:80:102",       "Vertex finding efficiency" ,
+  "zed_eff",       "Efficiency z",                "xaxis:lin:-175:175",  "Offline vertex z [mm]",             "yaxis:auto:lin:50:102",       "Vertex finding efficiency" ,
+  "mu_eff",        "efficiency vs mu",            "xaxis:lin:auto",      "pileup <#mu>",                      "yaxis:auto:lin:50:102",        "Efficiency"  ,
+
+  //  "nvtx_eff",      "Vertices efficiency",         "xaxis:lin:auto",     "Number of vertices",                 "yaxis:lin:auto:0.5:1.05",   "Vertex finding efficiency" ,                                  
+  //  "lb_eff",       "Efficiency lb",                "xaxis:lin:auto",     "luminosity block",                  "yaxis:lin:auto:0.50:1.05",       "Vertex finding efficiency" ,                              
+
+  "ntrax",        "Number of tracks",    "xaxis:lin:auto",              "Offline track multiplcicty",    "yaxis:log:autow",          "Entries"  ,
+  "zed",          "Vertex z position",   "xaxis:lin:auto:-175:175",     "Offline vertex z [mm]",         "yaxis:log:auto",           "Entries"  ,
+  "mu",            "mu",                 "xaxis:lin:auto",              "pileup <#mu>",                  "yaxis:log:auto",           "Entries"	
+
+};
+
+
+
+vtx_res_panel = {
+
+  "rdz_vs_ntrax/mean",        "Offset z vs N_{tracks}",     "xaxis:lin:auto",     "Offline track multiplicity",  "yaxis:auto:lin:-1:1.", "z_{0} mean [mm]" ,
+  "rdz_vs_zed/mean",          "Offset z vs z",              "xaxis:lin:-175:175", "Offline vertex z [mm]",        "yaxis:auto:lin:-1:1",  "z_{0} mean [mm]" ,
+  "rdz_vs_zed/1d+rebin10",     "Residual z",                 "xaxis:lin:-5:5",   "#Delta z [mm]",                 "yaxis:log:auton",    "(1/N)dN/dz [mm^{-1}]" ,
+
+
+  "rdz_vs_ntrax/sigma",       "Offset z vs N_{tracks}",     "xaxis:lin:auto",     "Offline track multiplicity",  "yaxis:auto:lin:0:2.", "z_{0} resolution [mm]" ,
+  "rdz_vs_zed/sigma",         "Resolution z vs z",          "xaxis:lin:-175:175", "Offline vertex z [mm]",        "yaxis:lin:auto:0:2",       "z_{0} resolution [mm]" ,
+  "rdz_vs_zed/1d+lin+rebin10", "Residual z",                 "xaxis:lin:-5:5",   "#Delta z [mm]",                  "yaxis:lin:auton",    "(1/N)dN/dz [mm^{-1}]"	
+
+};
+
+
+
+vtx_kin_panel = {
+
+  "ntrax",        "Number of tracks",       "xaxis:lin:auto",           "Offline vertex track multiplcicty",   "yaxis:log:autow",   "Entries" ,
+  "zed",          "Vertex z position",      "xaxis:lin:auto:-175:175",  "Offline vertex z [mm]",               "yaxis:log:auto",    "Entries" ,
+  "nvtx",         "Vertices multiplicity",  "xaxis:lin:auto",           "Number of vertices",                  "yaxis:lin:auto",    "Entries" ,
+
+  "ntrax_rec",    "Number of tracks",      "xaxis:lin:auto",            "Trigger vertex track multiplicity",  "yaxis:log:autow",   "Entries" ,
+  "zed_rec",      "Vertex z position",     "xaxis:lin:auto:-175:175",   "Trigger Vertex z [mm]",              "yaxis:log:auto",    "Entries" ,
+  "nvtx_rec",     "Vertices multiplicity", "xaxis:lin:auto",            "Number of vertices",                 "yaxis:lin:auto",    "Entries"
+
+};
+
+

Trigger/TrigValidation/TrigInDetValidation/python/TrigInDetNewArtSteps.py

+#
+# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+#
+
+'''
+Definitions of additional validation steps in Trigger ART tests relevant only for TrigInDetValidation
+The main common check steps are defined in the TrigValSteering.CheckSteps module.
+'''
+
+import os
+import json
+
+from TrigValTools.TrigValSteering.ExecStep import ExecStep
+from TrigAnalysisTest.TrigAnalysisSteps import AthenaCheckerStep
+from TrigValTools.TrigValSteering.Step import Step
+from TrigValTools.TrigValSteering.CheckSteps import RefComparisonStep
+from AthenaCommon.Utils.unixtools import FindFile
+
+##################################################
+# Exec (athena) steps for Reco_tf
+##################################################
+
+class TrigInDetReco(ExecStep):
+
+    def __init__(self, name='TrigInDetReco', postinclude_file='' ):
+        ExecStep.__init__(self, name)
+##        super(TrigInDetReco, self).__init__(name)
+        self.type = 'Reco_tf'
+        self.max_events=-1
+        self.required = True
+        self.threads = 1 # TODO: change to 4
+        self.concurrent_events = 1 # TODO: change to 4
+        self.perfmon = False
+        self.timeout = 18*3600
+        self.slices = []
+        self.preexec_trig = ' '
+        self.postinclude_trig = postinclude_file
+        self.preexec_reco =  ';'.join([
+            'from RecExConfig.RecFlags import rec',
+            'rec.doForwardDet=False',
+            'rec.doEgamma=False',
+            'rec.doMuonCombined=False',
+            'rec.doJetMissingETTag=False',
+            'rec.doTau=False'
+        ])
+
+        self.preexec_aod = ';'.join([
+            self.preexec_reco,
+            'from ParticleBuilderOptions.AODFlags import AODFlags',
+            'AODFlags.ThinGeantTruth.set_Value_and_Lock(False)',
+            'AODFlags.ThinNegativeEnergyCaloClusters.set_Value_and_Lock(False)',
+            'AODFlags.ThinNegativeEnergyNeutralPFOs.set_Value_and_Lock(False)',
+            'AODFlags.ThinInDetForwardTrackParticles.set_Value_and_Lock(False)'
+        ])
+
+        self.preexec_all = ';'.join([
+            'from TriggerJobOpts.TriggerFlags import TriggerFlags',
+            'TriggerFlags.AODEDMSet.set_Value_and_Lock(\\\"AODFULL\\\")',
+        ])
+        self.postexec_trig = "from AthenaCommon.AppMgr import ServiceMgr; ServiceMgr.AthenaPoolCnvSvc.MaxFileSizes=['tmp.RDO_TRIG=100000000000']"
+
+
+        # get the cuttent atlas base release, and the previous base release
+        import os
+        DVERSION=os.getenv('Athena_VERSION')
+        if ( DVERSION == None ) : 
+            AVERSION = "22.0.20"
+        else :
+            BASE=DVERSION[:5]
+            SUB=int(DVERSION[5:])
+            SUB -= 1
+            AVERSION=BASE+str(SUB)
+
+        print( "remapping athena base release version: ", DVERSION, " -> ", AVERSION )
+
+        self.postexec_reco = "from AthenaCommon.AppMgr import ServiceMgr; ServiceMgr.AthenaPoolCnvSvc.MaxFileSizes=['tmp.ESD=100000000000']"
+        self.args = '--outputAODFile=AOD.pool.root --steering="doRDO_TRIG" --asetup "RAWtoESD:Athena,'+AVERSION+'" "ESDtoAOD:Athena,'+AVERSION+'" '
+
+
+    def configure(self, test):
+        chains = '['
+        flags = ''
+        for i in self.slices:
+            if (i=='muon') :
+                chains += "'HLT_mu6_idperf_L1MU6',"
+                chains += "'HLT_mu24_idperf_L1MU20',"
+                chains += "'HLT_mu26_ivarmedium_L1MU20',"
+                chains += "'HLT_mu28_ivarmedium_L1MU20',"
+                flags += 'doMuonSlice=True;'
+            if (i=='electron') :
+                chains +=  "'HLT_e5_etcut_L1EM3',"  ## need an idperf chain once one is in the menu
+                chains +=  "'HLT_e17_lhvloose_nod0_L1EM15VH'," 
+                flags += 'doEgammaSlice=True;'
+            if (i=='tau') :
+                chains +=  "'HLT_tau25_idperf_tracktwo_L1TAU12IM',"
+                chains +=  "'HLT_tau25_idperf_tracktwoMVA_L1TAU12IM',"
+                flags += 'doTauSlice=True;'
+            if (i=='bjet') :
+                chains += "'HLT_j45_ftf_subjesgscIS_boffperf_split_L1J20','HLT_j45_subjesgscIS_ftf_boffperf_split_L1J20',"
+                flags  += 'doBjetSlice=True;'
+            if ( i=='fsjet' or i=='fs' or i=='jet' ) :
+                chains += "'HLT_j45_ftf_L1J15',"
+                flags  += 'doJetSlice=True;'
+            if (i=='beamspot') :
+                chains += "'HLT_beamspot_allTE_trkfast_BeamSpotPEB_L1J15','HLT_beamspot_trkFS_trkfast_BeamSpotPEB_L1J15',"
+                flags  += 'doBeamspotSlice=True;'
+            if (i=='minbias') :
+                chains += "'HLT_mb_sptrk_L1RD0_FILLED',"
+                flags  += 'doMinBiasSlice=True;'
+
+        if ( flags=='' ) : 
+            print( "ERROR: no chains configured" )
+
+        chains += ']'
+        self.preexec_trig = 'doEmptyMenu=True;'+flags+'selectChains='+chains
+
+
+        self.args += ' --preExec "RDOtoRDOTrigger:{:s};" "all:{:s};" "RAWtoESD:{:s};" "ESDtoAOD:{:s};"'.format(
+            self.preexec_trig, self.preexec_all, self.preexec_reco, self.preexec_aod)
+        if (self.postexec_trig != ' '):
+            self.args += ' --postExec "RDOtoRDOTrigger:{:s};" "RAWtoESD:{:s};" '.format(self.postexec_trig, self.postexec_reco)
+        if (self.postinclude_trig != ''):
+            self.args += ' --postInclude "RDOtoRDOTrigger:{:s}" '.format(self.postinclude_trig)
+        super(TrigInDetReco, self).configure(test)
+
+
+##################################################
+# Additional exec (athena) steps - AOD to TrkNtuple
+##################################################
+
+class TrigInDetAna(AthenaCheckerStep):
+    def __init__(self, name='TrigInDetAna', in_file='AOD.pool.root'):
+        AthenaCheckerStep.__init__(self, name, 'TrigInDetValidation/TrigInDetValidation_AODtoTrkNtuple.py')
+        self.max_events=-1
+        self.required = True
+        self.depends_on_previous = False
+        self.input_file = in_file
+
+##################################################
+# Additional post-processing steps
+##################################################
+
+class TrigInDetRdictStep(Step):
+    '''
+    Execute TIDArdict for TrkNtuple files.
+    '''
+    def __init__(self, name='TrigInDetdict', args=None ):
+        super(TrigInDetRdictStep, self).__init__(name)
+        self.args=args + "  -b Test_bin.dat "
+        self.auto_report_result = True
+        self.required = True
+        self.executable = 'TIDArdict'
+
+    def configure(self, test):
+        os.system( 'get_files -data TIDAbeam.dat &> /dev/null' )
+        os.system( 'get_files -data Test_bin.dat &> /dev/null' )
+        os.system( 'get_files -data TIDAdata-chains-run3.dat &> /dev/null' )
+        os.system( 'get_files -data TIDAhisto-panel.dat &> /dev/null' )
+        os.system( 'get_files -data TIDAhisto-panel-vtx.dat &> /dev/null' )
+        os.system( 'get_files -data TIDAhistos-vtx.dat &> /dev/null' )
+        os.system( 'get_files -data TIDAdata-run3.dat &> /dev/null' )
+        os.system( 'get_files -data TIDAdata_cuts.dat &> /dev/null' )
+        os.system( 'get_files -data TIDAdata-run3-offline.dat &> /dev/null' )
+        os.system( 'get_files -data TIDAdata-run3-offline-vtx.dat &> /dev/null' )
+        os.system( 'get_files -data TIDAdata_cuts-offline.dat &> /dev/null' )
+        os.system( 'get_files -jo   TIDAml_extensions.py &> /dev/null' )
+        super(TrigInDetRdictStep, self).configure(test)
+
+
+def json_chains( slice ) : 
+    json_file     = 'TrigInDetValidation/comparitor.json'
+    json_fullpath = FindFile(json_file, os.environ['DATAPATH'].split(os.pathsep), os.R_OK)
+
+    if not json_fullpath:
+        print('Failed to determine full path for input JSON %s', json_file)
+        return None
+        
+    with open(json_fullpath) as f:
+        data = json.load(f)
+       
+    chainmap = data[slice]
+
+    return chainmap['chains']
+
+
+
+class TrigInDetCompStep(RefComparisonStep):
+    '''
+    Execute TIDAcomparitor for data.root files.
+    '''
+    def __init__( self, name='TrigInDetComp', slice=None, args=None, file=None, reference=None ):
+        super(TrigInDetCompStep, self).__init__(name)
+        if reference == None : 
+            self.reference  = file # do we need this any more ??? 
+            self.args  = args + " " + file + "  " + file + " --noref --oldrms "
+        else:
+            self.reference = reference
+            self.args  = args + " " + file + "  " + reference + " --oldrms "
+        self.slice = slice 
+        self.auto_report_result = True
+        self.required   = True
+
+        self.executable = 'TIDAcomparitor'
+    
+
+    def configure(self, test):
+        self.chains = json_chains( self.slice )
+        self.args += " " + self.chains
+        print( "\033[0;32mTIDAcomparitor "+self.args+" \033[0m" )
+        super(TrigInDetCompStep, self).configure(test)
+
+
+
+class TrigInDetCpuCostStep(RefComparisonStep):
+    '''
+    Execute TIDAcpucost for expert-monitoring.root files.
+    '''
+    def __init__(self, name='TrigInDetCpuCost', ftf_times=True):
+        super(TrigInDetCpuCostStep, self).__init__(name)
+        self.input_file = 'expert-monitoring.root'
+##      self.ref_file = 'expert-monitoring.root'   #### need to add reference file here 
+        self.output_dir = 'times'
+        self.args = '--auto '
+        self.auto_report_result = True
+        self.required = True
+        self.executable = 'TIDAcpucost'
+
+        if ftf_times:
+            self.args += ' -d TrigFastTrackFinder_'
+            self.output_dir = 'times-FTF'
+    
+    def configure(self, test):
+        #self.args += self.input_file+' '+self.ref_file+' '+' -o '+self.output_dir
+        if (self.reference == None):
+            ## if not reference found, run with "--noref" option
+            self.args += ' {} --noref -o {} -p TIME'.format(self.input_file,self.output_dir)
+        else:
+            self.args += ' {} {} -o {} -p TIME'.format(self.input_file,self.reference,self.output_dir)
+
+        print( "TIDAcpucost " + self.args )    
+
+        super(TrigInDetCpuCostStep, self).configure(test)
+

Trigger/TrigValidation/TrigInDetValidation/share/TrigInDetValidation_NewBase.py

+###  #!/usr/bin/env python
+
+# Slices = ['fsjet']
+# RunEF  = False
+# Events = 10
+# Threads = 1
+# Slots = 1
+# Input = 'ttbar'    # defined in TrigValTools/share/TrigValInputs.json   
+# TrackReference = 'Truth'
+
+import re
+
+from TrigValTools.TrigValSteering import Test
+from TrigValTools.TrigValSteering import CheckSteps
+
+from TrigInDetValidation.TrigInDetNewArtSteps import TrigInDetReco
+from TrigInDetValidation.TrigInDetNewArtSteps import TrigInDetAna
+from TrigInDetValidation.TrigInDetNewArtSteps import TrigInDetRdictStep
+from TrigInDetValidation.TrigInDetNewArtSteps import TrigInDetCompStep
+from TrigInDetValidation.TrigInDetNewArtSteps import TrigInDetCpuCostStep
+
+
+import sys,getopt
+
+try:
+    opts, args = getopt.getopt(sys.argv[1:],"lcxpn:",["local","config"])
+except getopt.GetoptError:
+    print("Usage:  ")
+    print("-l(--local)    run locally with input file from art eos grid-input")
+    print("-x             don't run athena or post post-processing, only plotting")
+    print("-p             run post-processing, even if -x is set")
+    print("-n  N          run only on N events per job")
+    print("-c(--config)   run with config_only and print to a pkl file")
+    print("")
+
+
+Events_local  = 0
+local         = False
+exclude       = False
+postproc      = False
+testconfig    = False
+
+
+try: GridFiles
+except NameError: GridFiles=False
+
+if GridFiles==True :
+    use_gridfiles = True
+else:
+    use_gridfiles = False
+
+for opt,arg in opts:
+    if opt in ("-l", "--local"):
+        local=True
+    if opt=="-x":
+        exclude=True
+    if opt=="-p":
+        postproc=True
+    if opt=="-n":
+        Events_local=arg
+    if opt in ("-c", "--config"):
+        testconfig = True
+
+
+if 'postinclude_file' in dir() :
+    rdo2aod = TrigInDetReco( postinclude_file = postinclude_file )
+else :
+    rdo2aod = TrigInDetReco()
+
+# test specific variables ...
+
+rdo2aod.slices            = Slices
+rdo2aod.threads           = Threads
+rdo2aod.concurrent_events = Slots 
+rdo2aod.config_only       = testconfig
+
+
+
+if "Args" not in locals() : 
+    Args = " "
+
+
+# allow command line to override programed number of events to process
+
+if Events_local != 0 : 
+    rdo2aod.max_events        = Events_local 
+else :
+    rdo2aod.max_events        = Events 
+
+
+rdo2aod.perfmon = False
+rdo2aod.timeout = 18*3600
+rdo2aod.input   = Input    # defined in TrigValTools/share/TrigValInputs.json  
+
+if use_gridfiles: 
+    if local:
+#   rdo2aod.input = 'Single_el_larged0'    # defined in TrigValTools/share/TrigValInputs.json  
+       rdo2aod.input = Input   # should match definition in TrigValTools/share/TrigValInputs.json  
+    else:
+       rdo2aod.input = ''
+       rdo2aod.args += ' --inputRDOFile=$ArtInFile '
+
+
+
+# Run athena analysis to produce TrkNtuple
+
+test = Test.Test()
+test.art_type = 'grid'
+if (not exclude):
+    test.exec_steps = [rdo2aod]
+    test.exec_steps.append(TrigInDetAna())
+    test.check_steps = CheckSteps.default_check_steps(test)
+
+# Run TIDArdict
+
+
+if ((not exclude) or postproc ):
+    for job in Jobs : 
+        rdict = TrigInDetRdictStep( name=job[0], args=job[1] )
+        print( "\n\033[0;32m TIDArdict "+job[1]+" \033[0m" )
+        test.check_steps.append(rdict)
+       
+        
+for _slice in Comp :
+    compstep = TrigInDetCompStep( name=_slice[0], slice=_slice[1], file=_slice[2], args=_slice[3] ) 
+    test.check_steps.append(compstep)
+
+# CPU cost steps
+
+cpucost=TrigInDetCpuCostStep('CpuCostStep1', ftf_times=False)
+test.check_steps.append(cpucost)
+
+cpucost2=TrigInDetCpuCostStep('CpuCostStep2')
+test.check_steps.append(cpucost2)
+
+import sys
+sys.exit(test.run())

Trigger/TrigValidation/TrigInDetValidation/share/comparitor.json

@@ -41,6 +41,9 @@
     "L2fsjet":{ 
         "chains" : "HLT_j45_ftf_L1J15:HLT_IDTrack_FS_FTF:HLT_FSRoI:HLT_IDVertex_FS"
     },
+    "L2fsjetvtx":{ 
+        "chains" : "HLT_j45_ftf_L1J15:HLT_IDTrack_FS_FTF:HLT_FSRoI:HLT_IDVertex_FS/HLT_IDVertex_FS"
+    },
     "L2minbias":{ 
         "chains" : "HLT_mb_sptrk_L1RD0_FILLED:HLT_IDTrack_MinBias_FTF"
     },

Trigger/TrigValidation/TrigInDetValidation/test/test_trigID_all_ttbar_pu40_new.py

+#!/usr/bin/env python
+
+# art-description: art job for all_ttbar_pu40_new
+# art-type: grid
+# art-include: master/Athena
+# art-athena-mt: 8
+# art-memory: 4096
+# art-html: https://idtrigger-val.web.cern.ch/idtrigger-val/TIDAWeb/TIDAart/?jobdir=
+# art-output: *.txt
+# art-output: *.log
+# art-output: log.*
+# art-output: *.out
+# art-output: *.err
+# art-output: *.log.tar.gz
+# art-output: *.new
+# art-output: *.json
+# art-output: *.root
+# art-output: *.check*
+# art-output: HLT*
+# art-output: times*
+# art-output: cost-perCall
+# art-output: cost-perEvent
+# art-output: cost-perCall-chain
+# art-output: cost-perEvent-chain
+# art-output: *.dat 
+
+
+Slices  = ['muon','electron','tau','bjet','fsjet']
+RunEF   = False
+Events  = 4000
+Threads = 8 
+Slots   = 8
+Input   = 'ttbar_ID'    # defined in TrigValTools/share/TrigValInputs.json  
+
+Jobs = [ ( "Offline",  " TIDAdata-run3-offline.dat -o data-hists.root" ) ]
+
+
+Comp = [ ( "L2muon",       "L2muon",      "data-hists.root",          " -c TIDAhisto-panel.dat  -d HLTL2-plots-muon " ),
+         ( "L2electron",   "L2electron",  "data-hists.root",          " -c TIDAhisto-panel.dat  -d HLTL2-plots-electron " ),
+         ( "L2tau",        "L2tau",       "data-hists.root",          " -c TIDAhisto-panel.dat  -d HLTL2-plots-tau " ),
+         ( "L2bjet",       "L2bjet",      "data-hists.root",          " -c TIDAhisto-panel.dat  -d HLTL2-plots-bjet " ),   
+         ( "FSjetoffline", "L2fsjet",     "data-hists.root",          " -c TIDAhisto-panel.dat  -d HLTL2-plots-FS " ),
+         ( "FSvtx",        "L2fsjetvtx",  "data-hists.root",          " -c TIDAhistos-vtx.dat   -d HLTL2-plots-vtx " ),
+ 
+         ( "EFmuon",       "EFmuon",      "data-hists.root",          " -c TIDAhisto-panel.dat  -d HLTEF-plots-muon " ),
+         ( "EFelectron",   "EFelectron",  "data-hists.root",          " -c TIDAhisto-panel.dat  -d HLTEF-plots-electron " ),
+         ( "EFtau",        "EFtau",       "data-hists.root",          " -c TIDAhisto-panel.dat  -d HLTEF-plots-tau " ),
+         ( "EFbjet",       "EFmuon",      "data-hists.root",          " -c TIDAhisto-panel.dat  -d HLTEF-plots-bjet " ) ]
+   
+from AthenaCommon.Include import include 
+include("TrigInDetValidation/TrigInDetValidation_NewBase.py")
+

Trigger/TrigValidation/TrigInDetValidation/test/test_trigID_bjet_pu40.py

@@ -26,14 +26,15 @@
 # art-output: *.dat 
 
 Slices = ['bjet']
-RunEF   = False
-Events = 4000
-Threads = 4 
-Slots   = 4
+RunEF   = True
+Events  = 4000
+Threads = 8 
+Slots   = 8
 Input = 'ttbar_ID'    # defined in TrigValTools/share/TrigValInputs.json  
 
-TrackReference = [ 'Truth' ]
+TrackReference = [ 'Truth', 'Offline' ]
 
 
 from AthenaCommon.Include import include 
-include("TrigInDetValidation/TrigInDetValidation_Base.py")
\ No newline at end of file
+include("TrigInDetValidation/TrigInDetValidation_Base.py")
+

Trigger/TrigValidation/TrigInDetValidation/test/test_trigID_fsjet_pu40_new.py

+#!/usr/bin/env python
+
+# art-description: art job for fsjet_pu40_new
+# art-type: grid
+# art-include: master/Athena
+# art-input-nfiles: 3
+# art-athena-mt: 8
+# art-memory: 4096
+# art-html: https://idtrigger-val.web.cern.ch/idtrigger-val/TIDAWeb/TIDAart/?jobdir=
+# art-output: *.txt
+# art-output: *.log
+# art-output: log.*
+# art-output: *.out
+# art-output: *.err
+# art-output: *.log.tar.gz
+# art-output: *.new
+# art-output: *.json
+# art-output: *.root
+# art-output: *.check*
+# art-output: HLT*
+# art-output: times*
+# art-output: cost-perCall
+# art-output: cost-perEvent
+# art-output: cost-perCall-chain
+# art-output: cost-perEvent-chain
+# art-output: *.dat 
+
+
+Slices  = ['fsjet']
+RunEF   = False
+Events  = 2000 
+Threads = 8 
+Slots   = 8
+Input   = 'ttbar'    # defined in TrigValTools/share/TrigValInputs.json  
+
+Jobs = [ ( "Truth",       " TIDAdata-run3.dat              -o data-hists.root" ), 
+         ( "Offline",     " TIDAdata-run3-offline.dat      -o data-hists-offline.root" ),
+         ( "OfflineVtx",  " TIDAdata-run3-offline-vtx.dat  -o data-hists-offline-vtx.root" ) ]
+
+
+Comp = [ ( "FSjet",        "L2fsjet",     "data-hists.root",              " -c TIDAhisto-panel.dat      -d HLTL2-plots " ),
+         ( "FSjetoffline", "L2fsjet",     "data-hists-offline.root",      " -c TIDAhisto-panel.dat      -d HLTL2-plots-offline " ),
+         ( "FSvtx",        "L2fsjetvtx",  "data-hists-offline-vtx.root",  " -c TIDAhisto-panel-vtx.dat  -d HLTL2-plots-vtx     --ncols 3" ),
+         ( "FSvtxall",     "L2fsjetvtx",  "data-hists-offline.root",      " -c TIDAhisto-panel-vtx.dat  -d HLTL2-plots-vtxall  --ncols 3" ) ]
+
+
+from AthenaCommon.Include import include 
+include("TrigInDetValidation/TrigInDetValidation_NewBase.py")
+
+
+