FPGATrackSimClusteringTool Class Reference

#include <FPGATrackSimClusteringTool.h>

Inheritance diagram for FPGATrackSimClusteringTool:

Collaboration diagram for FPGATrackSimClusteringTool:

Public Member Functions
	FPGATrackSimClusteringTool (const std::string &, const std::string &, const IInterface *)
virtual	~FPGATrackSimClusteringTool ()=default
virtual StatusCode	initialize () override
virtual StatusCode	DoClustering (FPGATrackSimLogicalEventInputHeader &, std::vector< FPGATrackSimCluster > &) const override

Private Types
using	HitPtrCollection = std::vector<std::unique_ptr<FPGATrackSimHit>>
using	HitPtrContainer = std::vector<HitPtrCollection>

Private Member Functions
void	SortedClustering (HitPtrContainer &&sorted_hits, std::vector< FPGATrackSimCluster > &) const
void	Clustering (HitPtrCollection &&, std::vector< FPGATrackSimCluster > &) const
void	reduceGlobalCoordPrecision (FPGATrackSimCluster &cluster) const
void	reduceGlobalCoordPrecision (FPGATrackSimHit &hit) const
void	splitAndSortHits (HitPtrCollection &&hits, HitPtrContainer &hitsPerModule, int &eta_phi) const
void	splitAndSortHits (HitPtrCollection &&hits, HitPtrContainer &hitsPerModule) const
void	splitHitsToModules (HitPtrCollection &&hits, HitPtrContainer &hitsPerModule) const
void	normaliseClusters (std::vector< FPGATrackSimCluster > &clusters) const
void	sortHitsOnModules (HitPtrContainer &hitsPerModule, int &eta_phi) const
void	sortHitsOnModules (HitPtrContainer &hitsPerModule) const
bool	etaOrPhi (const FPGATrackSimHit &hit) const
bool	sortIBLInput (const std::unique_ptr< FPGATrackSimHit > &i, const std::unique_ptr< FPGATrackSimHit > &j) const
bool	sortPixelInput (const std::unique_ptr< FPGATrackSimHit > &i, const std::unique_ptr< FPGATrackSimHit > &j) const
void	SetMinMaxIndicies (FPGATrackSimCluster &cluster) const

Private Attributes
Gaudi::Property< bool >	m_digitalClustering {this, "DigitalClustering", true, "flag to enable digital clustering instead of ToT weighted position calculation" }
Gaudi::Property< bool >	m_reduceCoordPrecision {this, "ReduceCoordPrecision", false, "flag to enable reducing the precision of global coordinates" }
Gaudi::Property< float >	m_coordRPrecision {this, "CoordRPrecision", 1./64., "fixed point precision of r coordinate" }
Gaudi::Property< float >	m_coordPhiPrecision {this, "CoordPhiPrecision", 1./8192., "fixed point precision of phi coordinate" }
Gaudi::Property< float >	m_coordZPrecision {this, "CoordZPrecision", 1./32., "fixed point precision of z coordinate" }
Gaudi::Property< int >	m_LorentzAngleShift { this, "LorentzAngleShift", -1, "flag for Lorentz angle shift. -1 means off, 0 means full corrections from first version, 1 means smaller LUT, 2 means very small LUT" }
ToolHandle< FPGATrackSim::LorentzAngleTool >	m_lorentzAngleTool {this, "LorentzAngleTool", "", "FPGATrackSim tool to retrieve Lorentz angle"}

Detailed Description

Definition at line 33 of file FPGATrackSimClusteringTool.h.

Member Typedef Documentation

HitPtrCollection

using FPGATrackSimClusteringTool::HitPtrCollection = std::vector<std::unique_ptr<FPGATrackSimHit>>

private

Definition at line 54 of file FPGATrackSimClusteringTool.h.

HitPtrContainer

using FPGATrackSimClusteringTool::HitPtrContainer = std::vector<HitPtrCollection>

private

Definition at line 55 of file FPGATrackSimClusteringTool.h.

Constructor & Destructor Documentation

FPGATrackSimClusteringTool()

FPGATrackSimClusteringTool::FPGATrackSimClusteringTool	(	const std::string &	algname,
		const std::string &	name,
		const IInterface *	ifc )

Definition at line 20 of file FPGATrackSimClusteringTool.cxx.

                                                                                                                             :
    base_class(algname, name, ifc)
{
}

~FPGATrackSimClusteringTool()

virtual FPGATrackSimClusteringTool::~FPGATrackSimClusteringTool ( )

virtualdefault

Member Function Documentation

Clustering()

void FPGATrackSimClusteringTool::Clustering ( HitPtrCollection && moduleHits, std::vector< FPGATrackSimCluster > & moduleClusters ) const

private

Definition at line 132 of file FPGATrackSimClusteringTool.cxx.

                                                                                                                               {
    FPGATrackSimHit clusterEquiv;
    bool newHit;
 
    //To hold the current cluster vars for comparison
    //loop over the hits that we have been passed for this module
    for( auto& hit: moduleHits){
        bool is_clustered_hit = false;
        std::vector<FPGATrackSimCluster>::iterator it_added_clus;
 
        //Loop over the clusters we have already made, check if this hit should be added to them?
        for(std::vector<FPGATrackSimCluster>::iterator it = moduleClusters.begin(); it != moduleClusters.end(); ++it) {
            if(hit->isPixel()) {
                if (FPGATrackSimCLUSTERING::updatePixelCluster(*it, *hit, false, m_digitalClustering)) {
                    if (!is_clustered_hit) {
                        is_clustered_hit = true;
                        it_added_clus = it;
                    } else {
                        int cPhi = it->getClusterEquiv().getPhiIndex();
                        int cPhiWidth = it->getClusterEquiv().getPhiWidth();
                        int cEta = it->getClusterEquiv().getEtaIndex();
                        int cEtaWidth = it->getClusterEquiv().getEtaWidth();
                        int fCPhi = it_added_clus->getClusterEquiv().getPhiIndex();
                        int fCPhiWidth = it_added_clus->getClusterEquiv().getPhiWidth();
                        int fCEta = it_added_clus->getClusterEquiv().getEtaIndex();
                        int fCEtaWidth = it_added_clus->getClusterEquiv().getEtaWidth();
 
                        clusterEquiv = it_added_clus->getClusterEquiv();
 
                        // set new phi & phi width
                        if (cPhi < fCPhi) {
                            clusterEquiv.setPhiIndex(cPhi);
                            if (cPhi + cPhiWidth < fCPhi + fCPhiWidth)
                                clusterEquiv.setPhiWidth(fCPhiWidth + (fCPhi - cPhi));
                            else
                                clusterEquiv.setPhiWidth(cPhiWidth);
                        } else {
                            clusterEquiv.setPhiIndex(fCPhi);
                            if (!(cPhi + cPhiWidth < fCPhi + fCPhiWidth))
                                clusterEquiv.setPhiWidth(cPhiWidth + (cPhi - fCPhi));
                            else
                                clusterEquiv.setPhiWidth(fCPhiWidth);
                        }
 
                        // set new eta & eta width
                        if (cEta < fCEta) {
                            clusterEquiv.setEtaIndex(cEta);
                            if (cEta + cEtaWidth < fCEta + fCEtaWidth)
                                clusterEquiv.setEtaWidth(fCEtaWidth + (fCEta - cEta));
                            else
                                clusterEquiv.setEtaWidth(cEtaWidth);
                        } else {
                            clusterEquiv.setEtaIndex(fCEta);
                            if (!(cEta + cEtaWidth < fCEta + fCEtaWidth))
                                clusterEquiv.setEtaWidth(cEtaWidth + (cEta - fCEta));
                            else
                                clusterEquiv.setEtaWidth(fCEtaWidth);
                        }
 
                        it_added_clus->setClusterEquiv(clusterEquiv);
 
                        for (auto& hit : it->getHitList()) {
                            newHit = true;
                            for (auto& finalHit : it_added_clus->getHitList()) {
                                if (hit.getEtaIndex() == finalHit.getEtaIndex() &&
                                        hit.getPhiIndex() == finalHit.getPhiIndex())
                                    newHit = false;
                            }
                            if (newHit) {
                                CXXUTILS_TRAPPING_FP;
                                clusterEquiv = it_added_clus->getClusterEquiv();
                                float xOld = clusterEquiv.getX();
                                float yOld = clusterEquiv.getY();
                                float zOld = clusterEquiv.getZ();
                                float xPhiOld = clusterEquiv.getPhiCoord();
                                float xEtaOld = clusterEquiv.getEtaCoord();
                                float cPhiOld = clusterEquiv.getCentroidPhiIndex();
                                float cEtaOld = clusterEquiv.getCentroidEtaIndex();
                                float xNew = hit.getX();
                                float yNew = hit.getY();
                                float zNew = hit.getZ();
                                float xPhiNew = hit.getPhiCoord();
                                float xEtaNew = hit.getEtaCoord();
                                float cPhiNew = hit.getPhiIndex();
                                float cEtaNew = hit.getEtaIndex();
                                int tot = clusterEquiv.getToT();
                                int totNew = hit.getToT();
                                if (m_digitalClustering) {
                                    // n+1 because that is old + new now
                                    int n = it_added_clus->getHitList().size();
                                    clusterEquiv.setX((xOld*n + xNew) / (n+1));
                                    clusterEquiv.setY((yOld*n + yNew) / (n+1));
                                    clusterEquiv.setZ((zOld*n + zNew) / (n+1));
                                    clusterEquiv.setPhiCoord((xPhiOld*n + xPhiNew) / (n+1));
                                    clusterEquiv.setEtaCoord((xEtaOld*n + xEtaNew) / (n+1));
                                    clusterEquiv.setCentroidPhiIndex((cPhiOld*n + cPhiNew) / (n+1));
                                    clusterEquiv.setCentroidEtaIndex((cEtaOld*n + cEtaNew) / (n+1));
                                } else {
                                    clusterEquiv.setX((xOld*tot + xNew*totNew) / (tot+totNew));
                                    clusterEquiv.setY((yOld*tot + yNew*totNew) / (tot+totNew));
                                    clusterEquiv.setZ((zOld*tot + zNew*totNew) / (tot+totNew));
                                    clusterEquiv.setPhiCoord((xPhiOld*tot + xPhiNew*totNew) / (tot+totNew));
                                    clusterEquiv.setEtaCoord((xEtaOld*tot + xEtaNew*totNew) / (tot+totNew));
                                    clusterEquiv.setCentroidPhiIndex((cPhiOld*tot + cPhiNew*totNew) / (tot+totNew));
                                    clusterEquiv.setCentroidEtaIndex((cEtaOld*tot + cEtaNew*totNew) / (tot+totNew));
                                }
                                clusterEquiv.setToT(tot + totNew);
                                it_added_clus->setClusterEquiv(clusterEquiv);
                                it_added_clus->push_backHitList(hit);
                            }
                        }
 
                        // move the last cluster to the newly freed spot in the cluster array if the merged cluster was not
                        // already the last cluster, decrease loop counter by one, so that this cluster gets also checked
                        // against the current hit
                        if (it != moduleClusters.end() - 1) {
                            *it = moduleClusters.back();
                            moduleClusters.pop_back();
                            it -= 1;
                        } else {
                            moduleClusters.pop_back();
                            break;
            }
                    }
                }
            }
            if(hit->isStrip()){
                if (FPGATrackSimCLUSTERING::updateStripCluster(*it, *hit, false, m_digitalClustering))
                    is_clustered_hit = true;
            }
        }
 
        //If it is the first hit or a not clustered hit, then start a new cluster and add it to the output vector
        if((!is_clustered_hit) || (moduleClusters.size() == 0)){
            FPGATrackSimCluster cluster;
            if(hit->isPixel()){
                // No need to check the return code here
                FPGATrackSimCLUSTERING::updatePixelCluster(cluster, *hit, true, m_digitalClustering);
            } else if(hit->isStrip()){
                FPGATrackSimCLUSTERING::updateStripCluster(cluster, *hit, true, m_digitalClustering);
            }
            //Put this cluster into the output hits. Will update it in place.
            moduleClusters.push_back(cluster);
        }
    }
    moduleHits.clear();
}

DoClustering()

StatusCode FPGATrackSimClusteringTool::DoClustering ( FPGATrackSimLogicalEventInputHeader & header, std::vector< FPGATrackSimCluster > & clusters ) const

overridevirtual

Definition at line 31 of file FPGATrackSimClusteringTool.cxx.

{
    for (int i = 0; i<header.nTowers(); i++)
    {
        // Retreive the hits from the tower
        FPGATrackSimTowerInputHeader& tower = *header.getTower(i);
        HitPtrCollection hits;
        hits.reserve(tower.hits().size());
        for (auto& hit : tower.hits()) {
            hits.push_back(std::make_unique<FPGATrackSimHit>(hit));
        }
 
        HitPtrContainer hitsPerModule;
        std::vector<FPGATrackSimCluster> towerClusters;
 
        if (m_reduceCoordPrecision) {
            for (auto &hit : hits)
                reduceGlobalCoordPrecision(*hit);
        }
 
        splitAndSortHits(std::move(hits), hitsPerModule);
        SortedClustering(std::move(hitsPerModule), towerClusters);
        normaliseClusters(towerClusters);
 
        //remove the old hits from the tower...
        tower.clearHits();
        tower.reserveHits(towerClusters.size());
        clusters.clear();
        clusters.reserve(towerClusters.size());
        if(i > 1)
            ATH_MSG_WARNING("more than one tower, m_clusters is only going to contain those from the last one");
 
        unsigned cluster_count = 0;
        unsigned int pixelCounter =  0;
        unsigned int stripCounter = 0;
        for ( auto &cluster: towerClusters){
            SetMinMaxIndicies(cluster);
            if (m_reduceCoordPrecision)
                reduceGlobalCoordPrecision(cluster);
 
            FPGATrackSimHit cluster_as_FPGATrackSimhit = cluster.getClusterEquiv();
            cluster_as_FPGATrackSimhit.setHitType(HitType::clustered);
            cluster_as_FPGATrackSimhit.setParentageMask(cluster_count); // making use of unused m_parentageMask to keep track of cluster index
 
            if(cluster_as_FPGATrackSimhit.getDetType() == SiliconTech::pixel)
            {
              cluster_as_FPGATrackSimhit.setCluster1ID(pixelCounter);
              pixelCounter++;
            }
            else if(cluster_as_FPGATrackSimhit.getDetType() == SiliconTech::strip)
            {
              cluster_as_FPGATrackSimhit.setCluster1ID(stripCounter);
              stripCounter++;
            }
            if(m_LorentzAngleShift>= 0){
                ATH_CHECK(m_lorentzAngleTool->updateHitPosition(cluster_as_FPGATrackSimhit, m_LorentzAngleShift));
            }
            tower.addHit(cluster_as_FPGATrackSimhit);
            cluster.setClusterEquiv(cluster_as_FPGATrackSimhit);
            //send back a copy for monitoring and to check when writing out hits in each road
            clusters.push_back(cluster);
            cluster_count++;
        }
    }
    ATH_MSG_DEBUG("Produced "<< clusters.size()<< " clusters");
    return StatusCode::SUCCESS;
}

etaOrPhi()

bool FPGATrackSimClusteringTool::etaOrPhi ( const FPGATrackSimHit & hit ) const

private

Definition at line 385 of file FPGATrackSimClusteringTool.cxx.

                                                                          {
 
    /*This currently might get complicated as eta/phi ordering varies depending on the position in the detector.
     * For ITK-20-00-00 Step 2.2 inclined duals layout, worked out by Naoki.
     * Detector position               |  Module Type (# chip)  |  Column  |  Row  |
     * =============================================================================
     * Barrel Layer 0 Eta module 1-6   |  2           (double)  |  eta     |  phi  |
     * Barrel Layer 0 Eta module 7-22  |  1           (single)  |  phi     |  eta  |
     * Barrel Layer 1 Eta module 1-6   |  3           (quad)    |  eta     |  phi  |
     * Barrel Layer 1 Eta module 7-19  |  3                     |  phi     |  eta  |
     * Barrel Layer 2 Eta module 1-11  |  3                     |  eta     |  phi  |
     * Barrel Layer 2 Eta module 12-22 |  2                     |  phi     |  eta  |
     * Barrel Layer 3 Eta module 1-12  |  3                     |  eta     |  phi  |
     * Barrel Layer 3 Eta module 13-25 |  2                     |  phi     |  eta  |
     * Barrel Layer 4 Eta module 1-13  |  3                     |  eta     |  phi  |
     * Barrel Layer 4 Eta module 14-26 |  2                     |  phi     |  eta  |
     * All Endcap modules              |  3                     |  eta     |  phi  |
     * =============================================================================
     * Module Type 1 = Single, 2, Dual, 3 Quad
     * 328x400 blocks
     * Hit type is essentially isPixel
     * DetectorZone 0 = Barrel, -ive/+ive = endcaps
     */
 
    //Check if the two hits are from the same module
    //If it is not a barrel module then sort eta as column
    if(hit.getDetectorZone() != DetectorZone::barrel){
        return ETA;
    }
    //Otherwise it is a barrel module and now things get more complicated
    else {
        //Start by looking at what layer it is in
        if (hit.getPhysLayer() == 0 || hit.getPhysLayer() == 1) {
            if (hit.getEtaModule() <=6) {
                return ETA;
            } else {
                return PHI;
            }
        } else if (hit.getPhysLayer() == 2) {
            if (hit.getEtaModule() <=11) {
                return ETA;
            } else {
                return PHI;
            }
        } else if (hit.getPhysLayer() == 3) {
            if (hit.getEtaModule() <=12) {
                return ETA;
            } else {
                return PHI;
            }
        } else if (hit.getPhysLayer() == 4) {
            if (hit.getEtaModule() <=13) {
                return ETA;
            } else {
                return PHI;
            }
        }
    }
    //Default to ETA, but shouldn't reach here
    return ETA;
}

initialize()

StatusCode FPGATrackSimClusteringTool::initialize ( )

overridevirtual

Definition at line 25 of file FPGATrackSimClusteringTool.cxx.

                                                  {
    ATH_CHECK(m_lorentzAngleTool.retrieve(EnableTool{m_LorentzAngleShift >=0}));
    return StatusCode::SUCCESS;
}

normaliseClusters()

void FPGATrackSimClusteringTool::normaliseClusters ( std::vector< FPGATrackSimCluster > & clusters ) const

private

Definition at line 362 of file FPGATrackSimClusteringTool.cxx.

                                                                                                 {
    for( auto &cluster:clusters){
        //Grab the cluster equiv
        FPGATrackSimHit clusterEquiv = cluster.getClusterEquiv();
        //Update the clusterEquiv's position and width
        if(clusterEquiv.isStrip()){
            //Clear the groupsize, set this to be one as we are only clustering one row.
            clusterEquiv.setEtaWidth(1);
            clusterEquiv.setCentroidPhiIndex(clusterEquiv.getCentroidPhiIndex()/fpgatracksim::scaleHitFactor);
            clusterEquiv.setPhiWidth(clusterEquiv.getPhiWidth()+1);
        } else {
            // Nothing to normalise for pixel clusters
            continue;
        }
        cluster.setClusterEquiv(clusterEquiv);
    }
}

reduceGlobalCoordPrecision() [1/2]

void FPGATrackSimClusteringTool::reduceGlobalCoordPrecision ( FPGATrackSimCluster & cluster ) const

private

Definition at line 722 of file FPGATrackSimClusteringTool.cxx.

                                                                                              {
    FPGATrackSimHit clusterEquiv = cluster.getClusterEquiv();
    float pos[3] = { clusterEquiv.getR(), clusterEquiv.getGPhi(), clusterEquiv.getZ() };
 
    pos[0] = std::trunc(pos[0] / m_coordRPrecision) * m_coordRPrecision;
    pos[1] = std::trunc(pos[1] / m_coordPhiPrecision) * m_coordPhiPrecision;
    pos[2] = std::trunc(pos[2] / m_coordZPrecision) * m_coordZPrecision;
 
    clusterEquiv.setX(pos[0] * std::cos(pos[1]));
    clusterEquiv.setY(pos[0] * std::sin(pos[1]));
    clusterEquiv.setZ(pos[2]);
 
    cluster.setClusterEquiv(clusterEquiv);
}

reduceGlobalCoordPrecision() [2/2]

void FPGATrackSimClusteringTool::reduceGlobalCoordPrecision ( FPGATrackSimHit & hit ) const

private

Definition at line 737 of file FPGATrackSimClusteringTool.cxx.

                                                                                      {
    float pos[3] = { hit.getR(), hit.getGPhi(), hit.getZ() };
 
    pos[0] = std::trunc(pos[0] / m_coordRPrecision) * m_coordRPrecision;
    pos[1] = std::trunc(pos[1] / m_coordPhiPrecision) * m_coordPhiPrecision;
    pos[2] = std::trunc(pos[2] / m_coordZPrecision) * m_coordZPrecision;
 
    hit.setX(pos[0] * std::cos(pos[1]));
    hit.setY(pos[0] * std::sin(pos[1]));
    hit.setZ(pos[2]);
}

SetMinMaxIndicies()

void FPGATrackSimClusteringTool::SetMinMaxIndicies ( FPGATrackSimCluster & cluster ) const

private

Definition at line 99 of file FPGATrackSimClusteringTool.cxx.

                                                                                     {
    //Set the min and max indices for the cluster equivalent
    FPGATrackSimHit clusterEquiv = cluster.getClusterEquiv();
    int maxPhiIdx{-std::numeric_limits<int>::max()}, maxEtaIdx{-std::numeric_limits<int>::max()};
    int minPhiIdx{std::numeric_limits<int>::max()}, minEtaIdx{std::numeric_limits<int>::max()};
    for (const FPGATrackSimHit& hit : cluster.getHitList()){
         maxPhiIdx = std::max(maxPhiIdx, static_cast<int>(hit.getPhiIndex()));
         minPhiIdx = std::min(minPhiIdx, static_cast<int>(hit.getPhiIndex()));
         maxEtaIdx = std::max(maxEtaIdx, static_cast<int>(hit.getEtaIndex()));
         minEtaIdx = std::min(minEtaIdx, static_cast<int>(hit.getEtaIndex()));
    }
    clusterEquiv.setMinPhiIndex(minPhiIdx);
    clusterEquiv.setMaxPhiIndex(maxPhiIdx);
    clusterEquiv.setMinEtaIndex(minEtaIdx);
    clusterEquiv.setMaxEtaIndex(maxEtaIdx);
    cluster.setClusterEquiv(clusterEquiv);
}

SortedClustering()

void FPGATrackSimClusteringTool::SortedClustering ( HitPtrContainer && sorted_hits, std::vector< FPGATrackSimCluster > & clusters ) const

private

Definition at line 118 of file FPGATrackSimClusteringTool.cxx.

                                                                                                                               {
    std::vector<FPGATrackSimCluster> moduleClusters;
    //Loop over the sorted modules that we have
    for( HitPtrCollection & moduleHits: sorted_hits){
        //Make the clusters for this module
        Clustering(std::move(moduleHits), moduleClusters);
        //Put these clusters into the output list
        clusters.insert(clusters.end(), moduleClusters.begin(), moduleClusters.end());
        //Clear the vector or this will get messy
        moduleClusters.clear();
    }
}

sortHitsOnModules() [1/2]

void FPGATrackSimClusteringTool::sortHitsOnModules ( HitPtrContainer & hitsPerModule ) const

private

Definition at line 345 of file FPGATrackSimClusteringTool.cxx.

                                                                                      {
    //Loop over the module separated hits
    for ( auto& module:hitsPerModule){
        if (module.size() > 1) {
            if (module.at(0)->isStrip())
                std::stable_sort(module.begin(), module.end(), FPGATrackSimCLUSTERING::sortITkInputEta);
        }
        if (module.size() > 1) {
            if (module.at(0)->isStrip())
                std::stable_sort(module.begin(), module.end(), FPGATrackSimCLUSTERING::sortITkInputPhi);
        }
    }
}

sortHitsOnModules() [2/2]

void FPGATrackSimClusteringTool::sortHitsOnModules ( HitPtrContainer & hitsPerModule, int & eta_phi ) const

private

Definition at line 315 of file FPGATrackSimClusteringTool.cxx.

                                                                                                    {
    //Loop over the module separated hits
    for ( auto& module:hitsPerModule){
        //Work out if columns are ETA (1) || PHI (0)
        if(etaOrPhi(*module.at(0)) == true){
            //Sort by ETA first
            eta_phi = ETA;
            if (module.size() > 1) {
                if (module.at(0)->isStrip())
                    std::stable_sort(module.begin(), module.end(), FPGATrackSimCLUSTERING::sortITkInputEta);
            }
            if (module.size() > 1) {
                if (module.at(0)->isStrip())
                    std::stable_sort(module.begin(), module.end(), FPGATrackSimCLUSTERING::sortITkInputPhi);
            }
        } else {
            //Sort by PHI first
            eta_phi = PHI;
            if (module.size() > 1) {
                if (module.at(0)->isStrip())
                    std::stable_sort(module.begin(), module.end(), FPGATrackSimCLUSTERING::sortITkInputPhi);
            }
            if (module.size() > 1) {
                if (module.at(0)->isStrip())
                    std::stable_sort(module.begin(), module.end(), FPGATrackSimCLUSTERING::sortITkInputEta);
            }
        }
    }
}

sortIBLInput()

bool FPGATrackSimClusteringTool::sortIBLInput ( const std::unique_ptr< FPGATrackSimHit > & i, const std::unique_ptr< FPGATrackSimHit > & j ) const

private

sortPixelInput()

bool FPGATrackSimClusteringTool::sortPixelInput ( const std::unique_ptr< FPGATrackSimHit > & i, const std::unique_ptr< FPGATrackSimHit > & j ) const

private

splitAndSortHits() [1/2]

void FPGATrackSimClusteringTool::splitAndSortHits ( HitPtrCollection && hits, HitPtrContainer & hitsPerModule ) const

private

Definition at line 286 of file FPGATrackSimClusteringTool.cxx.

                                                                                                              {
    splitHitsToModules(std::move(hits), hitsPerModule);
    sortHitsOnModules(hitsPerModule);
}

splitAndSortHits() [2/2]

void FPGATrackSimClusteringTool::splitAndSortHits ( HitPtrCollection && hits, HitPtrContainer & hitsPerModule, int & eta_phi ) const

private

Definition at line 280 of file FPGATrackSimClusteringTool.cxx.

                                                                                                                             {
    splitHitsToModules(std::move(hits), hitsPerModule);
    sortHitsOnModules(hitsPerModule, eta_phi);
}

splitHitsToModules()

void FPGATrackSimClusteringTool::splitHitsToModules ( HitPtrCollection && hits, HitPtrContainer & hitsPerModule ) const

private

Definition at line 293 of file FPGATrackSimClusteringTool.cxx.

                                                                                                                {
    //To hold the current module
    HitPtrCollection currentModule;
    uint hashing = 0;
    //Split the incoming hits into hits by module
    for ( auto& hit:hits){
        if(hashing == 0){
            hashing = hit->getIdentifierHash();
            currentModule.push_back(std::move(hit));
        } else if (hit->getIdentifierHash() == hashing) {
            currentModule.push_back(std::move(hit));
        } else {
            hitsPerModule.push_back(std::exchange(currentModule, HitPtrCollection{}));
            hashing = hit->getIdentifierHash();
            currentModule.push_back(std::move(hit));
        }
    }
 
    // Now push that last one
    if (currentModule.size() > 0) hitsPerModule.push_back(std::move(currentModule));
}

Member Data Documentation

m_coordPhiPrecision

Gaudi::Property<float> FPGATrackSimClusteringTool::m_coordPhiPrecision {this, "CoordPhiPrecision", 1./8192., "fixed point precision of phi coordinate" }

private

Definition at line 48 of file FPGATrackSimClusteringTool.h.

{this, "CoordPhiPrecision", 1./8192., "fixed point precision of phi coordinate" };

m_coordRPrecision

Gaudi::Property<float> FPGATrackSimClusteringTool::m_coordRPrecision {this, "CoordRPrecision", 1./64., "fixed point precision of r coordinate" }

private

Definition at line 47 of file FPGATrackSimClusteringTool.h.

{this, "CoordRPrecision", 1./64., "fixed point precision of r coordinate" };

m_coordZPrecision

Gaudi::Property<float> FPGATrackSimClusteringTool::m_coordZPrecision {this, "CoordZPrecision", 1./32., "fixed point precision of z coordinate" }

private

Definition at line 49 of file FPGATrackSimClusteringTool.h.

{this, "CoordZPrecision", 1./32., "fixed point precision of z coordinate" };

m_digitalClustering

Gaudi::Property<bool> FPGATrackSimClusteringTool::m_digitalClustering {this, "DigitalClustering", true, "flag to enable digital clustering instead of ToT weighted position calculation" }

private

Definition at line 45 of file FPGATrackSimClusteringTool.h.

{this, "DigitalClustering", true, "flag to enable digital clustering instead of ToT weighted position calculation" };

m_LorentzAngleShift

Gaudi::Property<int> FPGATrackSimClusteringTool::m_LorentzAngleShift { this, "LorentzAngleShift", -1, "flag for Lorentz angle shift. -1 means off, 0 means full corrections from first version, 1 means smaller LUT, 2 means very small LUT" }

private

Definition at line 50 of file FPGATrackSimClusteringTool.h.

{ this, "LorentzAngleShift", -1, "flag for Lorentz angle shift. -1 means off, 0 means full corrections from first version, 1 means smaller LUT, 2 means very small LUT" };

m_lorentzAngleTool

ToolHandle<FPGATrackSim::LorentzAngleTool> FPGATrackSimClusteringTool::m_lorentzAngleTool {this, "LorentzAngleTool", "", "FPGATrackSim tool to retrieve Lorentz angle"}

private

Definition at line 52 of file FPGATrackSimClusteringTool.h.

{this, "LorentzAngleTool", "", "FPGATrackSim tool to retrieve Lorentz angle"};

m_reduceCoordPrecision

Gaudi::Property<bool> FPGATrackSimClusteringTool::m_reduceCoordPrecision {this, "ReduceCoordPrecision", false, "flag to enable reducing the precision of global coordinates" }

private

Definition at line 46 of file FPGATrackSimClusteringTool.h.

{this, "ReduceCoordPrecision", false, "flag to enable reducing the precision of global coordinates" };

---

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

• FPGATrackSimClusteringTool.h
• FPGATrackSimClusteringTool.cxx