.. _program_listing_file_Root_TrigMatcher.cxx:

Program Listing for File TrigMatcher.cxx
========================================

|exhale_lsh| :ref:`Return to documentation for file <file_Root_TrigMatcher.cxx>` (``Root/TrigMatcher.cxx``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   /********************************************
    *
    * Interface to CP trigger matching tool(s).
    *
    *******************************************/
   
   // c++ include(s):
   #include <iostream>
   #include <typeinfo>
   #include <sstream>
   
   // EL include(s):
   #include <EventLoop/Job.h>
   #include <EventLoop/StatusCode.h>
   #include <EventLoop/Worker.h>
   
   // EDM include(s):
   #include <xAODEventInfo/EventInfo.h>
   #include <xAODAnaHelpers/HelperFunctions.h>
   
   #include <xAODAnaHelpers/TrigMatcher.h>
   
   #include "TriggerMatchingTool/MatchFromCompositeTool.h"
   
   // ROOT include(s):
   #include <TFile.h>
   #include <TObjArray.h>
   #include <TObjString.h>
   
   
   // this is needed to distribute the algorithm to the workers
   ClassImp(TrigMatcher)
   
   TrigMatcher :: TrigMatcher ()
   : Algorithm("TrigMatcher")
   {
   }
   
   TrigMatcher::~TrigMatcher() {}
   
   EL::StatusCode TrigMatcher :: setupJob (EL::Job& job)
   {
     // Here you put code that sets up the job on the submission object
     // so that it is ready to work with your algorithm, e.g. you can
     // request the D3PDReader service or add output files.  Any code you
     // put here could instead also go into the submission script.  The
     // sole advantage of putting it here is that it gets automatically
     // activated/deactivated when you add/remove the algorithm from your
     // job, which may or may not be of value to you.
   
     ANA_MSG_INFO( "Calling setupJob");
   
     job.useXAOD ();
     xAOD::Init( "TrigMatcher" ).ignore(); // call before opening first file
   
     return EL::StatusCode::SUCCESS;
   }
   
   EL::StatusCode TrigMatcher :: initialize ()
   {
     ANA_MSG_INFO( "Initializing TrigMatcher Interface... ");
   
     ANA_CHECK( xAH::Algorithm::algInitialize());
   
     // Standard containers
     m_event = wk()->xaodEvent();
     m_store = wk()->xaodStore();
   
     // Configuration
     if ( m_inContainerName.empty() ) {
       ANA_MSG_ERROR( "InputContainer is empty!");
       return EL::StatusCode::FAILURE;
     }
   
     if( !isPHYS() ) {
       // Grab the TrigDecTool from the ToolStore
       if(!m_trigDecTool_handle.isUserConfigured()){
         ANA_MSG_FATAL("A configured " << m_trigDecTool_handle.typeAndName() << " must have been previously created! Are you creating one in xAH::BasicEventSelection?" );
         return EL::StatusCode::FAILURE;
       }
       ANA_CHECK( m_trigDecTool_handle.retrieve());
       ANA_MSG_DEBUG("Retrieved tool: " << m_trigDecTool_handle);
     }
   
     // ***************************************
     //
     // Initialise Trig::TrigMatchingTool
     //
     // ***************************************
     if( !m_trigChains.empty() ) {
       std::string trig;
       std::istringstream ss(m_trigChains);
       while ( std::getline(ss, trig, ',') ) {
         m_trigChainsList.push_back(trig);
       }
     }
   
     ANA_CHECK( m_scoreTool.retrieve());
   
     //  everything went fine, let's initialise the tool!
     //
     if( !isPHYS() ) {
       m_trigMatchTool_handle = asg::AnaToolHandle<Trig::IMatchingTool>("Trig::MatchingTool/MatchingTool");
       ANA_CHECK( m_trigMatchTool_handle.setProperty( "TrigDecisionTool", m_trigDecTool_handle ));
       ANA_CHECK( m_trigMatchTool_handle.setProperty( "ScoringTool", m_scoreTool ));    
     } else { // For DAOD_PHYS samples
       m_trigMatchTool_handle = asg::AnaToolHandle<Trig::IMatchingTool>("Trig::MatchFromCompositeTool/MatchFromCompositeTool");
     }
     ANA_CHECK( m_trigMatchTool_handle.retrieve() );
   
     // **********************************************************************************************
   
     ANA_MSG_INFO( "TrigMatcher Interface succesfully initialized!" );
   
     return EL::StatusCode::SUCCESS;
   }
   
   EL::StatusCode TrigMatcher :: execute ()
   {
     // Here you do everything that needs to be done on every single
     // events, e.g. read input variables, apply cuts, and fill
     // histograms and trees.  This is where most of your actual analysis
     // code will go.
   
     ANA_MSG_DEBUG( "Applying trigger matching... ");
   
     const xAOD::IParticleContainer* inParticles(nullptr);
   
     // if input comes from xAOD, or just running one collection,
     // then get the one collection and be done with it
     //
     if ( m_systNames.empty() ) {
   
       // this will be the collection processed - no matter what!!
       //
       ANA_CHECK( HelperFunctions::retrieve(inParticles, m_inContainerName, m_event, m_store, msg()) );
       ANA_CHECK( executeMatching( inParticles ) );
   
     } else { // get the list of systematics to run over
   
       // get vector of string giving the syst names of the upstream algo from TStore (rememeber: 1st element is a blank string: nominal case!)
       //
       std::vector< std::string >* systNames(nullptr);
       ANA_CHECK( HelperFunctions::retrieve(systNames, m_systNames, 0, m_store, msg()) );
   
       // loop over systematic sets
       //
       for ( auto systName : *systNames) {
   
         ANA_MSG_DEBUG( " syst name: " << systName << "  input container name:  " << m_inContainerName+systName );
   
         ANA_CHECK( HelperFunctions::retrieve(inParticles, m_inContainerName + systName, m_event, m_store, msg()));
         ANA_CHECK( executeMatching( inParticles ) );
       }
   
     }
   
     return EL::StatusCode::SUCCESS;
   }
   
   EL::StatusCode TrigMatcher :: executeMatching ( const xAOD::IParticleContainer* inParticles )
   {
     static const SG::AuxElement::Decorator< std::vector< std::string > > isTrigMatchedDecor( "trigMatched" );
   
     for( auto particle : *inParticles )
       {
         ANA_MSG_DEBUG( "Trigger matching an object");
   
         if ( !isTrigMatchedDecor.isAvailable( *particle ) )
       isTrigMatchedDecor( *particle ) = std::vector<std::string>();
   
         for ( auto const &chain : m_trigChainsList ) {
       ANA_MSG_DEBUG( "\t checking trigger chain " << chain);
   
       bool matched = m_trigMatchTool_handle->match( *particle, chain, 0.07 );
       ANA_MSG_DEBUG( "\t\t result = " << matched );
       if(matched) isTrigMatchedDecor( *particle ).push_back( chain );
         }
       }
   
     return EL::StatusCode::SUCCESS;
   }