#include <MuonPatternRecognitionTestTree.h>

Inheritance diagram for MuonValR4::MuonPatternRecognitionTestTree:

Collaboration diagram for MuonValR4::MuonPatternRecognitionTestTree:

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

Public Member Functions
StatusCode	initialize (AthHistogramAlgorithm *parent)
	initialisation - internally calls the MuonTesterTree::init method More...

void	fillChamberInfo (const MuonGMR4::SpectrometerSector *chamber)

void	fillTruthInfo (const xAOD::MuonSegment truthSegment, const MuonGMR4::MuonDetectorManager detMgr, const ActsGeometryContext &gctx)

void	fillSeedInfo (const ObjectMatching &obj)

void	fillSegmentInfo (const ActsGeometryContext &gctx, const ObjectMatching &obj)

	MuonTesterTree (const std::string &tree_name, const std::string &stream)
	constructor delegates to the parent class More...

TTree *	tree ()
	TTree object. More...

const TTree *	tree () const

TTree *	operator-> ()
	Operator to the TTree object. More...

const TTree *	operator-> () const

bool	initialized () const
	Has the init method been called and the tree is connected with the output file. More...

bool	fill (const EventContext &ctx)
	Fills the tree per call. More...

std::string	name () const
	Name of the tree. More...

const std::string &	fileStream () const
	file_stream of the analysis to which the tree belongs More...

const std::string &	path () const
	sub directory in the TFile More...

void	setPath (const std::string &new_path)
	Save the TTree in a subfolder of the TFile. More...

template<class OWNER , typename = typename std::enable_if<std::is_base_of<IProperty, OWNER>::value>::type>
StatusCode	init (OWNER *instance)
	Initialize method. More...

StatusCode	write ()
	Finally write the TTree objects. More...

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. More...

bool	addBranch (std::shared_ptr< IMuonTesterBranch > branch)
	Branch is added to the tree without transferring the ownership. More...

bool	addBranch (IMuonTesterBranch &branch)

bool	addBranch (IMuonTesterBranch *branch)

void	removeBranch (IMuonTesterBranch *branch)
	In case instances of a certain branch type are destroyed before hand. More...

void	removeBranch (IMuonTesterBranch &branch)

void	disableBranch (const std::string &br_name)
	Skips the branch from being added to the tree. More...

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. More...

template<typename T >
VectorBranch< T > &	newVector (const std::string &name)
	Creates new branches and returns their reference. More...

template<typename T >
VectorBranch< T > &	newVector (const std::string &name, const T def_val)
	Creates and returns branches with a default value. More...

template<typename T >
ScalarBranch< T > &	newScalar (const std::string &name)

template<typename T >
ScalarBranch< T > &	newScalar (const std::string &name, const T def_val)

template<typename T >
MatrixBranch< T > &	newMatrix (const std::string &name)

template<typename T >
MatrixBranch< T > &	newMatrix (const std::string &name, const T def_val)

template<typename T >
SetBranch< T > &	newSet (const std::string &name)

template<typename T >
T &	newBranch (std::shared_ptr< T > br)
	returns the reference of the branch More...

bool	isActive (const IMuonTesterBranch *branch) const
	Returns a boolean whether the branch is already part of the tree or one of the deligated friends. More...

bool	isCommonTree () const
	Returns Whether the Tree is a common tree or not. More...

bool	addCommonTree (FriendTreePtr common_tree)

const std::vector< FriendTreePtr > &	getFriends () const

bool	msgLvl (const MSG::Level lvl) const
	Test the output level. More...

MsgStream &	msg () const
	The standard message stream. More...

MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream. More...

void	setLevel (MSG::Level lvl)
	Change the current logging level. More...

Protected Attributes
MuonVal::ScalarBranch< int > &	m_out_chamberIndex {newScalar<int>("chamberIndex")}
	====== Common block: Filled for all entries =========== More...

MuonVal::ScalarBranch< short > &	m_out_stationSide {newScalar<short>("stationSide")}
	+1 for A-, -1 of C-side More...

MuonVal::ScalarBranch< int > &	m_out_stationPhi {newScalar<int>("stationPhi")}
	phi index of the station More...

MuonVal::ScalarBranch< float > &	m_out_bucketStart {newScalar<float>("bucketStart", 1)}

MuonVal::ScalarBranch< float > &	m_out_bucketEnd {newScalar<float>("bucketEnd", -1)}

MuonVal::ScalarBranch< bool > &	m_out_hasTruth {newScalar<bool>("hasTruth",false)}
	======= Truth block: Filled if we have a truth match. ============ More...

MuonVal::ScalarBranch< float > &	m_out_gen_Eta {newScalar<float>("genEta",-10.)}
	global particle properties More...

MuonVal::ScalarBranch< float > &	m_out_gen_Phi {newScalar<float>("genPhi",-10.)}

MuonVal::ScalarBranch< float > &	m_out_gen_Pt {newScalar<float>("genPt",-10.)}

MuonVal::ScalarBranch< short > &	m_out_gen_Q {newScalar<short>("genQ", 0)}

MuonVal::ScalarBranch< float > &	m_out_gen_y0 {newScalar<float>("genY0", 0.0)}
	Truth - segment parameters More...

MuonVal::ScalarBranch< float > &	m_out_gen_tantheta {newScalar<float>("genTanTheta", 0.0)}

MuonVal::ScalarBranch< float > &	m_out_gen_tanphi {newScalar<float>("genTanPhi", 0.0)}

MuonVal::ScalarBranch< float > &	m_out_gen_x0 {newScalar<float>("genX0", 0.0)}

MuonVal::ScalarBranch< float > &	m_out_gen_time {newScalar<float>("genTime", 0.0)}

MuonVal::ScalarBranch< unsigned short > &	m_out_gen_nHits {newScalar<unsigned short>("genNHits",0)}
	Truth - hit count summary. More...

MuonVal::ScalarBranch< unsigned short > &	m_out_gen_nRPCHits {newScalar<unsigned short>("genNRpcHits",0)}

MuonVal::ScalarBranch< unsigned short > &	m_out_gen_nMDTHits {newScalar<unsigned short>("genNMdtHits",0)}

MuonVal::ScalarBranch< unsigned short > &	m_out_gen_nTGCHits {newScalar<unsigned short>("genNTgcHits",0)}

MuonVal::ScalarBranch< unsigned short > &	m_out_gen_nNswHits {newScalar<unsigned short>("genNNswHits",0)}

MuonVal::ScalarBranch< float > &	m_out_gen_minYhit {newScalar<float>("genMinYhit", 1.0)}

MuonVal::ScalarBranch< float > &	m_out_gen_maxYhit {newScalar<float>("genMaxYhit", -1.0)}

MuonVal::ScalarBranch< unsigned > &	m_out_seed_n {newScalar<unsigned>("nSeeds", 0)}
	========== Seed block: Filled when we have one or multiple seeds ============= seed count More...

MuonVal::VectorBranch< bool > &	m_out_seed_hasPhiExtension {newVector<bool>("seedHasPhiExtension", false)}

MuonVal::VectorBranch< float > &	m_out_seed_nMatchedHits {newVector<float>("seedTruthMatchedHits", false)}

MuonVal::VectorBranch< float > &	m_out_seed_y0 {newVector<float>("seedY0", 0.0)}

MuonVal::VectorBranch< float > &	m_out_seed_x0 {newVector<float>("seedX0", 0.0)}

MuonVal::VectorBranch< float > &	m_out_seed_tantheta {newVector<float>("seedTanTheta", 0.0)}

MuonVal::VectorBranch< float > &	m_out_seed_tanphi {newVector<float>("seedTanPhi", 0.0)}

MuonVal::VectorBranch< float > &	m_out_seed_minYhit {newVector<float>("seedMinYhit", 1.0)}

MuonVal::VectorBranch< float > &	m_out_seed_maxYhit {newVector<float>("seedMaxYhit", -1.0)}

MuonVal::VectorBranch< unsigned short > &	m_out_seed_nHits {newVector<unsigned short>("seedNHits", 0)}

MuonVal::VectorBranch< unsigned short > &	m_out_seed_nEtaHits {newVector<unsigned short>("seedNEtaHits", 0)}

MuonVal::VectorBranch< unsigned short > &	m_out_seed_nPhiHits {newVector<unsigned short>("seedNPhiHits", 0)}

MuonVal::VectorBranch< unsigned short > &	m_out_seed_nMdt {newVector<unsigned short>("seedNMdtHits", 0)}

MuonVal::VectorBranch< unsigned short > &	m_out_seed_nRpc {newVector<unsigned short>("seedNRpcHits", 0)}

MuonVal::VectorBranch< unsigned short > &	m_out_seed_nTgc {newVector<unsigned short>("seedNTgcHits", 0)}

MuonVal::VectorBranch< unsigned short > &	m_out_seed_nsTgc {newVector<unsigned short>("seedNsTgcHits", 0)}

MuonVal::VectorBranch< unsigned short > &	m_out_seed_nMm {newVector<unsigned short>("seedNMmHits", 0)}

MuonVal::VectorBranch< bool > &	m_out_seed_ledToSegment {newVector<bool>("seedConvertedToSegment",false)}

MuonVal::ScalarBranch< unsigned > &	m_out_segment_n {newScalar<unsigned>("nSegments", 0)}
	========== Segment block: Filled when we have one or multiple segments ============= More...

MuonVal::VectorBranch< float > &	m_out_segment_chi2 {newVector<float>("segmentChi2", -1.)}

MuonVal::VectorBranch< uint16_t > &	m_out_segment_nDoF {newVector<uint16_t>("segmentNdoF", 0)}

MuonVal::VectorBranch< bool > &	m_out_segment_hasTimeFit {newVector<bool>("segmentHasTimeFit", false)}

MuonVal::VectorBranch< uint16_t > &	m_out_segment_fitIter {newVector<uint16_t>("segmentFitIterations", 0)}

MuonVal::VectorBranch< bool > &	m_out_segment_hasPhi {newVector<bool>("segmentHasPhiHits", false)}

MuonVal::VectorBranch< float > &	m_out_segment_y0 {newVector<float>("segmentY0", 0.0)}

MuonVal::VectorBranch< float > &	m_out_segment_x0 {newVector<float>("segmentX0", 0.0)}

MuonVal::VectorBranch< float > &	m_out_segment_tantheta {newVector<float>("segmentTanTheta", 0.0)}

MuonVal::VectorBranch< float > &	m_out_segment_tanphi {newVector<float>("segmentTanPhi", 0.0)}

MuonVal::VectorBranch< float > &	m_out_segment_time {newVector<float>("segmentTime", 0.)}

MuonVal::VectorBranch< float > &	m_out_segment_err_y0 {newVector<float>("segmentErrY0", -1.0)}

MuonVal::VectorBranch< float > &	m_out_segment_err_x0 {newVector<float>("segmentErrX0", -1.0)}

MuonVal::VectorBranch< float > &	m_out_segment_err_tantheta {newVector<float>("segmentErrTanTheta", -1.0)}

MuonVal::VectorBranch< float > &	m_out_segment_err_tanphi {newVector<float>("segmentErrTanPhi", -1.0)}

MuonVal::VectorBranch< float > &	m_out_segment_err_time {newVector<float>("segmentErrTime", -1.0)}

MuonVal::VectorBranch< unsigned short > &	m_out_segment_truthMatchedHits {newVector<unsigned short>("segmentTruthMatchedHits", 0)}

MuonVal::VectorBranch< unsigned short > &	m_out_segment_nMdtHits {newVector<unsigned short>("segmentNMdtHits", 0)}

MuonVal::VectorBranch< unsigned short > &	m_out_segment_nRpcEtaHits {newVector<unsigned short>("segmentNRpcEtaHits", 0)}

MuonVal::VectorBranch< unsigned short > &	m_out_segment_nRpcPhiHits {newVector<unsigned short>("segmentNRpcPhiHits", 0)}

MuonVal::VectorBranch< unsigned short > &	m_out_segment_nTgcEtaHits {newVector<unsigned short>("segmentNTgcEtaHits", 0)}

MuonVal::VectorBranch< unsigned short > &	m_out_segment_nTgcPhiHits {newVector<unsigned short>("segmentNTgcPhiHits", 0)}

MuonVal::VectorBranch< float > &	m_out_segment_minYhit {newVector<float>("segmentMinYhit", 1.0)}

MuonVal::VectorBranch< float > &	m_out_segment_maxYhit {newVector<float>("segmentMaxYhit", -1.0)}

Private Types
using	DataDependency = IMuonTesterBranch::DataDependency

Private Member Functions
StatusCode	init (ServiceHandle< ITHistSvc > hist_svc)
	Initialze the tree with the output file. More...

bool	addClient (MuonTesterTree *client)
	Adds the other TTree as a Client and declares this instance as a Common Tree. More...

void	initMessaging () const
	Initialize our message level and MessageSvc. More...

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. More...

bool	m_written {false}
	Flag to indicate whether the TTree is written to the file or not. More...

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. More...

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. More...

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. More...

std::shared_ptr< EventHashBranch >	m_hash_br

std::string	m_nm
	Message source name. More...

boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels) More...

std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer. More...

std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level. More...

std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging) More...

Detailed Description

Definition at line 40 of file MuonPatternRecognitionTestTree.h.

Member Typedef Documentation

◆ DataDependency

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

privateinherited

Definition at line 123 of file MuonTesterTree.h.

◆ FriendTreePtr

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

inherited

Appends the other tester Tree as friend to this instance.

Definition at line 109 of file MuonTesterTree.h.

Member Function Documentation

◆ addBranch() [1/3]

bool MuonVal::MuonTesterTree::addBranch ( IMuonTesterBranch & branch )

inherited

Definition at line 62 of file MuonTesterTree.cxx.

62 { return addBranch(&branch); }

◆ addBranch() [2/3]

bool MuonVal::MuonTesterTree::addBranch ( IMuonTesterBranch * branch )

inherited

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 )

inherited

Branch is added to the tree without transferring the ownership.

Definition at line 61 of file MuonTesterTree.cxx.

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

◆ addClient()

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

privateinherited

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 )

inherited

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 )

inherited

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 )

inherited

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

inherited

file_stream of the analysis to which the tree belongs

Definition at line 205 of file MuonTesterTree.cxx.

205 { return m_stream; }

◆ fill()

bool MuonVal::MuonTesterTree::fill ( const EventContext & ctx )

inherited

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;
 }

◆ fillChamberInfo()

void MuonValR4::MuonPatternRecognitionTestTree::fillChamberInfo ( const MuonGMR4::SpectrometerSector * chamber )

Definition at line 27 of file MuonPatternRecognitionTestTree.cxx.

                                                                                                   {
         m_out_chamberIndex = msSector->chamberIndex();
         m_out_stationSide = msSector->side();
         m_out_stationPhi = msSector->stationPhi();
     }                

◆ fillSeedInfo()

void MuonValR4::MuonPatternRecognitionTestTree::fillSeedInfo ( const ObjectMatching & obj )

Definition at line 82 of file MuonPatternRecognitionTestTree.cxx.

                                                                                {
         m_out_seed_n = obj.matchedSeeds.size();
         int iseed = -1; 
         for (auto & seed : obj.matchedSeeds){
             ++iseed;
             if (m_out_bucketEnd.getVariable() < m_out_bucketStart.getVariable()){
                 m_out_bucketEnd = seed->parentBucket()->coveredMax();
                 m_out_bucketStart = seed->parentBucket()->coveredMin();
             }
             double minYhit = m_out_bucketEnd.getVariable();
             double maxYhit = m_out_bucketStart.getVariable();
             for (auto & hit : seed->getHitsInMax()){
                 minYhit = std::min(hit->positionInChamber().y(),minYhit); 
                 maxYhit = std::max(hit->positionInChamber().y(),maxYhit); 
             }
             m_out_seed_minYhit.push_back(minYhit);
             m_out_seed_maxYhit.push_back(maxYhit);
  
             m_out_seed_hasPhiExtension.push_back(seed->hasPhiExtension()); 
             m_out_seed_nMatchedHits.push_back(obj.matchedSeedHits.at(iseed)); 
             m_out_seed_y0.push_back(seed->interceptY());
             m_out_seed_tantheta.push_back(seed->tanTheta());
             if (seed->hasPhiExtension()){
                 m_out_seed_x0.push_back(seed->interceptX());
                 m_out_seed_tanphi.push_back(seed->tanPhi());
             }
             else{
                 m_out_seed_x0.push_back(-999);
                 m_out_seed_tanphi.push_back(-999);
             }
         
             m_out_seed_nHits.push_back(seed->getHitsInMax().size()); 
             m_out_seed_nEtaHits.push_back(std::accumulate(seed->getHitsInMax().begin(), seed->getHitsInMax().end(),0,
                                                 [](int i, const HoughHitType & h){i += h->measuresEta();return i;})); 
             m_out_seed_nPhiHits.push_back(std::accumulate(seed->getHitsInMax().begin(), seed->getHitsInMax().end(),0,
                                                 [](int i, const HoughHitType & h){i += h->measuresPhi();return i;})); 
             unsigned int nMdtSeed{0}, nRpcSeed{0}, nTgcSeed{0}, nMmSeed{0}, nsTgcSeed{0}; 
             for (const HoughHitType & houghSP: seed->getHitsInMax()){
                 switch (houghSP->type()) {
                     case xAOD::UncalibMeasType::MdtDriftCircleType: 
                         ++nMdtSeed;
                         break;
                     case xAOD::UncalibMeasType::RpcStripType:
                         nRpcSeed+=houghSP->measuresEta();
                         nRpcSeed+=houghSP->measuresPhi();
                         break;
                     case xAOD::UncalibMeasType::TgcStripType:
                         nTgcSeed+=houghSP->measuresEta();
                         nTgcSeed+=houghSP->measuresPhi();
                         break;
                     case xAOD::UncalibMeasType::sTgcStripType:
                         ++nsTgcSeed;
                         break;
                     case xAOD::UncalibMeasType::MMClusterType:
                         ++nMmSeed;
                         break;
                     default:
                         ATH_MSG_WARNING("Technology "<<houghSP->identify()
                                     <<" not yet implemented");                        
                 }                    
             }
             m_out_seed_nMdt.push_back(nMdtSeed);
             m_out_seed_nRpc.push_back(nRpcSeed);
             m_out_seed_nTgc.push_back(nTgcSeed);
             m_out_seed_nsTgc.push_back(nsTgcSeed);
             m_out_seed_nMm.push_back(nMmSeed);
  
             m_out_seed_ledToSegment.push_back(obj.matchedSeedFoundSegment.at(iseed)); 
         }
     }

◆ fillSegmentInfo()

void MuonValR4::MuonPatternRecognitionTestTree::fillSegmentInfo	(	const ActsGeometryContext &	gctx,
		const ObjectMatching &	obj
	)

Definition at line 153 of file MuonPatternRecognitionTestTree.cxx.

                                                                              {
         using namespace SegmentFit;
  
         m_out_segment_n = obj.matchedSegments.size(); 
         int iSegment = -1;
         for (auto & segment : obj.matchedSegments){
             ++iSegment; 
             m_out_segment_hasPhi.push_back(std::ranges::find_if(segment->measurements(), [](const auto& meas){  return meas->measuresPhi();}) 
                                 !=segment->measurements().end());
             m_out_segment_fitIter.push_back(segment->nFitIterations());
             m_out_segment_truthMatchedHits.push_back(obj.matchedSegHits.at(iSegment));
             m_out_segment_chi2.push_back(segment->chi2());
             m_out_segment_nDoF.push_back(segment->nDoF());
             m_out_segment_hasTimeFit.push_back(segment->hasTimeFit());
  
             m_out_segment_err_x0.push_back(segment->covariance()(toInt(ParamDefs::x0), toInt(ParamDefs::x0)));
             m_out_segment_err_y0.push_back(segment->covariance()(toInt(ParamDefs::y0), toInt(ParamDefs::y0)));
             m_out_segment_err_tantheta.push_back(segment->covariance()(toInt(ParamDefs::theta), toInt(ParamDefs::theta)));
             m_out_segment_err_tanphi  .push_back(segment->covariance()(toInt(ParamDefs::phi), toInt(ParamDefs::phi)));
             m_out_segment_err_time.push_back(segment->covariance()(toInt(ParamDefs::time), toInt(ParamDefs::time)));
             const auto [locPos, locDir] = makeLine(localSegmentPars(gctx, *segment));
             m_out_segment_tanphi.push_back(houghTanPhi(locDir));
             m_out_segment_tantheta.push_back(houghTanTheta(locDir));
             m_out_segment_y0.push_back(locPos.y());
             m_out_segment_x0.push_back(locPos.x());
             m_out_segment_time.push_back(segment->segementT0() + segment->position().mag() * c_inv);
  
             unsigned int nMdtHits{0}, nRpcEtaHits{0}, nRpcPhiHits{0}, nTgcEtaHits{0}, nTgcPhiHits{0};
             for (const auto & meas : segment->measurements()){
                 switch (meas->type()) {
                     case xAOD::UncalibMeasType::MdtDriftCircleType:
                         ++nMdtHits;
                         break;
                     case xAOD::UncalibMeasType::RpcStripType:
                         nRpcEtaHits += meas->measuresEta();
                         nRpcPhiHits += meas->measuresPhi();
                         break;
                     case xAOD::UncalibMeasType::TgcStripType:
                         nTgcEtaHits += meas->measuresEta();
                         nTgcPhiHits += meas->measuresPhi();
                         break;
                     default:
                         break;
                 }
             }
             m_out_segment_nMdtHits.push_back(nMdtHits);
             m_out_segment_nRpcEtaHits.push_back(nRpcEtaHits);
             m_out_segment_nRpcPhiHits.push_back(nRpcPhiHits);
             m_out_segment_nTgcEtaHits.push_back(nTgcEtaHits);
             m_out_segment_nTgcPhiHits.push_back(nTgcPhiHits);
  
             double minYhit = std::numeric_limits<double>::max();
             double maxYhit = -1 * std::numeric_limits<double>::max();
             for (auto & hit : segment->measurements()){
                 // skip dummy measurement from beam spot constraint
                 if (hit->type() == xAOD::UncalibMeasType::Other) continue;
                 minYhit = std::min(hit->positionInChamber().y(),minYhit); 
                 maxYhit = std::max(hit->positionInChamber().y(),maxYhit); 
             }
             m_out_segment_minYhit.push_back(minYhit);
             m_out_segment_maxYhit.push_back(maxYhit);
         }
     }

◆ fillTruthInfo()

void MuonValR4::MuonPatternRecognitionTestTree::fillTruthInfo	(	const xAOD::MuonSegment *	truthSegment,
		const MuonGMR4::MuonDetectorManager *	detMgr,
		const ActsGeometryContext &	gctx
	)

Definition at line 32 of file MuonPatternRecognitionTestTree.cxx.

                                                                                                                                                                    {
         if (!segment) return; 
         m_out_hasTruth = true; 
  
         const Amg::Vector3D segDir{segment->direction()};
         static const SG::Accessor<float> acc_pt{"pt"};
         static const SG::Accessor<float> acc_charge{"charge"};
         // eta is interpreted as the eta-location 
         m_out_gen_Eta = segDir.eta();
         m_out_gen_Phi = segDir.phi();
         m_out_gen_Pt  = acc_pt(*segment);
         m_out_gen_Q = acc_charge(*segment);
  
         const auto [chamberPos, chamberDir] = SegmentFit::makeLine(SegmentFit::localSegmentPars(*segment));
         m_out_gen_nHits = segment->nPrecisionHits()+segment->nPhiLayers() + segment->nTrigEtaLayers(); 
        
         m_out_gen_nMDTHits = (segment->technology() == Muon::MuonStationIndex::MDT ? segment->nPrecisionHits() : 0); 
         m_out_gen_nNswHits = (segment->technology() != Muon::MuonStationIndex::MDT ? segment->nPrecisionHits() : 0); 
         m_out_gen_nTGCHits = (segment->chamberIndex() > Muon::MuonStationIndex::ChIndex::BEE ? segment->nPhiLayers() + segment->nTrigEtaLayers() : 0);
         m_out_gen_nRPCHits = (segment->chamberIndex() <= Muon::MuonStationIndex::ChIndex::BEE ? segment->nPhiLayers() + segment->nTrigEtaLayers() : 0);
  
         m_out_gen_tantheta = houghTanTheta(chamberDir); 
         m_out_gen_tanphi   = houghTanPhi(chamberDir);
         m_out_gen_y0 = chamberPos.y(); 
         m_out_gen_x0 = chamberPos.x(); 
         m_out_gen_time = segment->t0();
  
         double minYhit = std::numeric_limits<double>::max();
         double maxYhit = -1 * std::numeric_limits<double>::max();
         for (auto & hit : getMatchingSimHits(*segment)){
             auto RE = detMgr->getReadoutElement(hit->identify()); 
             IdentifierHash hash{};
             if (detMgr->idHelperSvc()->isMdt(hit->identify())){
                 hash = RE->measurementHash(hit->identify());
             }
             else {
                 hash = RE->layerHash(hit->identify());
             }
             auto localToChamber = RE->msSector()->globalToLocalTrans(gctx) * RE->localToGlobalTrans(gctx, hash);
             auto chamberPos = localToChamber * xAOD::toEigen(hit->localPosition()); 
             minYhit = std::min(chamberPos.y(),minYhit); 
             maxYhit = std::max(chamberPos.y(),maxYhit); 
         }
         m_out_gen_minYhit = minYhit;
         m_out_gen_maxYhit = maxYhit;
  
         ATH_MSG_DEBUG("A true max on chamber index "<<m_out_chamberIndex.getVariable()<<" side "<<m_out_stationSide.getVariable()<<" phi "<<m_out_stationPhi.getVariable()<<" with "
                     <<m_out_gen_nMDTHits.getVariable()<<" MDT and "<<m_out_gen_nRPCHits.getVariable()+m_out_gen_nTGCHits.getVariable()<< " trigger hits is at "
                     <<m_out_gen_tantheta.getVariable()<<" and "<<m_out_gen_y0.getVariable()); 
     }

◆ getBranch()

template<class T >

std::shared_ptr<T> MuonVal::MuonTesterTree::getBranch ( const std::string & str ) const

inherited

Retrieves the branches owned by the muon_tree.

◆ getFriends()

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

inherited

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 )

inherited

Initialize method.

◆ init() [2/2]

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

privateinherited

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;
 }

◆ initialize()

StatusCode MuonValR4::MuonPatternRecognitionTestTree::initialize ( AthHistogramAlgorithm * parent )

initialisation - internally calls the MuonTesterTree::init method

Definition at line 22 of file MuonPatternRecognitionTestTree.cxx.

                                                                                       {
         addBranch(std::make_shared<MuonVal::EventInfoBranch>(*this,0));
         ATH_CHECK(init(parent));
         return StatusCode::SUCCESS;
     }

◆ initialized()

bool MuonVal::MuonTesterTree::initialized ( ) const

inherited

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

Definition at line 88 of file MuonTesterTree.cxx.

88 { 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();
   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

inherited

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

inherited

Returns Whether the Tree is a common tree or not.

Definition at line 265 of file MuonTesterTree.cxx.

265 {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 164 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 179 of file AthMessaging.h.

180 { 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_initialized.test_and_set()) initMessaging();
   if (m_lvl <= lvl) {
     msg() << lvl;
     return true;
   } else {
     return false;
   }
 }

◆ MuonTesterTree()

MuonVal::MuonTesterTree::MuonTesterTree

constructor delegates to the parent class

Definition at line 32 of file MuonTesterTree.cxx.

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

◆ name()

std::string MuonVal::MuonTesterTree::name ( ) const

inherited

Name of the tree.

Definition at line 20 of file MuonTesterTree.cxx.

20 { return m_tree->GetName(); }

◆ newBranch()

template<typename T >

T& MuonVal::MuonTesterTree::newBranch ( std::shared_ptr< T > br )

inherited

returns the reference of the branch

◆ newMatrix() [1/2]

template<typename T >

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

inherited

◆ newMatrix() [2/2]

template<typename T >

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

inherited

◆ newScalar() [1/2]

template<typename T >

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

inherited

◆ newScalar() [2/2]

template<typename T >

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

inherited

◆ newSet()

template<typename T >

SetBranch<T>& MuonVal::MuonTesterTree::newSet ( const std::string & name )

inherited

◆ newVector() [1/2]

template<typename T >

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

inherited

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
	)

inherited

Creates and returns branches with a default value.

◆ operator->() [1/2]

TTree * MuonVal::MuonTesterTree::operator-> ( )

inherited

Operator to the TTree object.

Definition at line 23 of file MuonTesterTree.cxx.

23 { return m_tree.get(); }

◆ operator->() [2/2]

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

inherited

Definition at line 25 of file MuonTesterTree.cxx.

25 { return m_tree.get(); }

◆ path()

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

inherited

sub directory in the TFile

Definition at line 223 of file MuonTesterTree.cxx.

223 { return m_path; }

◆ registerBranch()

bool MuonVal::MuonTesterTree::registerBranch ( std::shared_ptr< IMuonTesterBranch > branch )

inherited

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(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(branch);
     return true;
 }

◆ removeBranch() [1/2]

void MuonVal::MuonTesterTree::removeBranch ( IMuonTesterBranch & branch )

inherited

Definition at line 86 of file MuonTesterTree.cxx.

86 { removeBranch(&branch); }

◆ removeBranch() [2/2]

void MuonVal::MuonTesterTree::removeBranch ( IMuonTesterBranch * branch )

inherited

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 )

inherited

Save the TTree in a subfolder of the TFile.

Definition at line 222 of file MuonTesterTree.cxx.

222 { m_path = new_path; }

◆ tree() [1/2]

TTree * MuonVal::MuonTesterTree::tree ( )

inherited

TTree object.

Definition at line 22 of file MuonTesterTree.cxx.

22 { return m_tree.get(); }

◆ tree() [2/2]

const TTree * MuonVal::MuonTesterTree::tree ( ) const

inherited

Definition at line 24 of file MuonTesterTree.cxx.

24 { return m_tree.get(); }

◆ write()

StatusCode MuonVal::MuonTesterTree::write ( )

inherited

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 {}

privateinherited

Definition at line 145 of file MuonTesterTree.h.

◆ m_branches_to_init

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

privateinherited

Definition at line 143 of file MuonTesterTree.h.

◆ m_commonClients

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

privateinherited

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}

privateinherited

Definition at line 125 of file MuonTesterTree.h.

◆ m_dependencies

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

privateinherited

Definition at line 124 of file MuonTesterTree.h.

◆ m_directory

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

privateinherited

Definition at line 151 of file MuonTesterTree.h.

◆ m_excludedBranches

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

privateinherited

Definition at line 149 of file MuonTesterTree.h.

◆ m_filled

bool MuonVal::MuonTesterTree::m_filled {false}

privateinherited

Definition at line 152 of file MuonTesterTree.h.

◆ m_friendLinks

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

privateinherited

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

privateinherited

Definition at line 162 of file MuonTesterTree.h.

◆ m_hist_svc

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

privateinherited

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.

◆ m_init

bool MuonVal::MuonTesterTree::m_init {false}

privateinherited

Flag to avoid double initialization with the StoreGate.

Definition at line 131 of file MuonTesterTree.h.

◆ m_initialized_br

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

privateinherited

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.

◆ 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_out_bucketEnd

MuonVal::ScalarBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_bucketEnd {newScalar<float>("bucketEnd", -1)}

protected

Definition at line 66 of file MuonPatternRecognitionTestTree.h.

◆ m_out_bucketStart

MuonVal::ScalarBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_bucketStart {newScalar<float>("bucketStart", 1)}

protected

Definition at line 65 of file MuonPatternRecognitionTestTree.h.

◆ m_out_chamberIndex

MuonVal::ScalarBranch<int>& MuonValR4::MuonPatternRecognitionTestTree::m_out_chamberIndex {newScalar<int>("chamberIndex")}

protected

====== Common block: Filled for all entries ===========

chamber index field

Definition at line 60 of file MuonPatternRecognitionTestTree.h.

◆ m_out_gen_Eta

MuonVal::ScalarBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_gen_Eta {newScalar<float>("genEta",-10.)}

protected

global particle properties

Definition at line 74 of file MuonPatternRecognitionTestTree.h.

◆ m_out_gen_maxYhit

MuonVal::ScalarBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_gen_maxYhit {newScalar<float>("genMaxYhit", -1.0)}

protected

Definition at line 92 of file MuonPatternRecognitionTestTree.h.

◆ m_out_gen_minYhit

MuonVal::ScalarBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_gen_minYhit {newScalar<float>("genMinYhit", 1.0)}

protected

Definition at line 91 of file MuonPatternRecognitionTestTree.h.

◆ m_out_gen_nHits

MuonVal::ScalarBranch<unsigned short>& MuonValR4::MuonPatternRecognitionTestTree::m_out_gen_nHits {newScalar<unsigned short>("genNHits",0)}

protected

Truth - hit count summary.

Definition at line 85 of file MuonPatternRecognitionTestTree.h.

◆ m_out_gen_nMDTHits

MuonVal::ScalarBranch<unsigned short>& MuonValR4::MuonPatternRecognitionTestTree::m_out_gen_nMDTHits {newScalar<unsigned short>("genNMdtHits",0)}

protected

Definition at line 87 of file MuonPatternRecognitionTestTree.h.

◆ m_out_gen_nNswHits

MuonVal::ScalarBranch<unsigned short>& MuonValR4::MuonPatternRecognitionTestTree::m_out_gen_nNswHits {newScalar<unsigned short>("genNNswHits",0)}

protected

Definition at line 89 of file MuonPatternRecognitionTestTree.h.

◆ m_out_gen_nRPCHits

MuonVal::ScalarBranch<unsigned short>& MuonValR4::MuonPatternRecognitionTestTree::m_out_gen_nRPCHits {newScalar<unsigned short>("genNRpcHits",0)}

protected

Definition at line 86 of file MuonPatternRecognitionTestTree.h.

◆ m_out_gen_nTGCHits

MuonVal::ScalarBranch<unsigned short>& MuonValR4::MuonPatternRecognitionTestTree::m_out_gen_nTGCHits {newScalar<unsigned short>("genNTgcHits",0)}

protected

Definition at line 88 of file MuonPatternRecognitionTestTree.h.

◆ m_out_gen_Phi

MuonVal::ScalarBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_gen_Phi {newScalar<float>("genPhi",-10.)}

protected

Definition at line 75 of file MuonPatternRecognitionTestTree.h.

◆ m_out_gen_Pt

MuonVal::ScalarBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_gen_Pt {newScalar<float>("genPt",-10.)}

protected

Definition at line 76 of file MuonPatternRecognitionTestTree.h.

◆ m_out_gen_Q

MuonVal::ScalarBranch<short>& MuonValR4::MuonPatternRecognitionTestTree::m_out_gen_Q {newScalar<short>("genQ", 0)}

protected

Definition at line 77 of file MuonPatternRecognitionTestTree.h.

◆ m_out_gen_tanphi

MuonVal::ScalarBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_gen_tanphi {newScalar<float>("genTanPhi", 0.0)}

protected

Definition at line 81 of file MuonPatternRecognitionTestTree.h.

◆ m_out_gen_tantheta

MuonVal::ScalarBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_gen_tantheta {newScalar<float>("genTanTheta", 0.0)}

protected

Definition at line 80 of file MuonPatternRecognitionTestTree.h.

◆ m_out_gen_time

MuonVal::ScalarBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_gen_time {newScalar<float>("genTime", 0.0)}

protected

Definition at line 83 of file MuonPatternRecognitionTestTree.h.

◆ m_out_gen_x0

MuonVal::ScalarBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_gen_x0 {newScalar<float>("genX0", 0.0)}

protected

Definition at line 82 of file MuonPatternRecognitionTestTree.h.

◆ m_out_gen_y0

MuonVal::ScalarBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_gen_y0 {newScalar<float>("genY0", 0.0)}

protected

Truth - segment parameters

Definition at line 79 of file MuonPatternRecognitionTestTree.h.

◆ m_out_hasTruth

MuonVal::ScalarBranch<bool>& MuonValR4::MuonPatternRecognitionTestTree::m_out_hasTruth {newScalar<bool>("hasTruth",false)}

protected

======= Truth block: Filled if we have a truth match. ============

existence of a truth match

Definition at line 71 of file MuonPatternRecognitionTestTree.h.

◆ m_out_seed_hasPhiExtension

MuonVal::VectorBranch<bool>& MuonValR4::MuonPatternRecognitionTestTree::m_out_seed_hasPhiExtension {newVector<bool>("seedHasPhiExtension", false)}

protected

Definition at line 100 of file MuonPatternRecognitionTestTree.h.

◆ m_out_seed_ledToSegment

MuonVal::VectorBranch<bool>& MuonValR4::MuonPatternRecognitionTestTree::m_out_seed_ledToSegment {newVector<bool>("seedConvertedToSegment",false)}

protected

Definition at line 123 of file MuonPatternRecognitionTestTree.h.

◆ m_out_seed_maxYhit

MuonVal::VectorBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_seed_maxYhit {newVector<float>("seedMaxYhit", -1.0)}

protected

Definition at line 112 of file MuonPatternRecognitionTestTree.h.

◆ m_out_seed_minYhit

MuonVal::VectorBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_seed_minYhit {newVector<float>("seedMinYhit", 1.0)}

protected

Definition at line 111 of file MuonPatternRecognitionTestTree.h.

◆ m_out_seed_n

MuonVal::ScalarBranch<unsigned>& MuonValR4::MuonPatternRecognitionTestTree::m_out_seed_n {newScalar<unsigned>("nSeeds", 0)}

protected

========== Seed block: Filled when we have one or multiple seeds ============= seed count

Definition at line 96 of file MuonPatternRecognitionTestTree.h.

◆ m_out_seed_nEtaHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonPatternRecognitionTestTree::m_out_seed_nEtaHits {newVector<unsigned short>("seedNEtaHits", 0)}

protected

Definition at line 115 of file MuonPatternRecognitionTestTree.h.

◆ m_out_seed_nHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonPatternRecognitionTestTree::m_out_seed_nHits {newVector<unsigned short>("seedNHits", 0)}

protected

Definition at line 114 of file MuonPatternRecognitionTestTree.h.

◆ m_out_seed_nMatchedHits

MuonVal::VectorBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_seed_nMatchedHits {newVector<float>("seedTruthMatchedHits", false)}

protected

Definition at line 102 of file MuonPatternRecognitionTestTree.h.

◆ m_out_seed_nMdt

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonPatternRecognitionTestTree::m_out_seed_nMdt {newVector<unsigned short>("seedNMdtHits", 0)}

protected

Definition at line 117 of file MuonPatternRecognitionTestTree.h.

◆ m_out_seed_nMm

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonPatternRecognitionTestTree::m_out_seed_nMm {newVector<unsigned short>("seedNMmHits", 0)}

protected

Definition at line 121 of file MuonPatternRecognitionTestTree.h.

◆ m_out_seed_nPhiHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonPatternRecognitionTestTree::m_out_seed_nPhiHits {newVector<unsigned short>("seedNPhiHits", 0)}

protected

Definition at line 116 of file MuonPatternRecognitionTestTree.h.

◆ m_out_seed_nRpc

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonPatternRecognitionTestTree::m_out_seed_nRpc {newVector<unsigned short>("seedNRpcHits", 0)}

protected

Definition at line 118 of file MuonPatternRecognitionTestTree.h.

◆ m_out_seed_nsTgc

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonPatternRecognitionTestTree::m_out_seed_nsTgc {newVector<unsigned short>("seedNsTgcHits", 0)}

protected

Definition at line 120 of file MuonPatternRecognitionTestTree.h.

◆ m_out_seed_nTgc

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonPatternRecognitionTestTree::m_out_seed_nTgc {newVector<unsigned short>("seedNTgcHits", 0)}

protected

Definition at line 119 of file MuonPatternRecognitionTestTree.h.

◆ m_out_seed_tanphi

MuonVal::VectorBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_seed_tanphi {newVector<float>("seedTanPhi", 0.0)}

protected

Definition at line 108 of file MuonPatternRecognitionTestTree.h.

◆ m_out_seed_tantheta

MuonVal::VectorBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_seed_tantheta {newVector<float>("seedTanTheta", 0.0)}

protected

Definition at line 107 of file MuonPatternRecognitionTestTree.h.

◆ m_out_seed_x0

MuonVal::VectorBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_seed_x0 {newVector<float>("seedX0", 0.0)}

protected

Definition at line 106 of file MuonPatternRecognitionTestTree.h.

◆ m_out_seed_y0

MuonVal::VectorBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_seed_y0 {newVector<float>("seedY0", 0.0)}

protected

Definition at line 105 of file MuonPatternRecognitionTestTree.h.

◆ m_out_segment_chi2

MuonVal::VectorBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_segment_chi2 {newVector<float>("segmentChi2", -1.)}

protected

Definition at line 132 of file MuonPatternRecognitionTestTree.h.

◆ m_out_segment_err_tanphi

MuonVal::VectorBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_segment_err_tanphi {newVector<float>("segmentErrTanPhi", -1.0)}

protected

Definition at line 151 of file MuonPatternRecognitionTestTree.h.

◆ m_out_segment_err_tantheta

MuonVal::VectorBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_segment_err_tantheta {newVector<float>("segmentErrTanTheta", -1.0)}

protected

Definition at line 150 of file MuonPatternRecognitionTestTree.h.

◆ m_out_segment_err_time

MuonVal::VectorBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_segment_err_time {newVector<float>("segmentErrTime", -1.0)}

protected

Definition at line 152 of file MuonPatternRecognitionTestTree.h.

◆ m_out_segment_err_x0

MuonVal::VectorBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_segment_err_x0 {newVector<float>("segmentErrX0", -1.0)}

protected

Definition at line 149 of file MuonPatternRecognitionTestTree.h.

◆ m_out_segment_err_y0

MuonVal::VectorBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_segment_err_y0 {newVector<float>("segmentErrY0", -1.0)}

protected

Definition at line 148 of file MuonPatternRecognitionTestTree.h.

◆ m_out_segment_fitIter

MuonVal::VectorBranch<uint16_t>& MuonValR4::MuonPatternRecognitionTestTree::m_out_segment_fitIter {newVector<uint16_t>("segmentFitIterations", 0)}

protected

Definition at line 135 of file MuonPatternRecognitionTestTree.h.

◆ m_out_segment_hasPhi

MuonVal::VectorBranch<bool>& MuonValR4::MuonPatternRecognitionTestTree::m_out_segment_hasPhi {newVector<bool>("segmentHasPhiHits", false)}

protected

Definition at line 138 of file MuonPatternRecognitionTestTree.h.

◆ m_out_segment_hasTimeFit

MuonVal::VectorBranch<bool>& MuonValR4::MuonPatternRecognitionTestTree::m_out_segment_hasTimeFit {newVector<bool>("segmentHasTimeFit", false)}

protected

Definition at line 134 of file MuonPatternRecognitionTestTree.h.

◆ m_out_segment_maxYhit

MuonVal::VectorBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_segment_maxYhit {newVector<float>("segmentMaxYhit", -1.0)}

protected

Definition at line 164 of file MuonPatternRecognitionTestTree.h.

◆ m_out_segment_minYhit

MuonVal::VectorBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_segment_minYhit {newVector<float>("segmentMinYhit", 1.0)}

protected

Definition at line 163 of file MuonPatternRecognitionTestTree.h.

◆ m_out_segment_n

MuonVal::ScalarBranch<unsigned>& MuonValR4::MuonPatternRecognitionTestTree::m_out_segment_n {newScalar<unsigned>("nSegments", 0)}

protected

========== Segment block: Filled when we have one or multiple segments =============

Definition at line 128 of file MuonPatternRecognitionTestTree.h.

◆ m_out_segment_nDoF

MuonVal::VectorBranch<uint16_t>& MuonValR4::MuonPatternRecognitionTestTree::m_out_segment_nDoF {newVector<uint16_t>("segmentNdoF", 0)}

protected

Definition at line 133 of file MuonPatternRecognitionTestTree.h.

◆ m_out_segment_nMdtHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonPatternRecognitionTestTree::m_out_segment_nMdtHits {newVector<unsigned short>("segmentNMdtHits", 0)}

protected

Definition at line 156 of file MuonPatternRecognitionTestTree.h.

◆ m_out_segment_nRpcEtaHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonPatternRecognitionTestTree::m_out_segment_nRpcEtaHits {newVector<unsigned short>("segmentNRpcEtaHits", 0)}

protected

Definition at line 157 of file MuonPatternRecognitionTestTree.h.

◆ m_out_segment_nRpcPhiHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonPatternRecognitionTestTree::m_out_segment_nRpcPhiHits {newVector<unsigned short>("segmentNRpcPhiHits", 0)}

protected

Definition at line 158 of file MuonPatternRecognitionTestTree.h.

◆ m_out_segment_nTgcEtaHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonPatternRecognitionTestTree::m_out_segment_nTgcEtaHits {newVector<unsigned short>("segmentNTgcEtaHits", 0)}

protected

Definition at line 159 of file MuonPatternRecognitionTestTree.h.

◆ m_out_segment_nTgcPhiHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonPatternRecognitionTestTree::m_out_segment_nTgcPhiHits {newVector<unsigned short>("segmentNTgcPhiHits", 0)}

protected

Definition at line 160 of file MuonPatternRecognitionTestTree.h.

◆ m_out_segment_tanphi

MuonVal::VectorBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_segment_tanphi {newVector<float>("segmentTanPhi", 0.0)}

protected

Definition at line 144 of file MuonPatternRecognitionTestTree.h.

◆ m_out_segment_tantheta

MuonVal::VectorBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_segment_tantheta {newVector<float>("segmentTanTheta", 0.0)}

protected

Definition at line 143 of file MuonPatternRecognitionTestTree.h.

◆ m_out_segment_time

MuonVal::VectorBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_segment_time {newVector<float>("segmentTime", 0.)}

protected

Definition at line 145 of file MuonPatternRecognitionTestTree.h.

◆ m_out_segment_truthMatchedHits

MuonVal::VectorBranch<unsigned short>& MuonValR4::MuonPatternRecognitionTestTree::m_out_segment_truthMatchedHits {newVector<unsigned short>("segmentTruthMatchedHits", 0)}

protected

Definition at line 155 of file MuonPatternRecognitionTestTree.h.

◆ m_out_segment_x0

MuonVal::VectorBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_segment_x0 {newVector<float>("segmentX0", 0.0)}

protected

Definition at line 142 of file MuonPatternRecognitionTestTree.h.

◆ m_out_segment_y0

MuonVal::VectorBranch<float>& MuonValR4::MuonPatternRecognitionTestTree::m_out_segment_y0 {newVector<float>("segmentY0", 0.0)}

protected

Definition at line 141 of file MuonPatternRecognitionTestTree.h.

◆ m_out_stationPhi

MuonVal::ScalarBranch<int>& MuonValR4::MuonPatternRecognitionTestTree::m_out_stationPhi {newScalar<int>("stationPhi")}

protected

phi index of the station

Definition at line 64 of file MuonPatternRecognitionTestTree.h.

◆ m_out_stationSide

MuonVal::ScalarBranch<short>& MuonValR4::MuonPatternRecognitionTestTree::m_out_stationSide {newScalar<short>("stationSide")}

protected

+1 for A-, -1 of C-side

Definition at line 62 of file MuonPatternRecognitionTestTree.h.

◆ m_path

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

privateinherited

Definition at line 129 of file MuonTesterTree.h.

◆ m_stream

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

privateinherited

Definition at line 128 of file MuonTesterTree.h.

◆ m_tree

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

privateinherited

Definition at line 127 of file MuonTesterTree.h.

◆ m_written

bool MuonVal::MuonTesterTree::m_written {false}

privateinherited

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

Definition at line 133 of file MuonTesterTree.h.

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

Public Types

Public Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ DataDependency

◆ FriendTreePtr

Member Function Documentation

◆ addBranch() [1/3]

◆ addBranch() [2/3]

◆ addBranch() [3/3]

◆ addClient()

◆ addCommonTree()

◆ disableBranch() [1/2]

◆ disableBranch() [2/2]

◆ fileStream()

◆ fill()

◆ fillChamberInfo()

◆ fillSeedInfo()

◆ fillSegmentInfo()

◆ fillTruthInfo()

◆ getBranch()

◆ getFriends()

◆ init() [1/2]

◆ init() [2/2]

◆ initialize()

◆ initialized()

◆ initMessaging()

◆ isActive()

◆ isCommonTree()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ MuonTesterTree()

◆ name()

◆ newBranch()

◆ newMatrix() [1/2]

◆ newMatrix() [2/2]

◆ newScalar() [1/2]

◆ newScalar() [2/2]

◆ newSet()

◆ newVector() [1/2]

◆ newVector() [2/2]

◆ operator->() [1/2]

◆ operator->() [2/2]

◆ path()

◆ registerBranch()

◆ removeBranch() [1/2]

◆ removeBranch() [2/2]

◆ setLevel()

◆ setPath()

◆ tree() [1/2]

◆ tree() [2/2]

◆ write()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ m_branches

◆ m_branches_to_init

◆ m_commonClients

◆ m_depCounter

◆ m_dependencies

◆ m_directory

◆ m_excludedBranches

◆ m_filled

◆ m_friendLinks

◆ m_hash_br

◆ m_hist_svc

◆ m_imsg

◆ m_init

◆ m_initialized_br

◆ m_lvl

◆ m_msg_tls

◆ m_nm

◆ m_out_bucketEnd

◆ m_out_bucketStart

◆ m_out_chamberIndex

◆ m_out_gen_Eta