FPGATrackSimCLUSTERING Namespace Reference

Functions
void	attachTruth (std::vector< FPGATrackSimHit > &)
bool	updatePixelCluster (FPGATrackSimCluster &currentCluster, FPGATrackSimHit &incomingHit, bool newCluster, bool digitalClustering)
bool	updateStripCluster (FPGATrackSimCluster &currentCluster, FPGATrackSimHit &incomingHit, bool newCluster, bool digitalClustering)
bool	updateClusterContents (FPGATrackSimCluster &currentCluster, int &clusterRow, int &clusterRowWidth, int &clusterCol, int &clusterColWidth, FPGATrackSimHit &incomingHit, bool digitalClustering)
bool	sortITkInputEta (const std::unique_ptr< FPGATrackSimHit > &hitA, const std::unique_ptr< FPGATrackSimHit > &hitB)
bool	sortITkInputPhi (const std::unique_ptr< FPGATrackSimHit > &hitA, const std::unique_ptr< FPGATrackSimHit > &HitB)

Function Documentation

attachTruth()

void FPGATrackSimCLUSTERING::attachTruth

(

std::vector< FPGATrackSimHit > &

hits

)

Definition at line 449 of file FPGATrackSimClusteringTool.cxx.

                                                                        {
    for( auto& hit : hits) {
        FPGATrackSimMultiTruth mt;
        // record highest pt contribution to the combination (cluster
        if(!hit.getTruth().isEmpty()) {
            mt.add(hit.getTruth());
            hit.setTruth(mt);
        } else {
            FPGATrackSimMultiTruth::Barcode uniquecode(hit.getEventIndex(), hit.getBarcode());
            mt.maximize(uniquecode, hit.getBarcodePt());
            hit.setTruth(mt);
        }
    }
} //record truth for each raw channel in the cluster

sortITkInputEta()

bool FPGATrackSimCLUSTERING::sortITkInputEta	(	const std::unique_ptr< FPGATrackSimHit > &	hitA,
		const std::unique_ptr< FPGATrackSimHit > &	hitB )

Definition at line 705 of file FPGATrackSimClusteringTool.cxx.

{
    if (hitA->getIdentifierHash() != hitB->getIdentifierHash())
        return hitA->getIdentifierHash() < hitB->getIdentifierHash();
    return hitA->getEtaIndex() < hitB->getEtaIndex();
}

sortITkInputPhi()

bool FPGATrackSimCLUSTERING::sortITkInputPhi	(	const std::unique_ptr< FPGATrackSimHit > &	hitA,
		const std::unique_ptr< FPGATrackSimHit > &	HitB )

Definition at line 714 of file FPGATrackSimClusteringTool.cxx.

{
    if (hitA->getIdentifierHash() != hitB->getIdentifierHash())
        return hitA->getIdentifierHash() < hitB->getIdentifierHash();
    return hitA->getPhiIndex() < hitB->getPhiIndex();
}

updateClusterContents()

bool FPGATrackSimCLUSTERING::updateClusterContents	(	FPGATrackSimCluster &	currentCluster,
		int &	clusterRow,
		int &	clusterRowWidth,
		int &	clusterCol,
		int &	clusterColWidth,
		FPGATrackSimHit &	incomingHit,
		bool	digitalClustering )

Definition at line 600 of file FPGATrackSimClusteringTool.cxx.

                                                                                                                                                                                                                          {
    //Grab the cluster equiv
    FPGATrackSimHit clusterEquiv = currentCluster.getClusterEquiv();
    bool isConnected = false;
 
    //Check if connected to another hit in the cluster
    if(incomingHit.isPixel()){
        for (auto & hit : currentCluster.getHitList()) {
            auto hitEta = hit.getEtaIndex();
            auto hitPhi = hit.getPhiIndex();
            auto inHitEta = incomingHit.getEtaIndex();
            auto inHitPhi = incomingHit.getPhiIndex();
 
            if (((inHitEta == hitEta - 1) && (inHitPhi == hitPhi - 1)) ||
                    ((inHitEta == hitEta + 1) && (inHitPhi == hitPhi - 1)) ||
                    ((inHitEta == hitEta - 1) && (inHitPhi == hitPhi + 1)) ||
                    ((inHitEta == hitEta + 1) && (inHitPhi == hitPhi + 1)) ||
                    ((inHitEta == hitEta) && (inHitPhi == hitPhi - 1)) ||
                    ((inHitEta == hitEta) && (inHitPhi == hitPhi + 1)) ||
                    ((inHitEta == hitEta - 1) && (inHitPhi == hitPhi)) ||
                    ((inHitEta == hitEta + 1) && (inHitPhi == hitPhi))) {
                isConnected = true;
                break;
            }
        }
        if (!isConnected)
            return false;
    }
 
    //Update the clusterEquiv's position and width
    if (incomingHit.isPixel()) {
        clusterEquiv.setEtaIndex(clusterCol);
        clusterEquiv.setEtaWidth(clusterColWidth);
        clusterEquiv.setPhiIndex(clusterRow);
        clusterEquiv.setPhiWidth(clusterRowWidth);
    } else {
        clusterEquiv.setEtaIndex(clusterRow);
        clusterEquiv.setEtaWidth(clusterRowWidth);
        clusterEquiv.setCentroidPhiIndex(clusterCol);
        clusterEquiv.setPhiWidth(clusterColWidth);
    }
 
 
    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 = incomingHit.getX();
    float yNew = incomingHit.getY();
    float zNew = incomingHit.getZ();
    float xPhiNew = incomingHit.getPhiCoord();
    float xEtaNew = incomingHit.getEtaCoord();
    float cPhiNew = incomingHit.getPhiIndex();
    float cEtaNew = incomingHit.getEtaIndex();
    int tot = clusterEquiv.getToT();
    int totNew = incomingHit.getToT();
    //As strips arrive pre-clustered, this is different for pixels/strips
    if(incomingHit.isPixel()){
        CXXUTILS_TRAPPING_FP;
        if (digitalClustering) {
            // n+1 because that is old + new now
            int n = currentCluster.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));
        }
    } else {
        //Phi width + 1 for the seed is the width of the current cluster
        int N = currentCluster.getClusterEquiv().getPhiWidth()+1;
        //Phi width of an incoming strip is the width of the cluster
        int newN = incomingHit.getPhiWidth();
        //Now as above, N+newN
        clusterEquiv.setPhiCoord((xPhiOld*N + xPhiNew*newN) / (N+newN));
        clusterEquiv.setX((xOld*N + xNew*newN) / (N+newN));
        clusterEquiv.setY((yOld*N + yNew*newN) / (N+newN));
        clusterEquiv.setZ((zOld*N + zNew*newN) / (N+newN));
    }
    clusterEquiv.setToT(tot + totNew);
 
    //Put it back
    currentCluster.setClusterEquiv(clusterEquiv);
 
    //Pushback the hit into the hitlist
    currentCluster.push_backHitList(incomingHit);
 
    return true;
}

updatePixelCluster()

bool FPGATrackSimCLUSTERING::updatePixelCluster	(	FPGATrackSimCluster &	currentCluster,
		FPGATrackSimHit &	incomingHit,
		bool	newCluster,
		bool	digitalClustering )

Definition at line 468 of file FPGATrackSimClusteringTool.cxx.

                                                                                                                                                         {
 
    if(newCluster){
        FPGATrackSimHit newHit = incomingHit;
        newHit.setEtaIndex(incomingHit.getEtaIndex());
        newHit.setPhiIndex(incomingHit.getPhiIndex());
        newHit.setEtaCoord(incomingHit.getEtaCoord());
        newHit.setPhiCoord(incomingHit.getPhiCoord());
        newHit.setCentroidPhiIndex(incomingHit.getPhiIndex());
        newHit.setCentroidEtaIndex(incomingHit.getEtaIndex());
        newHit.setEtaWidth(1);
        newHit.setPhiWidth(1);
        //Set the initial clusterEquiv to be the incoming hit with double precision
        currentCluster.setClusterEquiv(newHit);
        //Add the current hit to the list of hits
        currentCluster.push_backHitList(incomingHit);
        //It doesn't really matter, as we will be at the end of the hit loop, but we did technically "cluster" this hit
        return true;
    } else {
        int hitCol = incomingHit.getEtaIndex();
        int hitRow = incomingHit.getPhiIndex();
 
        FPGATrackSimHit clusterEquiv = currentCluster.getClusterEquiv();
        int clusterCol = clusterEquiv.getEtaIndex();
        int clusterColWidth = clusterEquiv.getEtaWidth();
        int clusterRow = clusterEquiv.getPhiIndex();
        int clusterRowWidth = clusterEquiv.getPhiWidth();
 
        if ((hitCol == clusterCol + clusterColWidth) && (hitRow == clusterRow + clusterRowWidth)) {
            clusterColWidth++;
            clusterRowWidth++;
 
            return FPGATrackSimCLUSTERING::updateClusterContents(currentCluster, clusterRow, clusterRowWidth, clusterCol, clusterColWidth, incomingHit, digitalClustering);
        } else if ((hitCol == clusterCol + clusterColWidth) && (hitRow == clusterRow - 1)) {
            clusterColWidth++;
            clusterRow--;
            clusterRowWidth++;
 
            return FPGATrackSimCLUSTERING::updateClusterContents(currentCluster, clusterRow, clusterRowWidth, clusterCol, clusterColWidth, incomingHit, digitalClustering);
        } else if ((hitCol >= clusterCol) && (hitCol < clusterCol + clusterColWidth) && (hitRow == clusterRow + clusterRowWidth)) {
            clusterRowWidth++;
 
            return FPGATrackSimCLUSTERING::updateClusterContents(currentCluster, clusterRow, clusterRowWidth, clusterCol, clusterColWidth, incomingHit, digitalClustering);
        } else if ((hitCol == clusterCol + clusterColWidth) && (hitRow >= clusterRow) && (hitRow < clusterRow + clusterRowWidth)) {
            clusterColWidth++;
 
            return FPGATrackSimCLUSTERING::updateClusterContents(currentCluster, clusterRow, clusterRowWidth, clusterCol, clusterColWidth, incomingHit, digitalClustering);
        } else if ((hitCol >= clusterCol) && (hitCol < clusterCol + clusterColWidth) && (hitRow == clusterRow - 1)) {
            clusterRow--;
            clusterRowWidth++;
 
            return FPGATrackSimCLUSTERING::updateClusterContents(currentCluster, clusterRow, clusterRowWidth, clusterCol, clusterColWidth, incomingHit, digitalClustering);
        } else if ((hitCol == clusterCol - 1) && (hitRow == clusterRow - 1)) {
            clusterCol--;
            clusterColWidth++;
            clusterRow--;
            clusterRowWidth++;
 
            return FPGATrackSimCLUSTERING::updateClusterContents(currentCluster, clusterRow, clusterRowWidth, clusterCol, clusterColWidth, incomingHit, digitalClustering);
        } else if ((hitCol == clusterCol - 1) && (hitRow >= clusterRow) && (hitRow < clusterRow + clusterRowWidth)) {
            clusterCol--;
            clusterColWidth++;
 
            return FPGATrackSimCLUSTERING::updateClusterContents(currentCluster, clusterRow, clusterRowWidth, clusterCol, clusterColWidth, incomingHit, digitalClustering);
        } else if ((hitCol == clusterCol - 1) && (hitRow == clusterRow + clusterRowWidth)) {
            clusterCol--;
            clusterColWidth++;
            clusterRowWidth++;
 
            return FPGATrackSimCLUSTERING::updateClusterContents(currentCluster, clusterRow, clusterRowWidth, clusterCol, clusterColWidth, incomingHit, digitalClustering);
        } else if ((hitCol >= clusterCol) && (hitCol < clusterCol + clusterColWidth) && (hitRow >= clusterRow) && (hitRow < clusterRow + clusterRowWidth)) {
            return FPGATrackSimCLUSTERING::updateClusterContents(currentCluster, clusterRow, clusterRowWidth, clusterCol, clusterColWidth, incomingHit, digitalClustering);
        } else {
            return false;
        }
    }
}

updateStripCluster()

bool FPGATrackSimCLUSTERING::updateStripCluster	(	FPGATrackSimCluster &	currentCluster,
		FPGATrackSimHit &	incomingHit,
		bool	newCluster,
		bool	digitalClustering )

Definition at line 550 of file FPGATrackSimClusteringTool.cxx.

                                                                                                                                                         {
 
    CXXUTILS_TRAPPING_FP;
 
    // Shift initial widths 1->0, 2->2, 3->4, 4->6 etc...
    //The groupSize is stored in the EtaWidth
    int tempWidth = (incomingHit.getPhiWidth()*fpgatracksim::scaleHitFactor)-fpgatracksim::scaleHitFactor;
    // Now shift to pixel width equivalents, 0->0, 2->1, 4->2, 6->3 etc...
    if(tempWidth > 0) tempWidth = tempWidth/fpgatracksim::scaleHitFactor;
    if(newCluster){
        FPGATrackSimHit newHit = incomingHit;
        //Double the precision of the strip positions.
        int tempCentroid = incomingHit.getPhiIndex()*fpgatracksim::scaleHitFactor;
        // Now shift the centroid phi+phiWidth, and store the width (put it back in the PhiWidth)
        newHit.setPhiIndex(incomingHit.getPhiIndex());
        newHit.setCentroidPhiIndex(tempCentroid+tempWidth);
        newHit.setPhiWidth(tempWidth);
        //Set the initial clusterEquiv to be the incoming hit with double precision
        currentCluster.setClusterEquiv(newHit);
        //Add the current hit to the list of hits
        currentCluster.push_backHitList(incomingHit);
        //It doesn't really matter, as we will be at the end of the hit loop, but we did technically "cluster" this hit
        return true;
    } else {
        //Now get the --START-- of the new strip cluster
        int hitRow = incomingHit.getEtaIndex();
        int hitCol = incomingHit.getPhiIndex()*fpgatracksim::scaleHitFactor;
 
        FPGATrackSimHit clusterEquiv = currentCluster.getClusterEquiv();
        int clusterRow = clusterEquiv.getEtaIndex();
        int clusterRowWidth = clusterEquiv.getEtaWidth();
        int clusterCol = clusterEquiv.getCentroidPhiIndex();
        int clusterColWidth = clusterEquiv.getPhiWidth();
 
        //Looking for a neighbour to the right. i.e. find the end of the current cluster (Col+width) and look in the next cell (+2). Compare this to the start of the new cluster. This is unlikely/impossible(?) to happen due to preclustering.
        if(hitCol == clusterCol+clusterColWidth+fpgatracksim::scaleHitFactor && hitRow == clusterRow) {
            //The new centroid will be the original column position, minus its width, plus the new width
            //So subtract the original width...
            clusterCol = clusterCol - clusterColWidth;
            //The new width will be the combination of the current widths, ++
            clusterColWidth = clusterColWidth+tempWidth+1;
            //And add on the new width
            clusterCol = clusterCol + clusterColWidth;
            FPGATrackSimCLUSTERING::updateClusterContents(currentCluster, clusterRow, clusterRowWidth, clusterCol, clusterColWidth, incomingHit, digitalClustering);
            return true;
        } else return false;
    }
}