MuonTesterTree.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUONTESTERTREE_MUONTESTERTREE_H
#define MUONTESTERTREE_MUONTESTERTREE_H
 
#include <GaudiKernel/ITHistSvc.h> //service handle template argument
#include <GaudiKernel/ServiceHandle.h>
#include <MuonTesterTree/IMuonTesterBranch.h> //for IMuonTesterBranch::DataDependency
#include <AthenaBaseComps/AthMessaging.h> //parent class
#include <AthenaBaseComps/AthHistogramAlgorithm.h>
//
#include <set>
#include <string>
#include <vector>
#include <memory>
#include <concepts> 
#include <format>
//
//need the full class declarations, function templates cannot return incomplete types
#include <MuonTesterTree/MatrixBranch.h>
#include <MuonTesterTree/ScalarBranch.h>
#include <MuonTesterTree/VectorBranch.h>
#include <MuonTesterTree/SetBranch.h>
//
class TTree;
 
namespace MuonVal {
    namespace detail {
        template <typename HistSvcHolder_t> concept hasHistSvc = requires(const HistSvcHolder_t& holder) {
            { holder.histSvc() }-> std::same_as<const ServiceHandle<ITHistSvc>&>;
        };
    }
 
class EventHashBranch;
 
class MuonTesterTree: public AthMessaging {
public:
    MuonTesterTree(const std::string& tree_name, const std::string& stream);
    ~MuonTesterTree();
    
    TTree* tree();
    const TTree* tree() const;
    
    TTree* operator->();
    const TTree* operator->() const;

    bool initialized() const;

    bool fill(const EventContext& ctx);

    std::string name() const;
    const std::string& fileStream() const;
    const std::string& path() const;
  
    void setPath(const std::string& new_path);
    void setFileStream(const std::string& new_stream);
 
    
   template <detail::hasHistSvc OWNER>
   StatusCode init(OWNER* instance);

    StatusCode write();
    bool registerBranch(std::shared_ptr<IMuonTesterBranch> branch);

    bool addBranch(std::shared_ptr<IMuonTesterBranch> branch);
    bool addBranch(IMuonTesterBranch& branch);
    bool addBranch(IMuonTesterBranch* branch);
    void removeBranch(IMuonTesterBranch* branch);
    void removeBranch(IMuonTesterBranch& branch);

    void disableBranch(const std::string& br_name);
    void disableBranch(const std::vector<std::string>& br_names);

    template <class T> std::shared_ptr<T> getBranch(const std::string& str) const;

    template <typename T> VectorBranch<T>& newVector(const std::string& name);
    template <typename T> ScalarBranch<T>& newScalar(const std::string& name);
    template <typename T> MatrixBranch<T>& newMatrix(const std::string& name);
    template <typename T> SetBranch<T>& newSet(const std::string& name);
    
    template <typename T> VectorBranch<T>& newVector(const std::string& name, const T def_val);
    template <typename T> ScalarBranch<T>& newScalar(const std::string& name, const T def_val);
    template <typename T> MatrixBranch<T>& newMatrix(const std::string& name, const T def_val);
    

    template <typename T> T& newBranch(std::shared_ptr<T> br);

    bool isActive(const IMuonTesterBranch* branch) const;

    bool isCommonTree() const;    
    using FriendTreePtr = std::shared_ptr<MuonTesterTree>;
    
    bool addCommonTree(FriendTreePtr common_tree);
    const std::vector<FriendTreePtr>& getFriends() const;
private:
    bool addClient(MuonTesterTree* client);
    
    StatusCode init(const ServiceHandle<ITHistSvc> & hist_svc);
    
    using DataDependency = IMuonTesterBranch::DataDependency;
    std::vector<DataDependency> m_dependencies{};
    unsigned int m_depCounter{0};
 
    std::unique_ptr<TTree> m_tree{nullptr};
    std::string m_stream{};
    std::string m_path{};
    bool m_init{false};
    bool m_written{false};
 
    // Careful: m_branches_to_init must come before m_branches.
    // When m_branches is destroyed, the branches being deleted will
    // try to remove themselves from m_branches_to_init.  If these are
    // in the opposite order, then m_branches_to_init will already
    // have been destroyed, and we'll be accessing freed memory.
 
    // List of branches which shall be initialized. The list will be sorted before initialization and then cleared
    // None of the branches is explicitly owned by the object
    std::vector<IMuonTesterBranch*> m_branches_to_init{};
    // List of branches which are owned by the tree. They will be deleted if the object is destroyed
    std::vector<std::shared_ptr<IMuonTesterBranch>> m_branches{};
    std::set<IMuonTesterBranch*> m_initialized_br{};
 
    std::set<std::string> m_excludedBranches{};
 
    TDirectory* m_directory{nullptr};
    bool m_filled{false};
    ServiceHandle<ITHistSvc> m_hist_svc{"", ""};
  
    std::vector<FriendTreePtr> m_friendLinks{};
    std::set<MuonTesterTree*> m_commonClients{};
 
    std::shared_ptr<EventHashBranch> m_hash_br;
 
};
}
#include <MuonTesterTree/MuonTesterTree.icc>
#endif