AsgxAODNTupleMakerAlg.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
//
// Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
//
#ifndef ASGANALYSISALGORITHMS_ASGXAODNTUPLEMAKERALG_H
#define ASGANALYSISALGORITHMS_ASGXAODNTUPLEMAKERALG_H
 
// System include(s):
#include <unordered_map>
#include <string>
#include <vector>
#include <memory>
#include <list>
 
// Framework include(s):
#include "AsgMessaging/AsgMessaging.h"
#include "AsgServices/ServiceHandle.h"
#include "AnaAlgorithm/AnaAlgorithm.h"
#include "CxxUtils/checker_macros.h"
#include "SystematicsHandles/SysListHandle.h"
#include <AsgTools/PropertyWrapper.h>
 
// EDM include(s):
#include "AthContainersInterfaces/IAuxTypeVector.h"
#include "AthContainers/AuxElement.h"
 
// Forward declaration(s):
class TClass;
class TTree;
class TVirtualCollectionProxy;
namespace SG {
   class AuxVectorBase;
   class IAuxTypeVectorFactory;
}
 
namespace CP {

   class ATLAS_NOT_THREAD_SAFE AsgxAODNTupleMakerAlg : public EL::AnaAlgorithm {
 
   public:
     using EL::AnaAlgorithm::AnaAlgorithm;


      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::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

      class ATLAS_NOT_THREAD_SAFE ContainerProcessor : public asg::AsgMessaging {
 
      public:
         ContainerProcessor();

         StatusCode process( const SG::AuxVectorBase& container, const TClass& cl);

         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 resize( size_t size, MsgStream& msg );
            StatusCode process( const SG::AuxElement& element, size_t index,
                                MsgStream& msg );

            std::string m_branchName;
            std::unique_ptr< SG::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;
         TVirtualCollectionProxy* m_collProxy = nullptr;
         int m_auxElementOffset = -1;
 
      }; // class ContainerProcessor


      TTree* m_tree = nullptr;

      std::unordered_map< std::string, ElementProcessor > m_elements;
      std::unordered_map< std::string, ContainerProcessor > m_containers;

      bool m_isInitialized = false;

      ServiceHandle<ISystematicsSvc> m_systematicsService {this, "systematicsService", "SystematicsSvc", "systematics service"};

 
   }; // class AsgxAODNTupleMakerAlg
 
} // namespace CP
 
#endif // ASGANALYSISALGORITHMS_ASGXAODNTUPLEMAKERALG_H