Muon::TriggerChamberClusterOnTrackCreator Class Reference

Tool to cluster several trigger measurements in different gas-gaps of the same detector module. More...

#include <TriggerChamberClusterOnTrackCreator.h>

Inheritance diagram for Muon::TriggerChamberClusterOnTrackCreator:

Collaboration diagram for Muon::TriggerChamberClusterOnTrackCreator:

Public Member Functions
virtual	~TriggerChamberClusterOnTrackCreator ()=default
StatusCode	initialize ()
std::unique_ptr< CompetingMuonClustersOnTrack >	createBroadCluster (const std::list< const Trk::PrepRawData * > &, const double) const
	method to create a CompetingMuonClustersOnTrack using the PrepRawData hits and a scaled factor for the errors

Private Member Functions
void	applyClusterConsistency (std::list< int > &limitingChannels, std::vector< std::unique_ptr< const Muon::MuonClusterOnTrack > > &limitingRots) const
std::vector< std::unique_ptr< const Muon::MuonClusterOnTrack > >	createPrdRots (std::vector< const Trk::PrepRawData * > &prds) const
void	makeClustersBySurface (std::list< int > &limitingChannels, std::vector< std::unique_ptr< const Muon::MuonClusterOnTrack > > &limitingRots, const std::vector< const Trk::PrepRawData * > &prds, const std::vector< std::unique_ptr< const Muon::MuonClusterOnTrack > > &rots) const
void	makeOverallParameters (Trk::LocalParameters &parameters, Amg::MatrixX &errorMatrix, std::unique_ptr< Trk::Surface > &surface, std::list< int > &limitingChannels, std::vector< std::unique_ptr< const Muon::MuonClusterOnTrack > > &limitingRots) const

Private Attributes
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc
ToolHandle< Muon::IMuonClusterOnTrackCreator >	m_clusterCreator
Gaudi::Property< bool >	m_chooseBroadestCluster {this, "ChooseBroadestCluster", true}

Detailed Description

Tool to cluster several trigger measurements in different gas-gaps of the same detector module.

Definition at line 30 of file TriggerChamberClusterOnTrackCreator.h.

Constructor & Destructor Documentation

~TriggerChamberClusterOnTrackCreator()

virtual Muon::TriggerChamberClusterOnTrackCreator::~TriggerChamberClusterOnTrackCreator ( )

virtualdefault

Member Function Documentation

applyClusterConsistency()

void Muon::TriggerChamberClusterOnTrackCreator::applyClusterConsistency ( std::list< int > & limitingChannels, std::vector< std::unique_ptr< const Muon::MuonClusterOnTrack > > & limitingRots ) const

private

Definition at line 94 of file TriggerChamberClusterOnTrackCreator.cxx.

                                                                                {
    // remove any clusters that will NOT contribute to the final cluster
    int numClusters = limitingChannels.size() / 2;
    int sizeMax = 0;
    int sizeMin = 999;
    for (std::list<int>::iterator l = limitingChannels.begin();
         l != limitingChannels.end() &&
         l != std::prev(limitingChannels.end());) {
        int end = *l++;
        int beg = *l++;
        int size = std::abs(end - beg);
        sizeMax = std::max(sizeMax, size);
        sizeMin = std::min(sizeMin, size);
    }
 
    std::list<int>::iterator discard = limitingChannels.end();
    for (std::list<int>::iterator l = limitingChannels.begin();
         l != limitingChannels.end() &&
         l != std::prev(limitingChannels.end());) {
        std::list<int>::iterator first = l;
        int end = *l++;
        int beg = *l++;
        int size = std::abs(end - beg);
        if (m_chooseBroadestCluster && size < sizeMax) {
            discard = first;
        }
        if (!m_chooseBroadestCluster && size > sizeMin) {
            discard = first;
        }
    }
    if (discard == limitingChannels.begin()) {
        ATH_MSG_VERBOSE(" discard cluster #" << 1);
        limitingRots.erase(limitingRots.begin());
        limitingRots.erase(limitingRots.begin());
        limitingChannels.pop_front();
        limitingChannels.pop_front();
    } else if (discard != limitingChannels.end()) {
        ATH_MSG_VERBOSE(" discard cluster #" << numClusters);
        limitingRots.pop_back();
        limitingRots.pop_back();
        limitingChannels.pop_back();
        limitingChannels.pop_back();
    }
}

createBroadCluster()

std::unique_ptr< CompetingMuonClustersOnTrack > Muon::TriggerChamberClusterOnTrackCreator::createBroadCluster	(	const std::list< const Trk::PrepRawData * > &	prdList,
		const double	) const

method to create a CompetingMuonClustersOnTrack using the PrepRawData hits and a scaled factor for the errors

Definition at line 30 of file TriggerChamberClusterOnTrackCreator.cxx.

                                                                       {
    ATH_MSG_VERBOSE("enter createBroadCluster: number of prds " << prdList.size());
 
    // make some PRD consistency checks
    if (prdList.empty()) {
        ATH_MSG_WARNING("fails: empty PRD list ");
        return nullptr;
    }
    std::vector<const Trk::PrepRawData*> prds{prdList.begin(), prdList.end()};
    const Trk::TrkDetElementBase* detectorElement = prds.front()->detectorElement();
    Identifier channelId = (*prds.front()).identify();
    const bool isRpc = m_idHelperSvc->isRpc(channelId);
    const bool isTgc = m_idHelperSvc->isTgc(channelId);
    if (!isRpc && !isTgc) {
        ATH_MSG_WARNING("fails: PRD must be from rpc or tgc ");
        return nullptr;
    }
 
    const bool measuresPhi = m_idHelperSvc->measuresPhi(channelId);
    for (const Trk::PrepRawData* prd : prds) {
        channelId = prd->identify();
        if (m_idHelperSvc->measuresPhi(channelId) != measuresPhi) {
            ATH_MSG_WARNING("fails: PRDs must measure same coordinate ");
            return nullptr;
        }
        if (prd->detectorElement() != detectorElement) {
            ATH_MSG_WARNING("fails: PRDs must be from same detectorElement ");
            return nullptr;
        }
        ATH_MSG_VERBOSE("Create trigger prd from "
                        << m_idHelperSvc->toString(channelId)
                        << ", nDim: " << prd->localCovariance().rows());
    }
 
    // create a rot for each prd (which gets weight zero)
    std::vector<std::unique_ptr<const Muon::MuonClusterOnTrack>> rots = createPrdRots(prds);
    auto assocProbs = std::vector<double>(rots.size(), 0.);
 
    // for each surface, find the first and last rot forming the cluster
    std::list<int> limitingChannels;
    std::vector<std::unique_ptr<const Muon::MuonClusterOnTrack>> limitingRots;
    makeClustersBySurface(limitingChannels, limitingRots, prds, rots);
 
    // cluster consistency - discard any surfaces not contributing to the final cluster
    applyClusterConsistency(limitingChannels, limitingRots);
 
    // overall localPosition, error matrix and surface
    Trk::LocalParameters parameters{};
    Amg::MatrixX errorMatrix{};
    std::unique_ptr<Trk::Surface> surface{};
    makeOverallParameters(parameters, errorMatrix, surface, limitingChannels,
                          limitingRots);
 
    // clear lists
    limitingChannels.clear();
 
    // return the competingMuonClusterOnTrack object containing the final parameters,
    // error matrix, surface, list of rots and weights
    return std::make_unique<CompetingMuonClustersOnTrack>(
        std::move(parameters), std::move(errorMatrix), surface.release(),
        std::move(rots), std::move(assocProbs));
}

createPrdRots()

std::vector< std::unique_ptr< const Muon::MuonClusterOnTrack > > Muon::TriggerChamberClusterOnTrackCreator::createPrdRots ( std::vector< const Trk::PrepRawData * > & prds ) const

private

Definition at line 142 of file TriggerChamberClusterOnTrackCreator.cxx.

                                                  {
    // create clusterRot for each PRD
    std::vector<std::unique_ptr<const Muon::MuonClusterOnTrack>> rots{};
    if (prds.empty()) {
        ATH_MSG_WARNING("empty PRD list ");
        return rots;
    }
    std::optional<int> dim{};
    for (const Trk::PrepRawData* prd : prds) {
        Identifier id = prd->identify();
        const Trk::TrkDetElementBase* detectorElement = prd->detectorElement();
        const Amg::Vector3D globalPosition = detectorElement->center(id);
        std::unique_ptr<const Muon::MuonClusterOnTrack> cluster{
            m_clusterCreator->createRIO_OnTrack(*prd, globalPosition)};
        if (!cluster) {
            ATH_MSG_WARNING("Cannot create a ROT from "
                            << m_idHelperSvc->toString(id) << ".");
            continue;
        }
        if (!dim) {
            dim = cluster->localCovariance().cols();
        } else if ((*dim) != cluster->localCovariance().cols()) {
            ATH_MSG_WARNING("The covariance dimension of "<<m_idHelperSvc->toString(id)
                            <<" does not match "<<(*dim));
            continue;
        }
        rots.push_back(std::move(cluster));
    }
    if (rots.size() != prds.size()) {
        auto [begin, end] = std::ranges::remove_if(prds, [&](const Trk::PrepRawData* prd){
            return std::ranges::none_of(rots, [prd](const std::unique_ptr<const Muon::MuonClusterOnTrack>& rot){
                return rot->identify() == prd->identify();
            });
        });
        prds.erase(begin, end);
    }
    return rots;
}

initialize()

StatusCode Muon::TriggerChamberClusterOnTrackCreator::initialize

(

)

Definition at line 23 of file TriggerChamberClusterOnTrackCreator.cxx.

                                                           {
    ATH_CHECK(m_idHelperSvc.retrieve());
    ATH_CHECK(m_clusterCreator.retrieve());
    return StatusCode::SUCCESS;
}

makeClustersBySurface()

void Muon::TriggerChamberClusterOnTrackCreator::makeClustersBySurface ( std::list< int > & limitingChannels, std::vector< std::unique_ptr< const Muon::MuonClusterOnTrack > > & limitingRots, const std::vector< const Trk::PrepRawData * > & prds, const std::vector< std::unique_ptr< const Muon::MuonClusterOnTrack > > & rots ) const

private

Definition at line 182 of file TriggerChamberClusterOnTrackCreator.cxx.

                                                                              {
    if (prds.empty()) {
        ATH_MSG_WARNING("makeClustersBySurface- empty PRD list ");
        return;
    }
    std::unordered_set<const Trk::PrepRawData*> usedPrd;
    std::vector<std::unique_ptr<const Muon::MuonClusterOnTrack>>::const_iterator r = rots.begin();
    for (std::vector<const Trk::PrepRawData*>::const_iterator p = prds.begin();
         p != prds.end(); ++p, ++r) {
 
        const Trk::PrepRawData* prd{*p};
        if (!usedPrd.insert(prd).second) {
            continue;
        }
        int channel = 0;
        int gasGap = 0;
        const Identifier channelId = prd->identify();
        const bool isRpc = m_idHelperSvc->isRpc(channelId);
        if (isRpc) {
            gasGap = m_idHelperSvc->rpcIdHelper().gasGap(channelId);
            channel = m_idHelperSvc->rpcIdHelper().strip(channelId);
        } else {
            gasGap = m_idHelperSvc->tgcIdHelper().gasGap(channelId);
            channel = m_idHelperSvc->tgcIdHelper().channel(channelId);
        }
        int channelMax = channel;
        int channelMin = channel;
        const Muon::MuonClusterOnTrack *rotMax{r->get()}, *rotMin{r->get()};
        std::vector<const Trk::PrepRawData*>::const_iterator q = p;
        std::vector<std::unique_ptr<const Muon::MuonClusterOnTrack>>::const_iterator s = r;
        for (++q, ++s; q != prds.end(); ++q, ++s) {
            const Identifier channelId1 = (**q).identify();
            if ((isRpc && m_idHelperSvc->rpcIdHelper().gasGap(channelId1) != gasGap) ||
                (!isRpc && m_idHelperSvc->tgcIdHelper().gasGap(channelId1) != gasGap)) {
                continue;
            }
            usedPrd.insert(*q);
            if (isRpc) {
                channel = m_idHelperSvc->rpcIdHelper().strip(channelId1);
            } else {
                channel = m_idHelperSvc->tgcIdHelper().channel(channelId1);
            }
            if (channel > channelMax) {
                channelMax = channel;
                rotMax = s->get();
            }
            if (channel < channelMin) {
                channelMin = channel;
                rotMin = s->get();
            }
        }
        limitingChannels.push_back(channelMin);
        limitingChannels.push_back(channelMax);
        limitingRots.emplace_back(rotMin->clone());
        limitingRots.emplace_back(rotMax->clone());
    }
    ATH_MSG_VERBOSE("makeClustersBySurface - " << limitingChannels.size()
                                               << ", " << limitingRots.size());
}

makeOverallParameters()

void Muon::TriggerChamberClusterOnTrackCreator::makeOverallParameters ( Trk::LocalParameters & parameters, Amg::MatrixX & errorMatrix, std::unique_ptr< Trk::Surface > & surface, std::list< int > & limitingChannels, std::vector< std::unique_ptr< const Muon::MuonClusterOnTrack > > & limitingRots ) const

private

Definition at line 246 of file TriggerChamberClusterOnTrackCreator.cxx.

                                                                                {
 
    std::vector<std::unique_ptr<const Muon::MuonClusterOnTrack>>::const_iterator r = limitingRots.begin();
    Amg::Vector3D centre        = (**r).associatedSurface().center();
    Amg::MatrixX covariance = (**r).localCovariance();
    parameters              = Trk::LocalParameters{(**r).localParameters()};
    const bool isRpc = m_idHelperSvc->isRpc((**r).identify());
    
   
    for (++r;
     r != limitingRots.end();
     ++r)
    {
      centre        += (**r).associatedSurface().center();
      covariance    += (**r).localCovariance();
      parameters    += (**r).localParameters();
    }
    const double norm           = 1. /static_cast<double>(limitingRots.size());
    std::list<int>::iterator l  = limitingChannels.begin();
    int firstChannel        = *l;
    double width        = static_cast<double>(1 + std::abs(*(++l) - firstChannel));
    if (limitingRots.size() > 2)
    {
      int offset = std::abs(*(++l) - firstChannel);
      if (!isRpc && offset < 2) {
        width *= 0.5;
      } else {
        width += static_cast<double>(offset);
      }
    }
 
    // get parameter means
    centre  *= norm;
    covariance  *= width*width*norm;
    parameters  *= norm;
 
    ATH_MSG_VERBOSE("Final parameters "<<m_idHelperSvc->toString((*limitingRots.begin())->identify())<<", centre: "<<Amg::toString(centre)<<", "
                    <<", covariance: "<<covariance<<", parameters: "<<parameters<<" , limiting ROTs: "<<limitingRots.size());
    // finally create the mean ErrorMatrix and the average Surface
    // note the cluster surfaces are assumed to have identical orientation and bounds
    errorMatrix = Amg::MatrixX(covariance);
    const Trk::Surface& surf = (**limitingRots.begin()).associatedSurface();
 
    if (const auto* rectbds =
            dynamic_cast<const Trk::RectangleBounds*>(&surf.bounds())) {
        surface = std::make_unique<Trk::PlaneSurface>(
            surf.transform(), std::make_unique<Trk::RectangleBounds>(*rectbds));
    } else if (const auto* trapbds =
                   dynamic_cast<const Trk::TrapezoidBounds*>(&surf.bounds())) {
        surface = std::make_unique<Trk::PlaneSurface>(
            surf.transform(), std::make_unique<Trk::TrapezoidBounds>(*trapbds));
    } else if (const auto* rottrapbds =
                   dynamic_cast<const Trk::RotatedTrapezoidBounds*>(
                       &surf.bounds())) {
        surface = std::make_unique<Trk::PlaneSurface>(
            surf.transform(),
            std::make_unique<Trk::RotatedTrapezoidBounds>(*rottrapbds));
    }
}

Member Data Documentation

m_chooseBroadestCluster

Gaudi::Property<bool> Muon::TriggerChamberClusterOnTrackCreator::m_chooseBroadestCluster {this, "ChooseBroadestCluster", true}

private

Definition at line 51 of file TriggerChamberClusterOnTrackCreator.h.

{this, "ChooseBroadestCluster", true};

m_clusterCreator

ToolHandle<Muon::IMuonClusterOnTrackCreator> Muon::TriggerChamberClusterOnTrackCreator::m_clusterCreator

private

Initial value:

{
        this, "ClusterCreator",
        "Muon::MuonClusterOnTrackCreator/MuonClusterOnTrackCreator"}

Definition at line 47 of file TriggerChamberClusterOnTrackCreator.h.

                                                               {
        this, "ClusterCreator",
        "Muon::MuonClusterOnTrackCreator/MuonClusterOnTrackCreator"};

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> Muon::TriggerChamberClusterOnTrackCreator::m_idHelperSvc

private

Initial value:

{
        this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

Definition at line 44 of file TriggerChamberClusterOnTrackCreator.h.

                                                     {
        this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

---

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

• TriggerChamberClusterOnTrackCreator.h
• TriggerChamberClusterOnTrackCreator.cxx