AsgxAODMetNTupleMakerAlg.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
//
// Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
//
#ifndef ASGANALYSISALGORITHMS_ASGXAODMETNTUPLEMAKERALG_H
#define ASGANALYSISALGORITHMS_ASGXAODMETNTUPLEMAKERALG_H
 
// // Framework include(s):
#include "AnaAlgorithm/AnaAlgorithm.h"
#include "AsgMessaging/AsgMessaging.h"
#include "AsgServices/ServiceHandle.h"
#include "AsgTools/PropertyWrapper.h"
#include "CxxUtils/checker_macros.h"
#include "SystematicsHandles/ISystematicsSvc.h"
 
// EDM include(s):
#include "AthContainers/AuxElement.h"
 
namespace CP {
 
   class ATLAS_NOT_THREAD_SAFE AsgxAODMetNTupleMakerAlg : public EL::AnaAlgorithm {
 
   public:
      AsgxAODMetNTupleMakerAlg( const std::string& name, ISvcLocator* svcLoc );
 
 
      StatusCode initialize() override;
 
      StatusCode execute() override;
 
      StatusCode finalize() override;
 
 
   private:
      StatusCode setupTree();
 
      StatusCode setupBranch( const std::string &branchDecl,
                              const CP::SystematicSet &sys );
 
 
      Gaudi::Property<std::string> m_treeName {this, "TreeName", "physics", "Name of the tree to write"};
      Gaudi::Property<std::vector< std::string >> m_branches {this, "Branches", {}, "Branches to write to the output tree"};
 
 
      class ElementProcessor : public asg::AsgMessaging {
 
      public:
         ElementProcessor();
 
         StatusCode process( const SG::AuxElement& element );
 
         StatusCode addBranch( TTree& tree, const std::string& auxName,
                               const std::string& branchName,
                               bool allowMissing,
                               bool &created );
 
      private:
         class BranchProcessor {
 
         public:
            StatusCode setup( TTree& tree, const std::string& auxName,
                              const std::string& branchName,
                              MsgStream& msg );
 
            StatusCode process( const SG::AuxElement& element,
                                MsgStream& msg );
 
            std::string m_branchName;
            std::unique_ptr< SG::AuxElement::TypelessConstAccessor > m_acc;
            const SG::IAuxTypeVectorFactory* m_factory = nullptr;
            std::unique_ptr< SG::IAuxTypeVector > m_data;
            void* m_dataPtr = nullptr;
 
         }; // class BranchProcessor
 
         std::list< BranchProcessor > m_branches;
 
      }; // class ElementProcessor
 
 
      TTree* m_tree = nullptr;
 
      std::unordered_map< std::string, ElementProcessor > m_elements;
 
      bool m_isInitialized = false;
 
      Gaudi::Property<std::string> m_termName {this, "termName", "Final", "the name of the MissingET term to save"};
 
      ServiceHandle<ISystematicsSvc> m_systematicsService {this, "systematicsSvc", "SystematicsSvc", "systematics service"};
 
 
   }; // class AsgxAODMetNTupleMakerAlg
 
} // namespace CP
 
#endif // ASGANALYSISALGORITHMS_ASGXAODNTUPLEMAKERALG_H