.. _program_listing_file_xAODAnaHelpers_IParticleHistsAlgo.h:

Program Listing for File IParticleHistsAlgo.h
=============================================

|exhale_lsh| :ref:`Return to documentation for file <file_xAODAnaHelpers_IParticleHistsAlgo.h>` (``xAODAnaHelpers/IParticleHistsAlgo.h``)

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

.. code-block:: cpp

   #ifndef xAODAnaHelpers_IParticleHistsAlgo_H
   #define xAODAnaHelpers_IParticleHistsAlgo_H
   
   #include <SampleHandler/MetaObject.h>
   #include <SampleHandler/MetaFields.h>
   
   // algorithm wrapper
   #include <xAODAnaHelpers/Algorithm.h>
   #include <xAODAnaHelpers/IParticleHists.h>
   #include <xAODAnaHelpers/HelperFunctions.h>
   #include <xAODAnaHelpers/HelperClasses.h>
   
   class IParticleHistsAlgo : public xAH::Algorithm
   {
     // put your configuration variables here as public variables.
     // that way they can be set directly from CINT and python.
   public:
   
     std::string m_inContainerName = "";
     std::string m_detailStr = "";
     std::string m_inputAlgo = "";
     std::string m_histPrefix;
     std::string m_histTitle;
   
   private:
     std::map< std::string, IParticleHists* > m_plots; 
   
     // variables that don't get filled at submission time should be
     // protected from being send from the submission node to the worker
     // node (done by the //!)
   public:
     // Tree *myTree; //!
     // TH1 *myHist; //!
   
     // this is a standard constructor
     IParticleHistsAlgo (std::string className = "IParticleHistsAlgo");
   
     // these are the functions inherited from Algorithm
     virtual EL::StatusCode setupJob (EL::Job& job);
     virtual EL::StatusCode fileExecute ();
     virtual EL::StatusCode histInitialize ();
     virtual EL::StatusCode changeInput (bool firstFile);
     virtual EL::StatusCode initialize ();
     virtual EL::StatusCode execute ();
     virtual EL::StatusCode postExecute ();
     virtual EL::StatusCode finalize ();
     virtual EL::StatusCode histFinalize ();
   
     template<class HIST_T, class CONT_T> EL::StatusCode execute ()
     {
       static SG::AuxElement::Accessor< float > mcEvtWeightAcc("mcEventWeight");
   
       const xAOD::EventInfo* eventInfo(nullptr);
       ANA_CHECK( HelperFunctions::retrieve(eventInfo, m_eventInfoContainerName, m_event, m_store, msg()) );
   
       float eventWeight(1);
       if ( mcEvtWeightAcc.isAvailable( *eventInfo ) ) {
         eventWeight = mcEvtWeightAcc( *eventInfo );
       }
       // if(isMC())
       //   {
       //  double xs     =wk()->metaData()->castDouble(SH::MetaFields::crossSection    ,1);
       //  double eff    =wk()->metaData()->castDouble(SH::MetaFields::filterEfficiency,1);
       //  double kfac   =wk()->metaData()->castDouble(SH::MetaFields::kfactor         ,1);
       //  eventWeight *= xs * eff * kfac;
       //   }
   
       // this will hold the collection processed
       const CONT_T* inParticles = 0;
   
       // if input comes from xAOD, or just running one collection,
       // then get the one collection and be done with it
       if( m_inputAlgo.empty() ) {
         ANA_CHECK( HelperFunctions::retrieve(inParticles, m_inContainerName, m_event, m_store, msg()) );
   
         // pass the photon collection
         ANA_CHECK( static_cast<HIST_T*>(m_plots[""])->execute( inParticles, eventWeight, eventInfo ));
       }
       else { // get the list of systematics to run over
   
         // get vector of string giving the names
         std::vector<std::string>* systNames(nullptr);
         ANA_CHECK( HelperFunctions::retrieve(systNames, m_inputAlgo, 0, m_store, msg()) );
   
         // loop over systematics
         for( auto systName : *systNames ) {
       ANA_CHECK( HelperFunctions::retrieve(inParticles, m_inContainerName+systName, m_event, m_store, msg()) );
       if( m_plots.find( systName ) == m_plots.end() ) { this->AddHists( systName ); }
       ANA_CHECK( static_cast<HIST_T*>(m_plots[systName])->execute( inParticles, eventWeight, eventInfo ));
         }
       }
   
       return EL::StatusCode::SUCCESS;
     }
   
     // these are the functions not inherited from Algorithm
     virtual EL::StatusCode AddHists( std::string name);
   
     template<class HIST_T> EL::StatusCode AddHists( std::string name ) {
       std::string fullname(m_name);
       fullname += name; // add systematic
       HIST_T* particleHists = new HIST_T( fullname, m_detailStr ); // add systematic
       particleHists->m_debug = msgLvl(MSG::DEBUG);
       ANA_CHECK( particleHists->initialize());
       particleHists->record( wk() );
       m_plots[name] = particleHists;
   
       return EL::StatusCode::SUCCESS;
     }
   
     // this is needed to distribute the algorithm to the workers
     ClassDef(IParticleHistsAlgo, 1);
   
   };
   
   #endif