FPGATrackSimCLUSTERING Namespace Reference

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

Function Documentation

attachTruth()

void FPGATrackSimCLUSTERING::attachTruth

(

std::vector< FPGATrackSimHit > &

hits

)

Definition at line 256 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 FPGATrackSimHit &	hitA,
		const FPGATrackSimHit &	hitB
	)

Definition at line 446 of file FPGATrackSimClusteringTool.cxx.

{
  return hitA.getEtaIndex() < hitB.getEtaIndex();
}

sortITkInputPhi()

bool FPGATrackSimCLUSTERING::sortITkInputPhi	(	const FPGATrackSimHit &	hitA,
		const FPGATrackSimHit &	HitB
	)

Definition at line 453 of file FPGATrackSimClusteringTool.cxx.

{
  return hitA.getPhiIndex() < hitB.getPhiIndex();
}

updateClusterContents()

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

Definition at line 403 of file FPGATrackSimClusteringTool.cxx.

                                                                                                                                                                                                  {
  //Grab the cluster equiv
  FPGATrackSimHit clusterEquiv = currentCluster.getClusterEquiv();
 
  //Update the clusterEquiv's position and width
  clusterEquiv.setEtaIndex(clusterRow);
  clusterEquiv.setEtaWidth(clusterRowWidth);
  clusterEquiv.setPhiIndex(clusterCol);
  clusterEquiv.setPhiWidth(clusterColWidth);
 
 
  float xOld = clusterEquiv.getX();
  float yOld = clusterEquiv.getY();
  float zOld = clusterEquiv.getZ();
  float xNew = incomingHit.getX();
  float yNew = incomingHit.getY();
  float zNew = incomingHit.getZ();
  //As strips arrive pre-clustered, this is different for pixels/strips
  if(incomingHit.isPixel()){
    int n = currentCluster.getHitList().size();
    // n+1 because that is old + new now
    clusterEquiv.setX((xOld*n + xNew) / (n+1));
    clusterEquiv.setY((yOld*n + yNew) / (n+1));
    clusterEquiv.setZ((zOld*n + zNew) / (n+1));
  } 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.setX((xOld*N + xNew*newN) / (N+newN));
    clusterEquiv.setY((yOld*N + yNew*newN) / (N+newN));
    clusterEquiv.setZ((zOld*N + zNew*newN) / (N+newN));
  }
  //Put it back
  currentCluster.setClusterEquiv(clusterEquiv);
 
  //Pushback the hit into the hitlist
  currentCluster.push_backHitList(incomingHit);
}

updatePixelCluster()

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

Definition at line 275 of file FPGATrackSimClusteringTool.cxx.

                                                                                                                                 {
 
  if(newCluster){
    FPGATrackSimHit newHit = incomingHit;
    //Double the precision on the positions
    //By doing this the hardware is able to handle clusters where the centre of the cluster is on a boundary between two clusters without needing a float
    newHit.setEtaIndex(incomingHit.getEtaIndex()*fpgatracksim::scaleHitFactor);
    newHit.setPhiIndex(incomingHit.getPhiIndex()*fpgatracksim::scaleHitFactor);
    //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 hitRow = incomingHit.getEtaIndex();
    int hitCol = incomingHit.getPhiIndex();
 
    FPGATrackSimHit clusterEquiv = currentCluster.getClusterEquiv();
    int clusterRow = clusterEquiv.getEtaIndex();
    int clusterRowWidth = clusterEquiv.getEtaWidth();
    int clusterCol = clusterEquiv.getPhiIndex();
    int clusterColWidth = clusterEquiv.getPhiWidth();
 
    //Looking for a neighbour in up/right position to the currentCluster
    if((hitRow*fpgatracksim::scaleHitFactor == clusterRow+clusterRowWidth+fpgatracksim::scaleHitFactor) &&
       (hitCol*fpgatracksim::scaleHitFactor == clusterCol+clusterColWidth+fpgatracksim::scaleHitFactor) ){
      clusterRow++;
      clusterRowWidth++;
      clusterCol++;
      clusterColWidth++;
      FPGATrackSimCLUSTERING::updateClusterContents(currentCluster, clusterRow, clusterRowWidth, clusterCol, clusterColWidth, incomingHit);
      return true;
    }
 
    //Looking for a neighbour in down right
    else if((hitRow*fpgatracksim::scaleHitFactor == clusterRow-clusterRowWidth-fpgatracksim::scaleHitFactor) && //because row then col sorted data, i.e. col sorted.
        (hitCol*fpgatracksim::scaleHitFactor == clusterCol+clusterColWidth+fpgatracksim::scaleHitFactor) ){
      clusterRow--; // important
      clusterRowWidth++;
      clusterCol++;
      clusterColWidth++;
      FPGATrackSimCLUSTERING::updateClusterContents(currentCluster, clusterRow, clusterRowWidth, clusterCol, clusterColWidth, incomingHit);
      return true;
    }
 
    //Looking for a neighbour above
    else if((hitRow*fpgatracksim::scaleHitFactor == clusterRow+clusterRowWidth+fpgatracksim::scaleHitFactor) &&
        (hitCol*fpgatracksim::scaleHitFactor == clusterCol+clusterColWidth) ){
      clusterRow++;
      clusterRowWidth++;
      FPGATrackSimCLUSTERING::updateClusterContents(currentCluster, clusterRow, clusterRowWidth, clusterCol, clusterColWidth, incomingHit);
      return true;
    }
 
    //Looking for a neighbour to the right
    else if(((hitRow*fpgatracksim::scaleHitFactor >  clusterRow-clusterRowWidth-fpgatracksim::scaleHitFactor) && (hitRow*fpgatracksim::scaleHitFactor <  clusterRow+clusterRowWidth+fpgatracksim::scaleHitFactor)) &&
        (hitCol*fpgatracksim::scaleHitFactor == clusterCol+clusterColWidth+fpgatracksim::scaleHitFactor) ){
      clusterCol++;
      clusterColWidth++;
      FPGATrackSimCLUSTERING::updateClusterContents(currentCluster, clusterRow, clusterRowWidth, clusterCol, clusterColWidth, incomingHit);
      return true;
    }
 
    //Checking for hits inside the box
    else if((hitRow*fpgatracksim::scaleHitFactor > clusterRow-clusterRowWidth-fpgatracksim::scaleHitFactor) &&
        (hitRow*fpgatracksim::scaleHitFactor < clusterRow+clusterRowWidth+fpgatracksim::scaleHitFactor) &&
        (hitCol*fpgatracksim::scaleHitFactor < clusterCol+clusterColWidth+fpgatracksim::scaleHitFactor) ){
      //We still want to do this as we are not changing the position of the cluster, but we are adding to its hitlist
      FPGATrackSimCLUSTERING::updateClusterContents(currentCluster, clusterRow, clusterRowWidth, clusterCol, clusterColWidth, incomingHit);
      return true;
    }
    //if we made it here then this cluster then start again
    else return false;
  }
}

updateStripCluster()

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

Definition at line 356 of file FPGATrackSimClusteringTool.cxx.

                                                                                                                                 {
 
  // Shift initial widths 1->0, 2->2, 3->4, 4->6 etc...
  //The groupSize is stored in the EtaWidth
  int tempWidth = (incomingHit.getEtaWidth()*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.getPhiCoord()*fpgatracksim::scaleHitFactor;
    // Now shift the centroid phi+phiWidth, and store the width (put it back in the PhiWidth)
    newHit.setPhiCoord(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.getEtaCoord();
    int hitCol = incomingHit.getPhiCoord()*fpgatracksim::scaleHitFactor;
 
    FPGATrackSimHit clusterEquiv = currentCluster.getClusterEquiv();
    int clusterRow = clusterEquiv.getEtaCoord();
    int clusterRowWidth = clusterEquiv.getEtaWidth();
    int clusterCol = clusterEquiv.getPhiCoord();
    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);
      return true;
    } else return false;
  }
}