Update xah

Root/HelperClasses.cxx

@@ -290,6 +290,7 @@ namespace HelperClasses{
   void JetInfoSwitch::initialize(){
     std::string tmpConfigStr; // temporary config string used to extract multiple values
 
+    m_displaced     = has_exact("displaced");
     m_trigger       = has_exact("trigger");
     m_substructure  = has_exact("substructure");
     m_ntrimsubjets  = has_exact("ntrimsubjets");
@@ -298,6 +299,7 @@ namespace HelperClasses{
     m_rapidity      = has_exact("rapidity");
     m_clean         = has_exact("clean");
     m_cleanLight    = has_exact("cleanLight");
+    m_cleanLLP      = has_exact("cleanLLP");
     m_cleanTrig     = has_exact("cleanTrig");
     m_cleanLLP      = has_exact("cleanLLP");
     m_timing        = has_exact("timing");

Root/JetContainer.cxx

@@ -12,6 +12,25 @@ JetContainer::JetContainer(const std::string& name, const std::string& detailStr
     m_trkSelTool(nullptr)
 
 {
+
+  // displaced
+  if(m_infoSwitch.m_displaced) {
+    m_ipsig              =  new std::vector<float>();
+    m_bdt_score          =  new std::vector<float>();
+    m_ptrel              =  new std::vector<float>();
+    m_ptrel_highest      =  new std::vector<float>();
+    m_chf                =  new std::vector<float>();
+    m_dchf               =  new std::vector<float>();
+    m_alpha_max          =  new std::vector<float>();
+    m_maxd0Value         =  new std::vector<float>();
+    m_mind0Value         =  new std::vector<float>();
+    m_mediand0Value      =  new std::vector<float>();
+    m_ntrk               =  new std::vector<int>();
+    m_ntrk_prompt        =  new std::vector<int>();
+
+
+  }
+
   // rapidity
   if(m_infoSwitch.m_rapidity) {
     m_rapidity                  =new std::vector<float>();
@@ -479,6 +498,23 @@ JetContainer::~JetContainer()
     delete m_rapidity;
   }
 
+  if(m_infoSwitch.m_displaced) {
+    delete  m_ipsig;
+    delete  m_bdt_score;
+    delete  m_ptrel;
+    delete  m_ptrel_highest;
+    delete  m_chf;
+    delete  m_dchf;
+    delete  m_alpha_max;        
+    delete  m_mind0Value;
+    delete  m_maxd0Value;
+    delete  m_mediand0Value;
+    delete  m_ntrk;
+    delete  m_ntrk_prompt;
+
+  }
+
+
   // trigger
   if ( m_infoSwitch.m_trigger ) {
     delete m_isTrigMatched         ;
@@ -923,6 +959,23 @@ void JetContainer::setTree(TTree *tree)
   // Connect branches
   ParticleContainer::setTree(tree);
 
+  if ( m_infoSwitch.m_displaced ){
+    connectBranch<float>  (tree,"ipsig",             &m_ipsig);
+    connectBranch<float>  (tree,"bdt_score",         &m_bdt_score);
+    connectBranch<float>  (tree,"ptrel",             &m_ptrel);
+    connectBranch<float>  (tree,"ptrel_highest",     &m_ptrel_highest);
+    connectBranch<float>  (tree,"alpha_max",         &m_alpha_max);
+    connectBranch<float>  (tree,"chf",               &m_chf);
+    connectBranch<float>  (tree,"dchf",              &m_dchf);    
+    connectBranch<float>  (tree,"maxd0Value",        &m_maxd0Value);
+    connectBranch<float>  (tree,"mind0Value",        &m_mind0Value);
+    connectBranch<float>  (tree,"mediand0Value",     &m_mediand0Value);
+    connectBranch<int>    (tree,"ntrk",              &m_ntrk);
+    connectBranch<int>    (tree,"ntrk_prompt",       &m_ntrk_prompt);
+
+  }
+
+
   if(m_infoSwitch.m_rapidity)
     {
       connectBranch<float>(tree,"rapidity",                      &m_rapidity);
@@ -1011,6 +1064,30 @@ void JetContainer::setTree(TTree *tree)
       connectBranch<float>(tree, "Jvt",        &m_Jvt);
     }
 
+  if ( m_infoSwitch.m_allTrack ) {
+    connectBranch<int  >(tree,"GhostTrackCount",  &m_GhostTrackCount );
+    connectBranch<float>(tree,"GhostTrackPt",     &m_GhostTrackPt    );
+    connectBranch<std::vector<float> >(tree,"GhostTrack_pt",    &m_GhostTrack_pt   );
+    connectBranch<std::vector<float> >(tree,"GhostTrack_qOverP",&m_GhostTrack_qOverP);
+    connectBranch<std::vector<float> >(tree,"GhostTrack_eta",   &m_GhostTrack_eta  );
+    connectBranch<std::vector<float> >(tree,"GhostTrack_phi",   &m_GhostTrack_phi  );
+    connectBranch<std::vector<float> >(tree,"GhostTrack_e",     &m_GhostTrack_e    );
+    connectBranch<std::vector<float> >(tree,"GhostTrack_d0",    &m_GhostTrack_d0   );
+    connectBranch<std::vector<float> >(tree,"GhostTrack_z0",    &m_GhostTrack_z0   );
+    if ( m_infoSwitch.m_allTrackDetail ) {
+      connectBranch<std::vector<int> >(tree,"GhostTrack_nPixelHits",                           &m_GhostTrack_nPixelHits);
+      connectBranch<std::vector<int> >(tree,"GhostTrack_nSCTHits",                             &m_GhostTrack_nSCTHits);
+      connectBranch<std::vector<int> >(tree,"GhostTrack_nTRTHits",                             &m_GhostTrack_nTRTHits);
+      connectBranch<std::vector<int> >(tree,"GhostTrack_nPixelSharedHits",                     &m_GhostTrack_nPixelSharedHits);
+      connectBranch<std::vector<int> >(tree,"GhostTrack_nPixelSplitHits",                      &m_GhostTrack_nPixelSplitHits);
+      connectBranch<std::vector<int> >(tree,"m_GhostTrack_nInnermostPixelLayerHits",             &m_GhostTrack_nInnermostPixelLayerHits);
+      connectBranch<std::vector<int> >(tree,"m_GhostTrack_nInnermostPixelLayerSharedHits",       &m_GhostTrack_nInnermostPixelLayerSharedHits);
+      connectBranch<std::vector<int> >(tree,"m_GhostTrack_nInnermostPixelLayerSplitHits",        &m_GhostTrack_nInnermostPixelLayerSplitHits);
+      connectBranch<std::vector<int> >(tree,"m_GhostTrack_nNextToInnermostPixelLayerHits",       &m_GhostTrack_nNextToInnermostPixelLayerHits);
+      connectBranch<std::vector<int> >(tree,"m_GhostTrack_nNextToInnermostPixelLayerSharedHits", &m_GhostTrack_nNextToInnermostPixelLayerSharedHits);
+      connectBranch<std::vector<int> >(tree,"m_GhostTrack_nNextToInnermostPixelLayerSplitHits",  &m_GhostTrack_nNextToInnermostPixelLayerSplitHits);
+    }
+  }
 
   if ( m_infoSwitch.m_chargedPFOPV ) {
     connectBranch<float>(tree, "SumPtChargedPFOPt500PV", &m_SumPtChargedPFOPt500PV);
@@ -1180,6 +1257,27 @@ void JetContainer::updateParticle(uint idx, Jet& jet)
   if(m_debug) std::cout << "in JetContainer::updateParticle " << std::endl;
   ParticleContainer::updateParticle(idx,jet);
 
+  if(m_infoSwitch.m_displaced)
+    {
+      jet.chf                       =m_chf                 ->at(idx);
+      jet.dchf                      =m_dchf                ->at(idx);
+      jet.ipsig                     =m_ipsig               ->at(idx);
+      jet.bdt_score                 =m_bdt_score           ->at(idx);
+      jet.ptrel                     =m_ptrel               ->at(idx);
+      jet.ptrel_highest             =m_ptrel_highest       ->at(idx);
+      jet.alpha_max                 =m_alpha_max           ->at(idx);
+      jet.mind0Value                =m_mind0Value          ->at(idx);
+      jet.maxd0Value                =m_maxd0Value          ->at(idx);
+      jet.mediand0Value             =m_mediand0Value       ->at(idx);
+      jet.ntrk                      =m_ntrk                ->at(idx);
+      jet.ntrk_prompt               =m_ntrk_prompt         ->at(idx);
+
+
+
+    }
+
+
+
   if(m_infoSwitch.m_rapidity)
     {
       jet.rapidity                    =m_rapidity                    ->at(idx);
@@ -1270,6 +1368,32 @@ void JetContainer::updateParticle(uint idx, Jet& jet)
       jet.Jvt       =m_Jvt       ->at(idx);
     }
 
+  if ( m_infoSwitch.m_allTrack ) {
+    jet.GhostTrackCount = m_GhostTrackCount->at(idx);
+    jet.GhostTrackPt    = m_GhostTrackPt->at(idx);
+
+    jet.GhostTrack_pt     = m_GhostTrack_pt->at(idx);
+    jet.GhostTrack_qOverP = m_GhostTrack_qOverP->at(idx);
+    jet.GhostTrack_eta    = m_GhostTrack_eta->at(idx);
+    jet.GhostTrack_phi    = m_GhostTrack_phi->at(idx);
+    jet.GhostTrack_e      = m_GhostTrack_e->at(idx);
+    jet.GhostTrack_d0     = m_GhostTrack_d0->at(idx);
+    jet.GhostTrack_z0     = m_GhostTrack_z0->at(idx);
+    if ( m_infoSwitch.m_allTrackDetail ) {
+      jet.GhostTrack_nPixelHits                           = m_GhostTrack_nPixelHits->at(idx);
+      jet.GhostTrack_nSCTHits                             = m_GhostTrack_nSCTHits->at(idx);
+      jet.GhostTrack_nTRTHits                             = m_GhostTrack_nTRTHits->at(idx);
+      jet.GhostTrack_nPixelSharedHits                     = m_GhostTrack_nPixelSharedHits->at(idx);
+      jet.GhostTrack_nPixelSplitHits                      = m_GhostTrack_nPixelSplitHits->at(idx);
+      jet.GhostTrack_nInnermostPixelLayerHits             = m_GhostTrack_nInnermostPixelLayerHits->at(idx);
+      jet.GhostTrack_nInnermostPixelLayerSharedHits       = m_GhostTrack_nInnermostPixelLayerSharedHits->at(idx);
+      jet.GhostTrack_nInnermostPixelLayerSplitHits        = m_GhostTrack_nInnermostPixelLayerSplitHits->at(idx);
+      jet.GhostTrack_nNextToInnermostPixelLayerHits       = m_GhostTrack_nNextToInnermostPixelLayerHits->at(idx);
+      jet.GhostTrack_nNextToInnermostPixelLayerSharedHits = m_GhostTrack_nNextToInnermostPixelLayerSharedHits->at(idx);
+      jet.GhostTrack_nNextToInnermostPixelLayerSplitHits  = m_GhostTrack_nNextToInnermostPixelLayerSplitHits->at(idx);
+    }
+  }
+
   if ( m_infoSwitch.m_chargedPFOPV ) {
     jet.SumPtChargedPFOPt500PV=m_SumPtChargedPFOPt500PV->at(idx);
     jet.fCharged=m_fCharged->at(idx);
@@ -1539,6 +1663,23 @@ void JetContainer::setBranches(TTree *tree)
 {
   ParticleContainer::setBranches(tree);
 
+  if ( m_infoSwitch.m_displaced ) {
+    setBranch<float>(tree,"ipsig",                       m_ipsig           );
+    setBranch<float>(tree,"bdt_score",                   m_bdt_score       );
+    setBranch<float>(tree,"ptrel",                       m_ptrel           );
+    setBranch<float>(tree,"ptrel_highest",               m_ptrel_highest   );
+    setBranch<float>(tree,"chf",                         m_chf             );
+    setBranch<float>(tree,"dchf",                        m_dchf            );
+    setBranch<float>(tree,"alpha_max",                   m_alpha_max       );    
+    setBranch<float>(tree,"maxd0Value",                  m_maxd0Value      );    
+    setBranch<float>(tree,"mind0Value",                  m_mind0Value      );    
+    setBranch<float>(tree,"mediand0Value",               m_mediand0Value   );    
+    setBranch<int>(tree,"ntrk",                          m_ntrk            );    
+    setBranch<int>(tree,"ntrk_prompt",                   m_ntrk_prompt     );    
+
+  }
+
+
   if ( m_infoSwitch.m_rapidity ) {
     setBranch<float>(tree,"rapidity",                      m_rapidity              );
   }
@@ -1981,6 +2122,24 @@ void JetContainer::clear()
 
   ParticleContainer::clear();
 
+  // displaced
+  if( m_infoSwitch.m_displaced ) {
+    m_alpha_max->clear();
+    m_chf->clear();
+    m_dchf->clear();
+    m_ipsig->clear();
+    m_bdt_score->clear();
+    m_ptrel->clear();
+    m_ptrel_highest->clear();
+    m_maxd0Value->clear();
+    m_mind0Value->clear();
+    m_mediand0Value->clear();
+    m_ntrk->clear();
+    m_ntrk_prompt->clear();
+
+  }
+
+
   // rapidity
   if( m_infoSwitch.m_rapidity ) {
     m_rapidity->clear();
@@ -2423,6 +2582,77 @@ void JetContainer::FillJet( const xAOD::IParticle* particle, const xAOD::Vertex*
 
   const xAOD::Jet* jet=dynamic_cast<const xAOD::Jet*>(particle);
 
+  if( m_infoSwitch.m_displaced ){
+    if( jet->isAvailable< float >( "alpha_max" ) ) {
+      m_alpha_max->push_back( jet->auxdata< float >("alpha_max") );
+    } else {
+      m_alpha_max->push_back( -999 );
+    }
+    if( jet->isAvailable< float >( "bdt_score" ) ) {
+      m_bdt_score->push_back( jet->auxdata< float >("bdt_score") );
+    } else {
+      m_bdt_score->push_back( -999 );
+    }
+    if( jet->isAvailable< float >( "ipsig" ) ) {
+      m_ipsig->push_back( jet->auxdata< float >("ipsig") );
+    } else {
+      m_ipsig->push_back( -999 );
+    }
+    if( jet->isAvailable< float >( "ptrel" ) ) {
+      m_ptrel->push_back( jet->auxdata< float >("ptrel") );
+    } else {
+      m_ptrel->push_back( -999 );
+    }
+    if( jet->isAvailable< float >( "ptrel_highest" ) ) {
+      m_ptrel_highest->push_back( jet->auxdata< float >("ptrel_highest") );
+    } else {
+      m_ptrel_highest->push_back( -999 );
+    }
+    if( jet->isAvailable< float >( "chf" ) ) {
+      m_chf->push_back( jet->auxdata< float >("chf") );
+    } else {
+      m_chf->push_back( -999 );
+    }
+    if( jet->isAvailable< float >( "dchf" ) ) {
+      m_dchf->push_back( jet->auxdata< float >("dchf") );
+    } else {
+      m_dchf->push_back( -999 );
+    }
+    if( jet->isAvailable< float >( "maxd0Value" ) ) {
+      m_maxd0Value->push_back( jet->auxdata< float >("maxd0Value") );
+    } else {
+      m_maxd0Value->push_back( -999 );
+    }
+
+    if( jet->isAvailable< float >( "mind0Value" ) ) {
+      m_mind0Value->push_back( jet->auxdata< float >("mind0Value") );
+    } else {
+      m_mind0Value->push_back( -999 );
+    }
+
+
+    if( jet->isAvailable< float >( "mediand0Value" ) ) {
+      m_mediand0Value->push_back( jet->auxdata< float >("mediand0Value") );
+    } else {
+      m_mediand0Value->push_back( -999 );
+    }
+
+    if( jet->isAvailable< int >( "ntrk" ) ) {
+      m_ntrk->push_back( jet->auxdata< int >("ntrk") );
+    } else {
+      m_ntrk->push_back( -999 );
+    }
+
+    if( jet->isAvailable< int >( "ntrk_prompt" ) ) {
+      m_ntrk_prompt->push_back( jet->auxdata< int >("ntrk_prompt") );
+    } else {
+      m_ntrk_prompt->push_back( -999 );
+    }
+
+
+  }
+
+
   if( m_infoSwitch.m_rapidity ){
     m_rapidity->push_back( jet->rapidity() );
   }
@@ -2986,8 +3216,13 @@ void JetContainer::FillJet( const xAOD::IParticle* particle, const xAOD::Vertex*
     std::vector<int> nNIMLPixSharedHits;
     std::vector<int> nNIMLPixSplitHits;
     static SG::AuxElement::ConstAccessor< std::vector<ElementLink<DataVector<xAOD::IParticle> > > >ghostTrack ("GhostTrack");
+    static SG::AuxElement::ConstAccessor< std::vector<ElementLink<DataVector<xAOD::IParticle> > > >ghostTrackLRT ("GhostTrackLRT");
     if ( ghostTrack.isAvailable( *jet ) ) {
       std::vector<ElementLink<DataVector<xAOD::IParticle> > > trackLinks = ghostTrack( *jet );
+      if ( ghostTrackLRT.isAvailable( *jet ) ) {
+        std::vector<ElementLink<DataVector<xAOD::IParticle> > > trackLinksLRT = ghostTrackLRT( *jet );
+        trackLinks.insert( trackLinks.end(), trackLinksLRT.begin(), trackLinksLRT.end() );
+      }
       //std::vector<float> pt(trackLinks.size(),-999);
       for ( auto link_itr : trackLinks ) {
         if( !link_itr.isValid() ) { continue; }
@@ -3010,6 +3245,12 @@ void JetContainer::FillJet( const xAOD::IParticle* particle, const xAOD::Vertex*
         e.  push_back( track->e()  / m_units );
         d0. push_back( track->d0() );
         z0. push_back( track->z0() + track->vz() - pv->z() ); // store z0 wrt PV...most useful
+        // TODO: z0sinTheta
+        //       Sd0
+        //       sign
+        //       ptFrac
+        //       dEta
+        //       dPhi
         if( m_infoSwitch.m_allTrackDetail ) {
           uint8_t getInt(0);
           // n pix, sct, trt
@@ -3116,6 +3357,7 @@ void JetContainer::FillJet( const xAOD::IParticle* particle, const xAOD::Vertex*
     myBTag->variable<float>("DL1r" , "pb", pb);
     //FixMe: Retrieve the correct f_c value from the CDI file would be the best approach
     score=log( pb / (0.018*pc+0.982*pu) );
+
     m_DL1r_pu->push_back(pu);
     m_DL1r_pc->push_back(pc);
     m_DL1r_pb->push_back(pb);