MuonR4::HitSummary Struct Reference

Summary struct to hold the hit counts on the track per MS layer. More...

#include <HitSummary.h>

Collaboration diagram for MuonR4::HitSummary:

Public Types
enum class	HitCategory : std::uint8_t { Precision =0 , TriggerEta , TriggerPhi , nCategories }
	Category of the hit. More...
enum class	Status { OnTrack = 0 , Outlier , Hole , MaxValue }
	Contribution to the track fit. More...
using	value_type = std::uint8_t
using	LayerIndex = Muon::MuonStationIndex::LayerIndex
	Abrivation of the layer index.

Public Member Functions
	HitSummary ()=default
	Default constructor.
value_type	value (const HitCategory cat, const Status status, const LayerIndex layer, const bool isSmall) const
	Returns the value type for a defined hit category & layer.
value_type &	value (const HitCategory cat, const Status status, const LayerIndex layer, const bool isSmall)
	Returns the value type for a defined hit category & layer to modify the summary value.

Static Public Member Functions
static std::string	toString (const HitCategory c)
	Converts the hit category to a string.
static std::string	toString (const Status s)
	Converts the status to a string.

Private Types
using	Counter_t
	Abrivation to store the hits per layer.

Private Member Functions
unsigned	translate (const HitCategory cat, const Status status, LayerIndex layer, const bool isSmall) const
	Translates the 4 classification indices to a unique consecutive number (used for storage access)
void	print (std::ostream &ostr) const
	Print the summary as an ASCII table.

Private Attributes
Counter_t	m_counts {}

Friends
std::ostream &	operator<< (std::ostream &ostr, const HitSummary &sum)
	Output string stream operator.

Detailed Description

Summary struct to hold the hit counts on the track per MS layer.

Summaries are categorized by MS layer (Inner / Middle / Outer / Extended), by whether the hit is a precision, trigger eta or trigger phi hit & by their contribution to the track fit. Note: Barrel extended is counted under the Extended category

Definition at line 22 of file HitSummary.h.

Member Typedef Documentation

Counter_t

using MuonR4::HitSummary::Counter_t

private

Initial value:

 std::array<value_type,  Acts::toUnderlying(HitCategory::nCategories) * 
                                                      (Acts::toUnderlying(LayerIndex::LayerIndexMax) -1)* 
                                                      Acts::toUnderlying(Status::MaxValue) * 2>

Abrivation to store the hits per layer.

Definition at line 85 of file HitSummary.h.

LayerIndex

using MuonR4::HitSummary::LayerIndex = Muon::MuonStationIndex::LayerIndex

Abrivation of the layer index.

Definition at line 25 of file HitSummary.h.

value_type

using MuonR4::HitSummary::value_type = std::uint8_t

Definition at line 23 of file HitSummary.h.

Member Enumeration Documentation

HitCategory

enum class MuonR4::HitSummary::HitCategory : std::uint8_t

strong

Category of the hit.

Enumerator
Precision
TriggerEta	Precision hits (Mdt, NSW) on track.
TriggerPhi	Trigger eta hits (Tgc, Rpc)
nCategories	Trigger phi hits (Tgc, Rpc)

Definition at line 29 of file HitSummary.h.

                                  : std::uint8_t{
                Precision=0,         
                TriggerEta,          
                TriggerPhi,          
                nCategories
            };

Status

enum class MuonR4::HitSummary::Status

strong

Contribution to the track fit.

Enumerator
OnTrack
Outlier	Added to the trajectory & contributing to the fit.
Hole	Added to the trajectory but rejected.
MaxValue	Expected hit but missing.

Definition at line 36 of file HitSummary.h.

                              {
                OnTrack = 0,       
                Outlier,           
                Hole,              
                MaxValue                
            };

Constructor & Destructor Documentation

HitSummary()

MuonR4::HitSummary::HitSummary ( )

default

Default constructor.

Member Function Documentation

print()

void MuonR4::HitSummary::print ( std::ostream & ostr ) const

private

Print the summary as an ASCII table.

Definition at line 60 of file HitSummary.cxx.

                                                 {
        using ColumnArray_t = std::array<std::string, 6>;
        std::vector<ColumnArray_t> summaryTable{ColumnArray_t{"layer", "sector", "type",
                                                            "on-track", "outlier", "hole"}};
 
        for (const auto lay: {LayerIndex::Inner, LayerIndex::Middle, LayerIndex::Extended,
                              LayerIndex::Outer}){            
            for (const bool small: {false, true}) {
                for (const auto cat : {HitCategory::Precision, HitCategory::TriggerEta,
                                       HitCategory::TriggerPhi}){
                    const unsigned onTrk = value(cat, Status::OnTrack, lay, small);
                    const unsigned outlier = value(cat, Status::Outlier, lay, small);
                    const unsigned hole = value(cat, Status::Hole, lay, small);
                    if (onTrk + outlier + hole == 0u) {
                        continue;
                    }
                    summaryTable.emplace_back(ColumnArray_t{Muon::MuonStationIndex::layerName(lay),
                                                            (small ? "small" : "large"),
                                                            toString(cat), std::to_string(onTrk),
                                                            std::to_string(outlier), std::to_string(hole)});
                }
            }
        }
        std::array<std::size_t, 6> widths{};
        for (const ColumnArray_t& row : summaryTable) {
            for (std::size_t c = 0 ; c < row.size(); ++c) {
                widths[c] = std::max(widths[c], row[c].size());
            }
        }
        for (const ColumnArray_t& row : summaryTable) {
            ostr<<"|";
            for (std::size_t c = 0; c < row.size(); ++c) {
                const std::size_t W = widths[c] - row[c].size(); 
                const std::size_t nWL = (W - W % 2) / 2;
                const std::size_t nWR = (W - W % 2) / 2 + W%2;
                ostr<<" "<<whiteSpaces(nWL)<<row[c]<<whiteSpaces(nWR)<<" |";
            }
            ostr<<std::endl;
        }
    }

toString() [1/2]

std::string MuonR4::HitSummary::toString ( const HitCategory c )

static

Converts the hit category to a string.

Definition at line 16 of file HitSummary.cxx.

                                                      {
        switch (c) {
            using enum HitCategory;
            case Precision: return "Precision";
            case TriggerEta: return "TriggerEta";
            case TriggerPhi: return "TriggerPhi";
            case nCategories: return "nCategories";
        }
        return "Unknown";
    }

toString() [2/2]

std::string MuonR4::HitSummary::toString ( const Status s )

static

Converts the status to a string.

Definition at line 26 of file HitSummary.cxx.

                                                 {
        switch(s) {
            using enum Status;
            case OnTrack: return "OnTrack";
            case Outlier: return "Outlier";
            case Hole: return "Hole";
            case MaxValue: return "MaxValue";
        }
        return "Unknown";
    }

translate()

unsigned MuonR4::HitSummary::translate ( const HitCategory cat, const Status status, LayerIndex layer, const bool isSmall ) const

private

Translates the 4 classification indices to a unique consecutive number (used for storage access)

Parameters

cat	Hit category
status	Contribution to the fit
layer	Spectrometer layer
isSmall	Small sectors

Map the barrel extended -> extended index

Definition at line 36 of file HitSummary.cxx.

                                                                                {
       using namespace Muon::MuonStationIndex;
       if (layer == LayerIndex::BarrelExtended) {
            layer = LayerIndex::Extended;
       }
       constexpr unsigned A = toInt(Status::MaxValue);
       constexpr unsigned AxB = A * toInt(HitCategory::nCategories);
       constexpr unsigned AxBxC = 2 *AxB;
       const unsigned idx = AxBxC*toInt(layer) + AxB*toInt(isSmall) + A*toInt(cat)  + toInt(status);
       assert(idx < m_counts.size());
       return idx;
    }

value() [1/2]

HitSummary::value_type & MuonR4::HitSummary::value	(	const HitCategory	cat,
		const Status	status,
		const LayerIndex	layer,
		const bool	isSmall )

Returns the value type for a defined hit category & layer to modify the summary value.

Parameters

cat	Hit category
status	Contribution to the fit
layer	Spectrometer layer
isSmall	Small sectors

Definition at line 56 of file HitSummary.cxx.

                                                                      {
        return m_counts[translate(cat, status, layer, isSmall)];
    }

value() [2/2]

HitSummary::value_type MuonR4::HitSummary::value	(	const HitCategory	cat,
		const Status	status,
		const LayerIndex	layer,
		const bool	isSmall ) const

Returns the value type for a defined hit category & layer.

Parameters

cat	Hit category
status	Contribution to the fit
layer	Spectrometer layer
isSmall	Small sectors

Definition at line 51 of file HitSummary.cxx.

                                                                            {
        return m_counts[translate(cat, status, layer, isSmall)];
    }       

Friends And Related Symbol Documentation

operator<<

std::ostream & operator<< ( std::ostream & ostr, const HitSummary & sum )

friend

Output string stream operator.

Definition at line 67 of file HitSummary.h.

                                                                                  {
                sum.print(ostr);
                return ostr;
            }

Member Data Documentation

m_counts

Counter_t MuonR4::HitSummary::m_counts {}

private

Definition at line 89 of file HitSummary.h.

{};

---

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

• HitSummary.h
• HitSummary.cxx