FPGATrackSimFunctions.h File Reference

#include <TString.h>
#include <TObjArray.h>
#include <TH1.h>
#include <TObjString.h>
#include <TTreeReader.h>
#include <TTreeReaderValue.h>
#include "FPGATrackSimObjects/FPGATrackSimTypes.h"
#include "FPGATrackSimObjects/FPGATrackSimHit.h"
#include <cmath>
#include <vector>
#include <sstream>

Go to the source code of this file.

Functions
std::vector< uint32_t >	splitSetBits32 (uint32_t x)
int	firstSetBit32 (uint32_t x)
unsigned	divUp (unsigned x, unsigned y)
uint32_t	binaryToGray (uint32_t num)
uint32_t	grayToBinary32 (uint32_t num)
std::vector< std::vector< int > >	getComboIndices (std::vector< size_t > const &sizes)
	Given a vector of sizes (of arrays), generates a vector of all combinations of indices to index one element from each array. More...
double	rms95 (TH1 const *h)
	This function is used to calculate RMS95 value for 1D histograms. More...
double	fieldCorrection (unsigned region, double qpt, double r)
std::vector< float >	computeIdealCoords (const FPGATrackSimHit &hit, const double hough_x, const double hough_y, const double target_r, const bool doDeltaGPhis, const TrackCorrType trackCorrType)

Function Documentation

binaryToGray()

uint32_t binaryToGray ( uint32_t  num )

inline

Definition at line 80 of file FPGATrackSimFunctions.h.

{
    return num ^ (num >> 1);
}

computeIdealCoords()

std::vector<float> computeIdealCoords	(	const FPGATrackSimHit &	hit,
		const double	hough_x,
		const double	hough_y,
		const double	target_r,
		const bool	doDeltaGPhis,
		const TrackCorrType	trackCorrType
	)

Definition at line 116 of file FPGATrackSimFunctions.cxx.

                                                                                                                                                                                               {
  
  std::vector<float> idealized_coordinates;
 
  float hitGPhi = (float) hit.getGPhi();
  float hitZ = (float) hit.getZ();
 
  // rho = 0.33 m * (pT / GeV) / (B/T)
  // B = 2 T so
  // rho = 0.33 m * (pT / GeV) / (2)
  double houghRho = 0.0003 * hough_y; //A*q/pT
 
  hitGPhi += (hit.getR() - target_r) * houghRho; //first order
  
  if (trackCorrType == TrackCorrType::Second) {
    hitGPhi += (pow(hit.getR() * houghRho, 3.0) / 6.0); //higher order
  }
 
  if (hit.getR() > 1e-8) {
    hitZ -= hit.getGCotTheta() * (hit.getR() - target_r); //first order
    if (trackCorrType == TrackCorrType::Second)
      hitZ -= (hit.getGCotTheta() * std::pow(hit.getR(), 3.0) * houghRho * houghRho) / 6.0; //higher order
  }
  
  idealized_coordinates.push_back(hitZ);
 
  if (doDeltaGPhis) {
    double expectedGPhi = hough_x;
 
    expectedGPhi -= target_r * houghRho; //first order
 
    if (trackCorrType == TrackCorrType::Second) {
      expectedGPhi -= (std::pow(target_r * houghRho, 3.0) / 6.0); //higher order
    }
 
    idealized_coordinates.push_back(hitGPhi - expectedGPhi);
  }
  else {
    idealized_coordinates.push_back(hitGPhi);
  }
 
 
  return idealized_coordinates;
 
}

divUp()

unsigned divUp ( unsigned  x, unsigned  y  )

inline

Definition at line 72 of file FPGATrackSimFunctions.h.

{
    // return (x + y - 1) / y; runs risk of overflow
    return 1 + ((x - 1) / y);
}

fieldCorrection()

double fieldCorrection	(	unsigned	region,
		double	qpt,
		double	r
	)

Definition at line 163 of file FPGATrackSimFunctions.cxx.

{
  r = r / 1000; // convert to meters
  if (region == 3)
    {
      double cor = 0.1216 * r * r - 0.0533 * r + 0.0069;
      return -cor * qpt;
    }
  else if (region == 4)
    {
      double cor = 0.4265 * r * r - 0.0662 * r + 0.0036;
      return -cor * qpt;
    }
  else return 0;
}

firstSetBit32()

int firstSetBit32 ( uint32_t  x )

inline

Definition at line 58 of file FPGATrackSimFunctions.h.

{
    unsigned bit = 0;
    while (x)
    {
        if (x & 1) return bit;
        x >>= 1;
        bit++;
    }
    return -1;
}

getComboIndices()

std::vector<std::vector<int> > getComboIndices

(

std::vector< size_t > const &

sizes

)

Given a vector of sizes (of arrays), generates a vector of all combinations of indices to index one element from each array.

For example, given [2 3], generates [(0 0) (1 0) (0 1) (1 1) (0 2) (1 2)].

Given a vector of sizes (of arrays), generates a vector of all combinations of indices to index one element from each array.

For example, given [2 3], generates [(0 0) (1 0) (0 1) (1 1) (0 2) (1 2)].

This basically amounts to a positional number system of where each digit has its own base. The number of digits is sizes.size(), and the base of digit i is sizes[i]. Then all combinations can be uniquely represented just by counting from [0, nCombs).

For a decimal number like 1357, you get the thousands digit with n / 1000 = n / (10 * 10 * 10). So here, you get the 0th digit with n / (base_1 * base_2 * base_3);

Definition at line 21 of file FPGATrackSimFunctions.cxx.

{
    size_t nCombs = 1;
    std::vector<size_t> nCombs_prior(sizes.size());
    std::vector<int> temp(sizes.size(), 0);
 
    for (size_t i = 0; i < sizes.size(); i++)
    {
        if (sizes[i] > 0)
        {
            nCombs_prior[i] = nCombs;
            nCombs *= sizes[i];
        }
        else temp[i] = -1;
    }
 
    std::vector<std::vector<int>> combos(nCombs, temp);
 
    for (size_t icomb = 0; icomb < nCombs; icomb++)
    {
        size_t index = icomb;
        for (size_t isize = sizes.size() - 1; isize < sizes.size(); isize--)
        {
            if (sizes[isize] == 0) continue;
            combos[icomb][isize] = static_cast<int>(index / nCombs_prior[isize]);
            index = index % nCombs_prior[isize];
        }
    }
 
    return combos;
}

grayToBinary32()

uint32_t grayToBinary32 ( uint32_t  num )

inline

Definition at line 86 of file FPGATrackSimFunctions.h.

{
    num = num ^ (num >> 16);
    num = num ^ (num >> 8);
    num = num ^ (num >> 4);
    num = num ^ (num >> 2);
    num = num ^ (num >> 1);
    return num;
}

rms95()

double rms95

(

TH1 const *

h

)

This function is used to calculate RMS95 value for 1D histograms.

It was ported from https://gitlab.cern.ch:8443/fpastore/l1tracksim/-/blob/master/PatRec/macros/FraMacros/Functions.cxx#L253 See more details there.

Definition at line 60 of file FPGATrackSimFunctions.cxx.

{
    double const frac = 0.95;
    double entries = h->Integral(0, h->GetNbinsX() + 1);
 
    // Not enough entries for this fraction, i.e. we want 0.95 then need 5% to be 1 events, so need at least 20 events.
    if ((1.0 - frac) * entries < 1 || entries == 0) return h->GetRMS();
 
    TH1* h_tmp = dynamic_cast<TH1*>(h->Clone());
    if (not h_tmp){
      throw "dynamic_cast failure in FPGATrackSimFunctions rms95(TH1*)";
    }
    h_tmp->GetXaxis()->SetRange(1, h_tmp->GetNbinsX());
 
    int meanbin  = h->GetXaxis()->FindBin(h_tmp->GetMean());
    int lowerbin = meanbin;
    int upperbin = meanbin;
 
    double sum = h->GetBinContent(meanbin);
    double lowerfrac = 0;
    double upperfrac = 0;
 
    int i = 1;
    while (true) {
        int this_lowerbin = meanbin - i;
        int this_upperbin = meanbin + i;
        if (this_lowerbin < 1 || this_upperbin > h->GetNbinsX()) break;
 
        sum += h_tmp->GetBinContent(this_lowerbin) + h_tmp->GetBinContent(this_upperbin);
        if (sum >= entries * frac) break;
 
        lowerfrac = sum / entries;
        lowerbin = this_lowerbin;
        upperbin = this_upperbin;
 
        i++;
    }
    upperfrac = sum / entries;
 
    if (upperfrac == lowerfrac) return h->GetRMS();
 
    double rms_lower = 0;
    double rms_upper = 0;
 
    h_tmp->GetXaxis()->SetRange(lowerbin, upperbin);
    rms_lower = h_tmp->GetRMS();
 
    h_tmp->GetXaxis()->SetRange(lowerbin - 1, upperbin + 1);
    rms_upper = h_tmp->GetRMS();
 
    double rms = rms_lower + (frac - lowerfrac) * (rms_upper - rms_lower) / (upperfrac - lowerfrac);
 
    return rms * 1.1479538518;
}

splitSetBits32()

std::vector<uint32_t> splitSetBits32 ( uint32_t  x )

inline

Definition at line 42 of file FPGATrackSimFunctions.h.

{
    std::vector<uint32_t> out;
    uint32_t setbit = 0x1;
    while (setbit != 0 && x != 0)
    {
        if (x & 1) out.push_back(setbit);
        x = x >> 1;
        setbit = setbit << 1;
    }
    return out;
}