28     CustomJetContainerName = 
"AntiKt4EMTopoCustomVtxGNNJets" 
   30     from JetRecConfig.StandardJetConstits 
import stdInputExtDic, JetInputExternal, JetInputConstitSeq, JetConstitModifier, xAODType
 
   31     from JetRecConfig.JetDefinition 
import JetDefinition 
 
   32     from JetRecConfig.StandardSmallRJets 
import AntiKt4EMTopo
 
   33     from JetRecTools 
import JetRecToolsConfig 
as jrtcfg
 
   34     from JetMomentTools 
import JetMomentToolsConfig
 
   35     from JetRecConfig.StandardJetConstits 
import stdConstitDic, stdContitModifDic
 
   36     from JetRecConfig.StandardJetContext 
import inputsFromContext
 
   37     from JetRecConfig.JetInputConfig 
import buildEventShapeAlg
 
   41     jetContextName = 
'CustomVtxGNN' 
   42     context = flags.Jet.Context[jetContextName]
 
   44     def replaceItems(tup,orgName,newName):
 
   46         for i, item 
in enumerate(newList):
 
   48                 newList[i] = item.replace(orgName,newName)
 
   49                 print( 
"Updated ", orgName, 
" to ", newName )
 
   51         print( 
"Failed to update ", orgName, 
" to ", newName )
 
   54     def updateCalibSequence(tup):
 
   57         rhoname = 
"Kt4EMTopoCustomVtxGNNEventShape"  
   59         for i, item 
in enumerate(newList):
 
   61                 calibspecs = item.split(
":")
 
   62                 calib, calibcontext, data_type = calibspecs[:3]
 
   65                   calibseq = calibspecs[3]
 
   66                 finalCalibString = f
"CalibCustomVtxGNN:{calibcontext}:{data_type}:{calibseq}:{rhoname}:PrimaryVertices_initial" 
   67                 if len(calibspecs)>6: finalCalibString = f
"{finalCalibString}:{calibspecs[6]}" 
   68                 newList[i] = finalCalibString
 
   69                 print(finalCalibString)
 
   71         print( 
"Failed to update calib sequence" )
 
   76     modsCustomVtxGNN = AntiKt4EMTopo.modifiers
 
   77     modsCustomVtxGNN = updateCalibSequence(modsCustomVtxGNN)
 
   78     modsCustomVtxGNN = replaceItems(modsCustomVtxGNN,
"TrackMoments",
"TrackMomentsCustomVtxGNN")
 
   79     modsCustomVtxGNN = replaceItems(modsCustomVtxGNN,
"TrackSumMoments",
"TrackSumMomentsCustomVtxGNN")
 
   80     modsCustomVtxGNN = replaceItems(modsCustomVtxGNN,
"JVF",
"JVFCustomVtxGNN")
 
   81     modsCustomVtxGNN = replaceItems(modsCustomVtxGNN,
"JVT",
"JVTCustomVtxGNN")
 
   82     modsCustomVtxGNN = replaceItems(modsCustomVtxGNN,
"Charge",
"ChargeCustomVtxGNN")
 
   83     modsCustomVtxGNN = replaceItems(modsCustomVtxGNN,
"jetiso",
"jetisoCustomVtxGNN")
 
   85     ghostCustomVtxGNN = AntiKt4EMTopo.ghostdefs
 
   88     stdConstitDic[
"EMTopoOriginCustomVtxGNN"]  = JetInputConstitSeq(
"EMTopoOriginCustomVtxGNN", xAODType.CaloCluster, [
"EMCustomVtxGNN",
"OriginCustomVtxGNN"],
 
   89                                                     "CaloCalTopoClusters", 
"EMOriginCustomVtxGNNTopoClusters", label=
"EMTopo")
 
   90     stdContitModifDic[
"OriginCustomVtxGNN"] = JetConstitModifier(
"OriginCustomVtxGNN", 
"CaloClusterConstituentsOrigin", prereqs=[
inputsFromContext(
"Vertices")], 
 
   91                                                 properties=dict(VertexContainer=
"PrimaryVertices_initial"))
 
   92     stdContitModifDic[
"EMCustomVtxGNN"] = JetConstitModifier(
"EMCustomVtxGNN",     
"ClusterAtEMScaleTool", )
 
   94     AntiKt4EMTopoCustomVtxGNN = JetDefinition(
"AntiKt",0.4,stdConstitDic.EMTopoOriginCustomVtxGNN,
 
   95                                            infix = 
"CustomVtxGNN",
 
   96                                            context = jetContextName,
 
   97                                            ghostdefs = ghostCustomVtxGNN,
 
   98                                            modifiers = modsCustomVtxGNN,
 
  102     def getUsedInVertexFitTrackDecoratorAlgCustomVtxGNN(jetdef, jetmod):
 
  103         """ Create the alg  to decorate the used-in-fit information for AMVF """ 
  104         context  = jetdef._contextDic
 
  106         from InDetUsedInFitTrackDecoratorTool.UsedInVertexFitTrackDecoratorConfig 
import getUsedInVertexFitTrackDecoratorAlg
 
  108                                                   vertexDeco=
'TTVA_AMVFVertices_forGNN',
 
  109                                                   weightDeco=
'TTVA_AMVFWeights_forGNN')
 
  113     stdInputExtDic[context[
'Vertices']] = JetInputExternal( context[
'Vertices'],   xAODType.Vertex )
 
  115     stdInputExtDic[
"JetSelectedTracksCustomVtxGNN"] = JetInputExternal(
"JetSelectedTracksCustomVtxGNN",     xAODType.TrackParticle,
 
  116                                                                                     prereqs= [ f
"input:{context['Tracks']}" ], 
 
  117                                                                                     algoBuilder = 
lambda jdef,_ : jrtcfg.getTrackSelAlg(jdef, trackSelOpt=
False,
 
  118                                                                                                                                               DecorDeps=[
"TTVA_AMVFWeights_forGNN", 
"TTVA_AMVFVertices_forGNN"] )
 
  121     stdInputExtDic[
"JetTrackUsedInFitDecoCustomVtxGNN"] = JetInputExternal(
"JetTrackUsedInFitDecoCustomVtxGNN", xAODType.TrackParticle,
 
  122                                                                         prereqs= [ f
"input:{context['Tracks']}" , 
 
  123                                                                                   f
"input:{context['Vertices']}"],
 
  124                                                                         algoBuilder = getUsedInVertexFitTrackDecoratorAlgCustomVtxGNN
 
  127     stdInputExtDic[
"JetTrackVtxAssocCustomVtxGNN"] = JetInputExternal(
"JetTrackVtxAssocCustomVtxGNN",  xAODType.TrackParticle,
 
  128                                               algoBuilder = 
lambda jdef,_ : jrtcfg.getJetTrackVtxAlg(jdef._contextDic, algname=
"jetTVACustomVtxGNN",
 
  129                                                                                                                        WorkingPoint=
"Nonprompt_All_MaxWeight",
 
  130                                                                                                                        AMVFVerticesDeco=
'TTVA_AMVFVertices_forGNN',
 
  131                                                                                                                        AMVFWeightsDeco=
'TTVA_AMVFWeights_forGNN'),
 
  132                                               prereqs = [ 
"input:JetTrackUsedInFitDecoCustomVtxGNN", f
"input:{context['Vertices']}" ] )
 
  134     stdInputExtDic[
"EventDensityCustomVtxGNN"] =     JetInputExternal(
"EventDensity", 
"EventShape", algoBuilder = buildEventShapeAlg,
 
  135                       containername = 
lambda jetdef, _ : 
"Kt4"+jetdef.inputdef.label+
"EventShape",
 
  136                       prereqs = 
lambda jetdef : [
"input:"+jetdef.inputdef.name] )
 
  140     from JetRecConfig.StandardJetMods 
import stdJetModifiers
 
  141     from JetRecConfig.JetDefinition 
import JetModifier
 
  142     from JetCalibTools 
import JetCalibToolsConfig
 
  144     stdJetModifiers.update(
 
  146       CalibCustomVtxGNN = JetModifier(
"JetCalibrationTool",
"jetcalib_jetcoll_calibseqCustomVtxGNN",
 
  147                                         createfn=JetCalibToolsConfig.getJetCalibToolFromString,
 
  151       JVFCustomVtxGNN =             JetModifier(
"JetVertexFractionTool", 
"jvfCustomVtxGNN",
 
  153                                         modspec = 
"CustomVtxGNN",
 
  154                                         prereqs = [
"input:JetTrackVtxAssocCustomVtxGNN", 
"mod:TrackMomentsCustomVtxGNN", f
"input:{context['Vertices']}"] ,
 
  155                                              JetContainer = CustomJetContainerName),
 
  157       JVTCustomVtxGNN =             JetModifier(
"JetVertexTaggerTool", 
"jvtCustomVtxGNN",
 
  159                                         modspec = 
"CustomVtxGNN",
 
  160                                         prereqs = [ 
"mod:JVFCustomVtxGNN" ],JetContainer = CustomJetContainerName),
 
  162       NNJVTCustomVtxGNN =           JetModifier(
"JetVertexNNTagger", 
"nnjvtCustomVtxGNN",
 
  164                                               prereqs = [ 
"mod:JVFCustomVtxGNN" ],JetContainer = CustomJetContainerName),
 
  166       OriginSetPVCustomVtxGNN =     JetModifier(
"JetOriginCorrectionTool", 
"origin_setpvCustomVtxGNN",
 
  167                                         modspec = 
"CustomVtxGNN",
 
  168                                         prereqs = [ 
"mod:JVFCustomVtxGNN" ],JetContainer = CustomJetContainerName, OnlyAssignPV=
True),
 
  170       TrackMomentsCustomVtxGNN =    JetModifier(
"JetTrackMomentsTool", 
"trkmomsCustomVtxGNN",
 
  172                                         modspec = 
"CustomVtxGNN",
 
  173                                         prereqs = [ 
"input:JetTrackVtxAssocCustomVtxGNN",
"ghost:Track" ],JetContainer = CustomJetContainerName),
 
  175       TrackSumMomentsCustomVtxGNN = JetModifier(
"JetTrackSumMomentsTool", 
"trksummomsCustomVtxGNN",
 
  177                                         modspec = 
"CustomVtxGNN",
 
  178                                         prereqs = [ 
"input:JetTrackVtxAssocCustomVtxGNN",
"ghost:Track" ],JetContainer = CustomJetContainerName),
 
  180       ChargeCustomVtxGNN =          JetModifier(
"JetChargeTool", 
"jetchargeCustomVtxGNN", 
 
  181                                         prereqs = [ 
"ghost:Track" ]),
 
  184       QGTaggingCustomVtxGNN =       JetModifier(
"JetQGTaggerVariableTool", 
"qgtaggingCustomVtxGNN",
 
  186                                         modspec = 
"CustomVtxGNN",
 
  187                                         prereqs = 
lambda _,jdef :
 
  188                                              [
"input:JetTrackVtxAssocCustomVtxGNN",
"mod:TrackMomentsCustomVtxGNN"] +
 
  189                                              ([
"mod:JetPtAssociation"] 
if not jdef._cflags.Input.isMC 
else []),
 
  190                                         JetContainer = CustomJetContainerName),
 
  192       fJVTCustomVtxGNN =            JetModifier(
"JetForwardPFlowJvtTool", 
"fJVTCustomVtxGNN",
 
  194                                         modspec = 
"CustomVtxGNN",
 
  195                                         prereqs = [
"input:JetTrackVtxAssocCustomVtxGNN",
"input:EventDensityCustomVtxGNN",f
"input:{context['Vertices']}",
"mod:NNJVTCustomVtxGNN"],
 
  196                                         JetContainer = CustomJetContainerName),
 
  197       jetisoCustomVtxGNN = JetModifier(
"JetIsolationTool",
"isoCustomVtxGNN",
 
  198                            JetContainer=CustomJetContainerName,
 
  199                            InputConstitContainer = 
"EMOriginCustomVtxGNNTopoClusters",
 
  200                            IsolationCalculations = [
"IsoFixedCone:5:Pt",   
"IsoFixedCone:5:PtPUsub",],
 
  201                            RhoKey = 
lambda jetdef, specs : 
"Kt4"+jetdef.inputdef.label+
"CustomVtxGNNEventShape" ,
 
  202                            prereqs= [
"input:EventDensityCustomVtxGNN"], 
 
  208     from JetRecConfig.JetRecConfig 
import JetRecCfg
 
  210     acc.merge(
JetRecCfg(flags,AntiKt4EMTopoCustomVtxGNN))