MuonVal::MuonTesterTree Class Reference

#include <MuonTesterTree.h>

Inheritance diagram for MuonVal::MuonTesterTree:

Public Types
using	FriendTreePtr = std::shared_ptr<MuonTesterTree>
	Appends the other tester Tree as friend to this instance.

Public Member Functions
	MuonTesterTree (const std::string &tree_name, const std::string &stream)
	~MuonTesterTree ()
TTree *	tree ()
	TTree object.
const TTree *	tree () const
TTree *	operator-> ()
	Operator to the TTree object.
const TTree *	operator-> () const
bool	initialized () const
	Has the init method been called and the tree is connected with the output file.
bool	fill (const EventContext &ctx)
	Fills the tree per call.
std::string	name () const
	Name of the tree.
const std::string &	fileStream () const
	file_stream of the analysis to which the tree belongs
const std::string &	path () const
	sub directory in the TFile
void	setPath (const std::string &new_path)
	Save the TTree in a subfolder of the TFile.
template<class OWNER, typename = typename std::enable_if<std::is_base_of<IProperty, OWNER>::value>::type>
StatusCode	init (OWNER *instance)
	Initialize method.
StatusCode	write ()
	Finally write the TTree objects.
bool	registerBranch (std::shared_ptr< IMuonTesterBranch > branch)
	This method adds the branch to the tree and hands over the ownership to the MuonAnalysisTree instance IF the second argument is set to false the branch is not added to the active list of branches i.e.
bool	addBranch (std::shared_ptr< IMuonTesterBranch > branch)
	Branch is added to the tree without transferring the ownership.
bool	addBranch (IMuonTesterBranch &branch)
bool	addBranch (IMuonTesterBranch *branch)
void	removeBranch (IMuonTesterBranch *branch)
	In case instances of a certain branch type are destroyed before hand.
void	removeBranch (IMuonTesterBranch &branch)
void	disableBranch (const std::string &br_name)
	Skips the branch from being added to the tree.
void	disableBranch (const std::vector< std::string > &br_names)
template<class T>
std::shared_ptr< T >	getBranch (const std::string &str) const
	Retrieves the branches owned by the muon_tree.
template<typename T>
VectorBranch< T > &	newVector (const std::string &name)
	Creates new branches and returns their reference.
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)
	Creates and returns branches with a default value.
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)
	returns the reference of the branch
bool	isActive (const IMuonTesterBranch *branch) const
	Returns a boolean whether the branch is already part of the tree or one of the deligated friends.
bool	isCommonTree () const
	Returns Whether the Tree is a common tree or not.
bool	addCommonTree (FriendTreePtr common_tree)
const std::vector< FriendTreePtr > &	getFriends () const
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Private Types
using	DataDependency = IMuonTesterBranch::DataDependency

Private Member Functions
bool	addClient (MuonTesterTree *client)
	Adds the other TTree as a Client and declares this instance as a Common Tree.
StatusCode	init (ServiceHandle< ITHistSvc > hist_svc)
	Initialze the tree with the output file.
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
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}
	Flag to avoid double initialization with the StoreGate.
bool	m_written {false}
	Flag to indicate whether the TTree is written to the file or not.
std::vector< IMuonTesterBranch * >	m_branches_to_init {}
std::vector< std::shared_ptr< IMuonTesterBranch > >	m_branches {}
std::set< IMuonTesterBranch * >	m_initialized_br {}
	Set of branches that were already initialized.
std::set< std::string >	m_excludedBranches {}
TDirectory *	m_directory {nullptr}
bool	m_filled {false}
ServiceHandle< ITHistSvc >	m_hist_svc {"", ""}
std::vector< FriendTreePtr >	m_friendLinks {}
	List of all other common instances that are acting as friends.
std::set< MuonTesterTree * >	m_commonClients {}
	List of all other MuonTesterTree instances using this instance as a common Tree If the Tree has one client it is declared as a common Tree.
std::shared_ptr< EventHashBranch >	m_hash_br
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels)
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging)

Detailed Description

Definition at line 30 of file MuonTesterTree.h.

Member Typedef Documentation

DataDependency

using MuonVal::MuonTesterTree::DataDependency = IMuonTesterBranch::DataDependency

private

Definition at line 123 of file MuonTesterTree.h.

FriendTreePtr

using MuonVal::MuonTesterTree::FriendTreePtr = std::shared_ptr<MuonTesterTree>

Appends the other tester Tree as friend to this instance.

Definition at line 109 of file MuonTesterTree.h.

Constructor & Destructor Documentation

MuonTesterTree()

MuonVal::MuonTesterTree::MuonTesterTree	(	const std::string &	tree_name,
		const std::string &	stream )

Definition at line 267 of file MuonTesterTree.cxx.

                                                                                  :
    AthMessaging{"MuonTesterTree"},
    m_tree{std::make_unique<TTree>(tree_name.c_str(), "MuonTesterTree")}, m_stream(stream) {}

~MuonTesterTree()

MuonVal::MuonTesterTree::~MuonTesterTree

(

)

Definition at line 271 of file MuonTesterTree.cxx.

                               {
    m_branches_to_init.clear();
}

Member Function Documentation

addBranch() [1/3]

bool MuonVal::MuonTesterTree::addBranch

(

IMuonTesterBranch &

branch

)

Definition at line 62 of file MuonTesterTree.cxx.

{ return addBranch(&branch); }

addBranch() [2/3]

bool MuonVal::MuonTesterTree::addBranch

(

IMuonTesterBranch *

branch

)

Definition at line 63 of file MuonTesterTree.cxx.

                                                        {
    if (isActive(branch))
        return true;
    else if (!branch) {
        ATH_MSG_ERROR("Nullptr given");
        return false;
    } else if (m_filled) {
        ATH_MSG_ERROR("Tree structure is already finalized. Cannot add " << branch->name());
        return false;
    } 
    if (branch->tree() != tree()) {
        for (const FriendTreePtr& friend_tree : getFriends()) {
            if (friend_tree->addBranch(branch)) return true;
        }
        return false;
    }
    m_branches_to_init.push_back(branch);
    return true;
}

addBranch() [3/3]

bool MuonVal::MuonTesterTree::addBranch

(

std::shared_ptr< IMuonTesterBranch >

branch

)

Branch is added to the tree without transferring the ownership.

Definition at line 61 of file MuonTesterTree.cxx.

{ return registerBranch(branch) && addBranch(branch.get()); }

addClient()

bool MuonVal::MuonTesterTree::addClient ( MuonTesterTree * client )

private

Adds the other TTree as a Client and declares this instance as a Common Tree.

Definition at line 225 of file MuonTesterTree.cxx.

                                                     {
    if (Gaudi::Concurrency::ConcurrencyFlags::numThreads() > 1) {
        ATH_MSG_WARNING("Common TTree mechanism only supported in single thread environment");
        return false;
    }
    if (!m_hash_br) {
        m_hash_br = std::make_shared<EventHashBranch>(tree());
        if (!addBranch(m_hash_br)) return false;
    }
    m_commonClients.insert(client);
    return true;
}

addCommonTree()

bool MuonVal::MuonTesterTree::addCommonTree

(

FriendTreePtr

common_tree

)

Ensure that the event entries are synchronized

Definition at line 237 of file MuonTesterTree.cxx.

                                                            {
    if (Gaudi::Concurrency::ConcurrencyFlags::numThreads() > 1) {
        ATH_MSG_WARNING("Common TTree mechanism only supported in single thread environment");
        return false;
    }
    if (!common_tree) {
        ATH_MSG_ERROR("Nullptr given");
        return false;
    }
    if (common_tree->fileStream() != fileStream()) {
        ATH_MSG_ERROR("The common tree "<<common_tree->name()<<" and "<<name()<<" have to be written into the same file");
        return false;
    }
    if (m_commonClients.count(common_tree.get())) {
        ATH_MSG_ERROR(name()<<" is already a friend of "<<common_tree->name());
        return false;
    }
    if (!m_hash_br) {
        m_hash_br = std::make_shared<EventHashBranch>(tree());
        if (!addBranch(m_hash_br)) return false;
    }
    m_friendLinks.push_back(common_tree);
    return common_tree->addClient(this);
}

disableBranch() [1/2]

void MuonVal::MuonTesterTree::disableBranch

(

const std::string &

br_name

)

Skips the branch from being added to the tree.

Definition at line 199 of file MuonTesterTree.cxx.

                                                          {
    if (!m_filled) m_excludedBranches.insert(b_name);
}

disableBranch() [2/2]

void MuonVal::MuonTesterTree::disableBranch

(

const std::vector< std::string > &

br_names

)

Definition at line 202 of file MuonTesterTree.cxx.

                                                                       {
    if (!m_filled) m_excludedBranches.insert(br_names.begin(), br_names.end());
}

fileStream()

const std::string & MuonVal::MuonTesterTree::fileStream

(

)

const

file_stream of the analysis to which the tree belongs

Definition at line 205 of file MuonTesterTree.cxx.

{ return m_stream; }

fill()

bool MuonVal::MuonTesterTree::fill

(

const EventContext &

ctx

)

Fills the tree per call.

Remove the information that is no longer of value

Common trees arecan only be filled once in an event

Call the fill method on all friends

These branches are actually initialized

Definition at line 89 of file MuonTesterTree.cxx.

                                                 {
    if (!initialized()) {
        ATH_MSG_ERROR("The TTree has not been initialized yet");
        return false;
    }
    if (!m_filled) {
        m_excludedBranches.clear();
        m_initialized_br.clear();
        m_dependencies.clear();
    }
    if (isCommonTree() && m_hash_br->is_dumped(ctx)) {
        return true;
    }
    for (const FriendTreePtr& friend_tree : getFriends()){
        if (!friend_tree->fill(ctx)) return false;
    }
    for (auto& branch : m_branches_to_init) {
        ATH_MSG_VERBOSE("Try to fill "<<branch->name());
        if (!branch->fill(ctx)) {
            ATH_MSG_ERROR("fill()  --- Failed to fill branch " << branch->name() << " in tree " << name() );
            return false;
        }
    }
    m_tree->Fill();
    m_filled = true;
    return true;
}

getBranch()

template<class T>

std::shared_ptr< T > MuonVal::MuonTesterTree::getBranch

(

const std::string &

str

)

const

Retrieves the branches owned by the muon_tree.

getFriends()

const std::vector< MuonTesterTree::FriendTreePtr > & MuonVal::MuonTesterTree::getFriends

(

)

const

Definition at line 262 of file MuonTesterTree.cxx.

                                                                               {
    return m_friendLinks;
}

init() [1/2]

template<class OWNER, typename = typename std::enable_if<std::is_base_of<IProperty, OWNER>::value>::type>

StatusCode MuonVal::MuonTesterTree::init

(

OWNER *

instance

)

Initialize method.

init() [2/2]

StatusCode MuonVal::MuonTesterTree::init ( ServiceHandle< ITHistSvc > hist_svc )

private

Initialze the tree with the output file.

The stream corresponds to the stream of the file e.g MDTTester HighEtaTester

push back the ds id index

Sort by alphabet

Kick everything that is not owned by the class itself

Definition at line 120 of file MuonTesterTree.cxx.

                                                                 {
    if (fileStream().empty()) {
        ATH_MSG_ERROR("The file stream of " << name() << " has not been set yet" );
        return StatusCode::FAILURE;
    }
    if (!initialized()) {
        if (!m_tree) {
            ATH_MSG_FATAL("No TTree object");
            return StatusCode::FAILURE;
        }
        std::stringstream full_path{};
        full_path<<"/"<<fileStream()<<"/"<<path()<<(path().empty() ? "" : "/")<<name();
        if (!hist_svc->regTree(full_path.str(), tree()).isSuccess()) { return StatusCode::FAILURE; }
        m_directory = m_tree->GetDirectory();
        if (!m_directory) {
            ATH_MSG_ERROR("Where is my directory to write later?");
            return StatusCode::FAILURE;
        }
        m_hist_svc = hist_svc;
        m_init = true;
    }
    for (const FriendTreePtr& friend_tree : getFriends()){
        if (!friend_tree->init(hist_svc).isSuccess()) return StatusCode::FAILURE;
    }
 
    Remove(m_branches_to_init, [this](const IMuonTesterBranch* br) {
        return !br || m_excludedBranches.count(br->name());
    });
    std::sort(m_branches_to_init.begin(), m_branches_to_init.end(),
              [](IMuonTesterBranch* a, IMuonTesterBranch* b) { return a->name() < b->name(); });
    for (IMuonTesterBranch* branch : m_branches_to_init) {
        if (m_initialized_br.count(branch)) {
            ATH_MSG_VERBOSE("Do not count the initialize function on "<<branch->name()<<" twice.");
            continue;
        }
        if (!branch->init()) {
            ATH_MSG_ERROR("Failed to initialize branch " << branch->name());
            return StatusCode::FAILURE;
        }
        ATH_MSG_DEBUG(" Branch " << branch->name() << " has been initialized");
        std::vector<DataDependency> data_dep = branch->data_dependencies();
        for (const DataDependency& data : data_dep) {
            m_dependencies.emplace_back(data);
        }
        m_initialized_br.insert(branch);
    }
    Remove(m_branches_to_init, [this](const IMuonTesterBranch* br) {
        return std::find_if(m_branches.begin(), m_branches.end(),
                            [br](const std::shared_ptr<IMuonTesterBranch>& owned) { 
                                return owned.get() == br; }) == m_branches.end();
    });
    ATH_MSG_INFO("Initialization of "<<name()<<" successfully completed");
    return StatusCode::SUCCESS;
}

initialized()

bool MuonVal::MuonTesterTree::initialized

(

)

const

Has the init method been called and the tree is connected with the output file.

Definition at line 88 of file MuonTesterTree.cxx.

{ return m_init; }

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

isActive()

bool MuonVal::MuonTesterTree::isActive

(

const IMuonTesterBranch *

branch

)

const

Returns a boolean whether the branch is already part of the tree or one of the deligated friends.

Definition at line 206 of file MuonTesterTree.cxx.

                                                                   {
    if (!branch) {        
        ATH_MSG_ERROR("Nullptr was given");
        return false;
    }
    if (branch->tree() != tree()) {
        for (const FriendTreePtr& friend_tree : getFriends()){
            if (friend_tree->isActive(branch)) return true;
        }
        return false;
    }
    return std::find_if(m_branches_to_init.begin(), m_branches_to_init.end(), 
        [&branch](const IMuonTesterBranch* known) {
            return known == branch || known->name() == branch->name();
        }) != m_branches_to_init.end();
}

isCommonTree()

bool MuonVal::MuonTesterTree::isCommonTree

(

)

const

Returns Whether the Tree is a common tree or not.

Definition at line 265 of file MuonTesterTree.cxx.

{return !m_commonClients.empty(); }

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 163 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 178 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

name()

std::string MuonVal::MuonTesterTree::name

(

)

const

Name of the tree.

Definition at line 20 of file MuonTesterTree.cxx.

{ return m_tree->GetName(); }

newBranch()

template<typename T>

T & MuonVal::MuonTesterTree::newBranch

(

std::shared_ptr< T >

br

)

returns the reference of the branch

newMatrix() [1/2]

template<typename T>

MatrixBranch< T > & MuonVal::MuonTesterTree::newMatrix

(

const std::string &

name

)

newMatrix() [2/2]

template<typename T>

MatrixBranch< T > & MuonVal::MuonTesterTree::newMatrix	(	const std::string &	name,
		const T	def_val )

newScalar() [1/2]

template<typename T>

ScalarBranch< T > & MuonVal::MuonTesterTree::newScalar

(

const std::string &

name

)

newScalar() [2/2]

template<typename T>

ScalarBranch< T > & MuonVal::MuonTesterTree::newScalar	(	const std::string &	name,
		const T	def_val )

newSet()

template<typename T>

SetBranch< T > & MuonVal::MuonTesterTree::newSet

(

const std::string &

name

)

newVector() [1/2]

template<typename T>

VectorBranch< T > & MuonVal::MuonTesterTree::newVector

(

const std::string &

name

)

Creates new branches and returns their reference.

newVector() [2/2]

template<typename T>

VectorBranch< T > & MuonVal::MuonTesterTree::newVector	(	const std::string &	name,
		const T	def_val )

Creates and returns branches with a default value.

operator->() [1/2]

TTree * MuonVal::MuonTesterTree::operator->

(

)

Operator to the TTree object.

Definition at line 23 of file MuonTesterTree.cxx.

{ return m_tree.get(); }

operator->() [2/2]

const TTree * MuonVal::MuonTesterTree::operator->

(

)

const

Definition at line 25 of file MuonTesterTree.cxx.

{ return m_tree.get(); }

path()

const std::string & MuonVal::MuonTesterTree::path

(

)

const

sub directory in the TFile

Definition at line 223 of file MuonTesterTree.cxx.

{ return m_path; }

registerBranch()

bool MuonVal::MuonTesterTree::registerBranch

(

std::shared_ptr< IMuonTesterBranch >

branch

)

This method adds the branch to the tree and hands over the ownership to the MuonAnalysisTree instance IF the second argument is set to false the branch is not added to the active list of branches i.e.

no fill and initialize function is called on it

Check whether the branch belongs to the same TTree

Definition at line 28 of file MuonTesterTree.cxx.

                                                                           {    
    if (!branch) {
        ATH_MSG_ERROR("Nullptr given");
        return false;
    }
    if (branch->tree() != tree()) {
        for (const FriendTreePtr& friend_tree : getFriends()){
            if (friend_tree->registerBranch(branch)) {
                m_branches.push_back(std::move(branch));
                return true;
            }
        }
        return false;
    }
    std::vector<std::shared_ptr<IMuonTesterBranch>>::const_iterator itr = std::find_if(
        m_branches.begin(), m_branches.end(),
        [&branch](const std::shared_ptr<IMuonTesterBranch>& known) { 
            return known == branch || known->name() == branch->name(); 
        });
    if (itr != m_branches.end()) {
        if (typeid((*itr).get()) != typeid(branch.get())) {
            ATH_MSG_FATAL("Different branches have been added here under " << branch->name());
            return false;
        }
        return true;
    } else if (m_filled) {
        ATH_MSG_FATAL("Tree structure is already finalized");
        return false;
    }
    m_branches.push_back(std::move(branch));
    return true;
}

removeBranch() [1/2]

void MuonVal::MuonTesterTree::removeBranch

(

IMuonTesterBranch &

branch

)

Definition at line 86 of file MuonTesterTree.cxx.

{ removeBranch(&branch); }

removeBranch() [2/2]

void MuonVal::MuonTesterTree::removeBranch

(

IMuonTesterBranch *

branch

)

In case instances of a certain branch type are destroyed before hand.

Definition at line 83 of file MuonTesterTree.cxx.

                                                           {
    Remove(m_branches_to_init, [branch](const IMuonTesterBranch* br) { return br == branch; });
}

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

setPath()

void MuonVal::MuonTesterTree::setPath

(

const std::string &

new_path

)

Save the TTree in a subfolder of the TFile.

Definition at line 222 of file MuonTesterTree.cxx.

{ m_path = new_path; }

tree() [1/2]

TTree * MuonVal::MuonTesterTree::tree

(

)

TTree object.

Definition at line 22 of file MuonTesterTree.cxx.

{ return m_tree.get(); }

tree() [2/2]

const TTree * MuonVal::MuonTesterTree::tree

(

)

const

Definition at line 24 of file MuonTesterTree.cxx.

{ return m_tree.get(); }

write()

StatusCode MuonVal::MuonTesterTree::write

(

)

Finally write the TTree objects.

Definition at line 178 of file MuonTesterTree.cxx.

                                 {
    if (!initialized() || !m_tree || m_written) { return StatusCode::SUCCESS; }
    if (!m_hist_svc->deReg(tree()).isSuccess()) {
        ATH_MSG_ERROR(__func__<<"() --- Failed to put the tree "<<name()<<" out of the HistService");
        return StatusCode::FAILURE;
    }
    for (const FriendTreePtr& friend_tree : getFriends()) {
        if (!friend_tree->write().isSuccess()) return StatusCode::FAILURE;
        if (!tree()->AddFriend(friend_tree->tree())) {
            ATH_MSG_ERROR("Failed to establish the Friendship between "<<name()<<" & "<<friend_tree->tree());
            return StatusCode::FAILURE;
        }
    }
    m_directory->WriteObject(tree(), tree()->GetName(), "overwrite");
    if (!isCommonTree()) m_tree.reset();
    m_branches_to_init.clear();
    m_branches.clear();
    m_friendLinks.clear();
    m_written = true;
    return StatusCode::SUCCESS;
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

m_branches

std::vector<std::shared_ptr<IMuonTesterBranch> > MuonVal::MuonTesterTree::m_branches {}

private

Definition at line 145 of file MuonTesterTree.h.

{};

m_branches_to_init

std::vector<IMuonTesterBranch*> MuonVal::MuonTesterTree::m_branches_to_init {}

private

Definition at line 143 of file MuonTesterTree.h.

{};

m_commonClients

std::set<MuonTesterTree*> MuonVal::MuonTesterTree::m_commonClients {}

private

List of all other MuonTesterTree instances using this instance as a common Tree If the Tree has one client it is declared as a common Tree.

It can then only be filled once in an event

Definition at line 160 of file MuonTesterTree.h.

{};

m_depCounter

unsigned int MuonVal::MuonTesterTree::m_depCounter {0}

private

Definition at line 125 of file MuonTesterTree.h.

{0};

m_dependencies

std::vector<DataDependency> MuonVal::MuonTesterTree::m_dependencies {}

private

Definition at line 124 of file MuonTesterTree.h.

{};

m_directory

TDirectory* MuonVal::MuonTesterTree::m_directory {nullptr}

private

Definition at line 151 of file MuonTesterTree.h.

{nullptr};

m_excludedBranches

std::set<std::string> MuonVal::MuonTesterTree::m_excludedBranches {}

private

Definition at line 149 of file MuonTesterTree.h.

{};

m_filled

bool MuonVal::MuonTesterTree::m_filled {false}

private

Definition at line 152 of file MuonTesterTree.h.

{false};

m_friendLinks

std::vector<FriendTreePtr> MuonVal::MuonTesterTree::m_friendLinks {}

private

List of all other common instances that are acting as friends.

Definition at line 156 of file MuonTesterTree.h.

{};

m_hash_br

std::shared_ptr<EventHashBranch> MuonVal::MuonTesterTree::m_hash_br

private

Definition at line 162 of file MuonTesterTree.h.

m_hist_svc

ServiceHandle<ITHistSvc> MuonVal::MuonTesterTree::m_hist_svc {"", ""}

private

Definition at line 153 of file MuonTesterTree.h.

{"", ""};

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_init

bool MuonVal::MuonTesterTree::m_init {false}

private

Flag to avoid double initialization with the StoreGate.

Definition at line 131 of file MuonTesterTree.h.

{false};

m_initialized_br

std::set<IMuonTesterBranch*> MuonVal::MuonTesterTree::m_initialized_br {}

private

Set of branches that were already initialized.

Definition at line 147 of file MuonTesterTree.h.

{};

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_path

std::string MuonVal::MuonTesterTree::m_path {}

private

Definition at line 129 of file MuonTesterTree.h.

{};

m_stream

std::string MuonVal::MuonTesterTree::m_stream {}

private

Definition at line 128 of file MuonTesterTree.h.

{};

m_tree

std::unique_ptr<TTree> MuonVal::MuonTesterTree::m_tree {nullptr}

private

Definition at line 127 of file MuonTesterTree.h.

{nullptr};

m_written

bool MuonVal::MuonTesterTree::m_written {false}

private

Flag to indicate whether the TTree is written to the file or not.

Definition at line 133 of file MuonTesterTree.h.

{false};

---

The documentation for this class was generated from the following files:

• MuonTesterTree.h
• MuonTesterTree.cxx