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.
void	setFileStream (const std::string &new_stream)
	Set the file stream post creation.
template<detail::hasHistSvc OWNER>
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 (const 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 38 of file MuonTesterTree.h.

Member Typedef Documentation

DataDependency

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

private

Definition at line 133 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 119 of file MuonTesterTree.h.

Constructor & Destructor Documentation

MuonTesterTree()

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

Definition at line 278 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 282 of file MuonTesterTree.cxx.

                               {
    m_branches_to_init.clear();
}

Member Function Documentation

addBranch() [1/3]

bool MuonVal::MuonTesterTree::addBranch

(

IMuonTesterBranch &

branch

)

Definition at line 64 of file MuonTesterTree.cxx.

{ return addBranch(&branch); }

addBranch() [2/3]

bool MuonVal::MuonTesterTree::addBranch

(

IMuonTesterBranch *

branch

)

Definition at line 65 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 63 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 236 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 248 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 210 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 213 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 216 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 91 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 273 of file MuonTesterTree.cxx.

                                                                               {
    return m_friendLinks;
}

init() [1/2]

StatusCode MuonVal::MuonTesterTree::init ( const 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 122 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;
}

init() [2/2]

template<detail::hasHistSvc OWNER>

StatusCode MuonVal::MuonTesterTree::init

(

OWNER *

instance

)

Initialize method.

initialized()

bool MuonVal::MuonTesterTree::initialized

(

)

const

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

Definition at line 90 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 217 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 276 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 167 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 182 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 user did not set explicit message level we have to initialize
  // the messaging and retrieve the default via the MessageSvc.
  if (m_lvl==MSG::NIL && !m_initialized.test_and_set()) initMessaging();
 
  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 22 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 25 of file MuonTesterTree.cxx.

{ return m_tree.get(); }

operator->() [2/2]

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

(

)

const

Definition at line 27 of file MuonTesterTree.cxx.

{ return m_tree.get(); }

path()

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

(

)

const

sub directory in the TFile

Definition at line 234 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 30 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 88 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 85 of file MuonTesterTree.cxx.

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

setFileStream()

void MuonVal::MuonTesterTree::setFileStream

(

const std::string &

new_stream

)

Set the file stream post creation.

Definition at line 180 of file MuonTesterTree.cxx.

                                                              {
    if (isCommonTree() || initialized()) {
        ATH_MSG_WARNING("Cannot  change file stream");
        return;
    }
    ATH_MSG_DEBUG("Update stream "<<m_stream<<" to "<<new_stream);
    m_stream = new_stream;
 
}

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 233 of file MuonTesterTree.cxx.

{ m_path = new_path; }

tree() [1/2]

TTree * MuonVal::MuonTesterTree::tree

(

)

TTree object.

Definition at line 24 of file MuonTesterTree.cxx.

{ return m_tree.get(); }

tree() [2/2]

const TTree * MuonVal::MuonTesterTree::tree

(

)

const

Definition at line 26 of file MuonTesterTree.cxx.

{ return m_tree.get(); }

write()

StatusCode MuonVal::MuonTesterTree::write

(

)

Finally write the TTree objects.

Definition at line 189 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 155 of file MuonTesterTree.h.

{};

m_branches_to_init

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

private

Definition at line 153 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 170 of file MuonTesterTree.h.

{};

m_depCounter

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

private

Definition at line 135 of file MuonTesterTree.h.

{0};

m_dependencies

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

private

Definition at line 134 of file MuonTesterTree.h.

{};

m_directory

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

private

Definition at line 161 of file MuonTesterTree.h.

{nullptr};

m_excludedBranches

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

private

Definition at line 159 of file MuonTesterTree.h.

{};

m_filled

bool MuonVal::MuonTesterTree::m_filled {false}

private

Definition at line 162 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 166 of file MuonTesterTree.h.

{};

m_hash_br

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

private

Definition at line 172 of file MuonTesterTree.h.

m_hist_svc

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

private

Definition at line 163 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 141 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 157 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 139 of file MuonTesterTree.h.

{};

m_stream

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

private

Definition at line 138 of file MuonTesterTree.h.

{};

m_tree

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

private

Definition at line 137 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 143 of file MuonTesterTree.h.

{false};

---

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

• MuonTesterTree.h
• MuonTesterTree.cxx