PixelDigitization Namespace Reference

Functions
std::string	formBichselDataFileName (int particleType, unsigned int nCols)
BichselData	getBichselDataFromFile (const std::string &fullFilename)
std::tuple< double, double, double >	parseThreeDoubles (const std::string &line)
std::pair< int, int >	fastSearch (const std::vector< double > &vec, double item)
double	randomThreshold (const PixelChargeCalib::Thresholds &t, CLHEP::HepRandomEngine *pEngine)
void	crossTalk (double crossTalk, SiChargedDiodeCollection &chargedDiodes)
void	thermalNoise (double thermalNoise, SiChargedDiodeCollection &chargedDiodes, CLHEP::HepRandomEngine *rndmEngine)
void	randomNoise (SiChargedDiodeCollection &chargedDiodes, const PixelModuleData *moduleData, int nBcid, const PixelChargeCalibCondData *chargeCalibData, CLHEP::HepRandomEngine *rndmEngine, InDetDD::IPixelReadoutManager *pixelReadout)
void	randomNoise (SiChargedDiodeCollection &chargedDiodes, const ITkPixSimulationParameters &chipData, int nBcid, const PixelChargeCalibCondData *chargeCalibData, CLHEP::HepRandomEngine *rndmEngine, InDetDD::IPixelReadoutManager *pixelReadout)
void	randomNoise (SiChargedDiodeCollection &chargedDiodes, const double totalNoiseOccupancy, const std::vector< float > &noiseShape, float overflowToT, const PixelChargeCalibCondData *chargeCalibData, CLHEP::HepRandomEngine *rndmEngine, InDetDD::IPixelReadoutManager *pixelReadout)
void	randomDisable (SiChargedDiodeCollection &chargedDiodes, const PixelModuleData *moduleData, CLHEP::HepRandomEngine *rndmEngine)
void	randomDisable (SiChargedDiodeCollection &chargedDiodes, const ITkPixSimulationParameters &chipData, CLHEP::HepRandomEngine *rndmEngine)
void	randomDisable (SiChargedDiodeCollection &chargedDiodes, double disableProbability, CLHEP::HepRandomEngine *rndmEngine)
int	generateToT (CLHEP::HepRandomEngine *rndmEngine, double mean, double sd, const std::pair< int, int > &range)
double	getG4Time (const SiTotalCharge &totalCharge)

Function Documentation

crossTalk()

void PixelDigitization::crossTalk	(	double	crossTalk,
		SiChargedDiodeCollection &	chargedDiodes )

Definition at line 28 of file PixelNoiseFunctions.cxx.

                                                                      {
    const InDetDD::PixelModuleDesign* p_design =
      static_cast<const InDetDD::PixelModuleDesign*>(&(chargedDiodes.element())->design());
    SiChargedDiodeMap oldChargedDiodes = chargedDiodes.chargedDiodes();
 
    for (SiChargedDiodeIterator i_chargedDiode = oldChargedDiodes.begin(); i_chargedDiode != oldChargedDiodes.end();
         ++i_chargedDiode) {
      InDetDD::SiCellId diode = (*i_chargedDiode).second.diode();
      std::vector<InDetDD::SiCellId> neighbours;
      p_design->neighboursOfCell(diode, neighbours);
      for (std::vector<InDetDD::SiCellId>::const_iterator p_neighbour = neighbours.begin();
           p_neighbour != neighbours.end(); ++p_neighbour) {
        const double intersection = p_design->intersectionLength(diode, *p_neighbour);
        // add cross talk only if the intersection is non-zero
        // if the original pixel is at (col,row) then the intersection length is
        // (col+-1, row+-1) : 0 -> diagonal
        // (col   , row+-1) : 0.4 mm (or 0.6 if long pixel) pixel width  = 400um or 600um
        // (col+-1, row   ) : 0.05 mm , pixel height = 50um
        // intersection length is just the length of the contact surface between the two pixels
        if (intersection > 0) {
          // create a new charge:
          // Q(new) = Q*L*X
          //   Q = charge of source pixel
          //   L = intersection length [mm]
          //   X = crosstalk factor    [mm-1]
          const SiChargedDiode& siCharge = (*i_chargedDiode).second;
          SiCharge charge(siCharge.charge() * intersection* crossTalk,
                          siCharge.totalCharge().time(), SiCharge::diodeX_Talk, siCharge.totalCharge().particleLink());
          chargedDiodes.add(*p_neighbour, charge);
        }
      }
    }
    return;
  }

fastSearch()

std::pair< int, int > PixelDigitization::fastSearch	(	const std::vector< double > &	vec,
		double	item )

Definition at line 73 of file PixelDigitizationUtilities.cxx.

                                                        {
    std::pair<int, int> output{-1, -1};
    if (vec.empty()) return output;
    int index_low = 0;
    int index_up = vec.size() - 1;
    if ((item < vec[index_low]) || (item > vec[index_up])) {
      return output;
    } else if (item == vec[index_low]) {
      output.first = index_low;
      output.second = index_low;
      return output;
    } else if (item == vec[index_up]) {
      output.first = index_up;
      output.second = index_up;
      return output;
    }
    while ((index_up - index_low) != 1) {
      int index_middle = int(1.0 * (index_up + index_low) / 2.);
      if (item < vec[index_middle]) index_up = index_middle;
      else if (item > vec[index_middle]) index_low = index_middle;
      else { // accurate hit. Though this is nearly impossible ...
        output.first = index_middle;
        output.second = index_middle;
        return output;
      }
    }
    output.first = index_low;
    output.second = index_up;
    return output;
  }

formBichselDataFileName()

std::string PixelDigitization::formBichselDataFileName	(	int	particleType,
		unsigned int	nCols )

Definition at line 18 of file PixelDigitizationUtilities.cxx.

                                                               {
    const std::string prefix{"PixelDigitization/Bichsel_"};
    const std::string suffix{".dat"};
    const std::string particleTypeString = std::to_string(particleType);
    const std::string nColString= (nCols == 1) ? "" : "_" + std::to_string(nCols) + "steps";
    return prefix + particleTypeString + nColString + suffix;
  }

generateToT()

int PixelDigitization::generateToT	(	CLHEP::HepRandomEngine *	rndmEngine,
		double	mean,
		double	sd,
		const std::pair< int, int > &	range )

Definition at line 192 of file PixelNoiseFunctions.cxx.

                                                                                                       {
    int nToT = static_cast<int>(CLHEP::RandGaussZiggurat::shoot(rndmEngine, mean, sd));
    const auto &[lo,hi] = range;
    //
    if (nToT < lo) {
      nToT = lo;
    }
    if (nToT >= hi) {
      nToT = hi;
    }
    return nToT;
  }

getBichselDataFromFile()

BichselData PixelDigitization::getBichselDataFromFile

(

const std::string &

fullFilename

)

Definition at line 28 of file PixelDigitizationUtilities.cxx.

                                                        {
    std::ifstream inputFile(fullFilename);
    if (not inputFile){
      std::string errmsg = "getBichselDataFromFile: File " + fullFilename +" could not be opened.";
      throw std::runtime_error(errmsg);
    }
    BichselData iData;
    std::string thisLine;
    thisLine.reserve(60); //expecting maximum line length to be 53, allow some margin
    while (getline(inputFile, thisLine)) {
      const auto & [logBetaGamma, logCollisionEnergy, logCrossSection] = parseThreeDoubles(thisLine);
      iData.addEntry(logBetaGamma, logCollisionEnergy, logCrossSection);
    }
    iData.logHighestCrossSectionsVector.push_back(iData.logIntegratedCrossSectionsVectorOfVector.back().back());
    return iData;
  }

getG4Time()

double PixelDigitization::getG4Time

(

const SiTotalCharge &

totalCharge

)

Definition at line 206 of file PixelNoiseFunctions.cxx.

                                              {
    // If there is one single charge, return its time:
    if (totalCharge.chargeComposition().empty()) {
      return totalCharge.time();
    }
    auto p_charge = totalCharge.chargeComposition().begin();
    int findfirst = 0;
    SiCharge first = *p_charge;
    // Look for first charge which is not noise
    for (; p_charge != totalCharge.chargeComposition().end(); p_charge++) {
      if (p_charge->processType() != SiCharge::noise) {
        findfirst = 1;
        break;
      }
    }
    // if all charges were noise, return the time of the highest charge
    if (findfirst == 0) {
      return totalCharge.time();
    }
    // look for the earliest charge among the remaining non-noise charges:
    first = *p_charge;
    p_charge++;
    for (; p_charge != totalCharge.chargeComposition().end(); p_charge++) {
      if (p_charge->time() < first.time() && p_charge->processType() != SiCharge::noise) {
        first = *p_charge;
      }
    }
    return first.time();
  }

parseThreeDoubles()

std::tuple< double, double, double > PixelDigitization::parseThreeDoubles

(

const std::string &

line

)

Definition at line 47 of file PixelDigitizationUtilities.cxx.

                                           {
    std::tuple<double, double, double> result{0., 0.,0.};
    //in local testing, making the following 'static const' reduced the test time (one parse)
    //from 1 637us to 455us. A total file parse test (209 lines of data) was reduced from
    //54 156us to 3 657us
    static const std::regex threeDoublesRx("^([-+.0-9eE]+)\\s+([-+.0-9eE]+)\\s+([-+.0-9eE]+)$");
    std::smatch x3;
    bool foundDoubles=std::regex_match(line, x3, threeDoublesRx);
    if (foundDoubles){
      try{
        //std::stod might throw a out_of_range or an invalid_argument error
        //both of which are subclasses of logic_error
        result = {std::stod(x3[1]), std::stod(x3[2]), std::stod(x3[3])};
      } catch (std::logic_error & e){
        const std::string msg("parseThreeDoubles: error in parsing a number in "+ line);
        throw(std::runtime_error(msg));
      }
    } else {
      const std::string msg("parseThreeDoubles: error in parsing the line " + line);
      throw(std::runtime_error(msg));
    }
    return result;
  }

randomDisable() [1/3]

void PixelDigitization::randomDisable	(	SiChargedDiodeCollection &	chargedDiodes,
		const ITkPixSimulationParameters &	chipData,
		CLHEP::HepRandomEngine *	rndmEngine )

Definition at line 173 of file PixelNoiseFunctions.cxx.

                                      {
    const double disableProbability = chipData.disableProbability();
    return randomDisable(chargedDiodes, disableProbability, rndmEngine);
  }

randomDisable() [2/3]

void PixelDigitization::randomDisable	(	SiChargedDiodeCollection &	chargedDiodes,
		const PixelModuleData *	moduleData,
		CLHEP::HepRandomEngine *	rndmEngine )

Definition at line 164 of file PixelNoiseFunctions.cxx.

                                      {
    const PixelID* pixelId = static_cast<const PixelID*>(chargedDiodes.element()->getIdHelper());
    const int barrel_ec = pixelId->barrel_ec(chargedDiodes.element()->identify());
    const int layerIndex = pixelId->layer_disk(chargedDiodes.element()->identify());
    const double disableProbability = moduleData->getDisableProbability(barrel_ec, layerIndex);
    return randomDisable(chargedDiodes, disableProbability, rndmEngine);
  }

randomDisable() [3/3]

void PixelDigitization::randomDisable	(	SiChargedDiodeCollection &	chargedDiodes,
		double	disableProbability,
		CLHEP::HepRandomEngine *	rndmEngine )

Definition at line 180 of file PixelNoiseFunctions.cxx.

                                     {
    for (SiChargedDiodeOrderedIterator i_chargedDiode = chargedDiodes.orderedBegin();
         i_chargedDiode != chargedDiodes.orderedEnd(); ++i_chargedDiode) {
      if (CLHEP::RandFlat::shoot(rndmEngine) < disableProbability) {
        SiHelper::disabled(**i_chargedDiode, true, false);
      }
    }
    return;
  }

randomNoise() [1/3]

void PixelDigitization::randomNoise	(	SiChargedDiodeCollection &	chargedDiodes,
		const double	totalNoiseOccupancy,
		const std::vector< float > &	noiseShape,
		float	overflowToT,
		const PixelChargeCalibCondData *	chargeCalibData,
		CLHEP::HepRandomEngine *	rndmEngine,
		InDetDD::IPixelReadoutManager *	pixelReadout )

Definition at line 115 of file PixelNoiseFunctions.cxx.

                                                                                                                                            {
   const InDetDD::PixelModuleDesign* p_design =
      static_cast<const InDetDD::PixelModuleDesign*>(&(chargedDiodes.element())->design());
 
    const PixelID* pixelId = static_cast<const PixelID*>(chargedDiodes.element()->getIdHelper());
    const IdentifierHash moduleHash = pixelId->wafer_hash(chargedDiodes.identify()); // wafer hash
    const auto nCircuits = p_design->numberOfCircuits();
    const auto nColumns = p_design->columnsPerCircuit();
    const auto nRows = p_design->rowsPerCircuit();
    const auto totalCells = nCircuits * nColumns * nRows;
    int nNoise = CLHEP::RandPoisson::shoot(rndmEngine, totalCells * totalNoiseOccupancy);
    //prepare to enter loop
    const auto technology = p_design->getReadoutTechnology();
    for (int i = 0; i < nNoise; i++) {
      int circuit = CLHEP::RandFlat::shootInt(rndmEngine, nCircuits);
      int column = CLHEP::RandFlat::shootInt(rndmEngine, nColumns);
      int row = CLHEP::RandFlat::shootInt(rndmEngine, nRows);
      if (row > 159 && technology == InDetDD::PixelReadoutTechnology::FEI3) {
        row += 8;
      } // jump over ganged pixels - rowsPerCircuit == 320 above
 
      InDetDD::SiReadoutCellId roCell(row, nColumns * circuit + column);
      Identifier noisyID = chargedDiodes.element()->identifierFromCellId(roCell);
 
      if (roCell.isValid()) {
        InDetDD::SiCellId diodeNoise = roCell;
        float x = static_cast<float>(CLHEP::RandFlat::shoot(rndmEngine, 0., 1.));  // returns double
        size_t bin{};
        for (size_t j = 1; j < noiseShape.size(); j++) {
          if (x > noiseShape[j - 1] && x <= noiseShape[j]) {
            bin = j - 1;
            break;
          }
        }
        float noiseToTm = bin + 1.5f;
        float noiseToT = CLHEP::RandGaussZiggurat::shoot(rndmEngine, noiseToTm, 1.f);
        if (noiseToT < 1.f) { continue; }  // throw away unphysical noise
        noiseToT = std::min(noiseToT, overflowToT);
        InDetDD::PixelDiodeType type = pixelReadout->getDiodeType(noisyID);
        if (type == InDetDD::PixelDiodeType::NONE) continue;
        float chargeShape = chargeCalibData->getCharge(type, moduleHash, circuit, noiseToT);
        chargedDiodes.add(diodeNoise, SiCharge(chargeShape, 0, SiCharge::noise));
      }
    }
    return;
  }

randomNoise() [2/3]

void PixelDigitization::randomNoise	(	SiChargedDiodeCollection &	chargedDiodes,
		const ITkPixSimulationParameters &	chipData,
		int	nBcid,
		const PixelChargeCalibCondData *	chargeCalibData,
		CLHEP::HepRandomEngine *	rndmEngine,
		InDetDD::IPixelReadoutManager *	pixelReadout )

Definition at line 101 of file PixelNoiseFunctions.cxx.

                                                {
    const double totalNoiseOccupancy = chipData.noiseOccupancy() * nBcid;
    //prepare to enter loop
    const std::vector<float> &noiseShape = chipData.noiseShape();
    // protection to the overflow ToT, that depends on the sensor technology
    float overflowToT = std::numeric_limits<float>::max();
    return randomNoise(chargedDiodes, totalNoiseOccupancy, noiseShape, overflowToT, chargeCalibData, rndmEngine, pixelReadout);
  }

randomNoise() [3/3]

void PixelDigitization::randomNoise	(	SiChargedDiodeCollection &	chargedDiodes,
		const PixelModuleData *	moduleData,
		int	nBcid,
		const PixelChargeCalibCondData *	chargeCalibData,
		CLHEP::HepRandomEngine *	rndmEngine,
		InDetDD::IPixelReadoutManager *	pixelReadout )

Definition at line 76 of file PixelNoiseFunctions.cxx.

                                                {
    const InDetDD::PixelModuleDesign* p_design =
      static_cast<const InDetDD::PixelModuleDesign*>(&(chargedDiodes.element())->design());
 
    const PixelID* pixelId = static_cast<const PixelID*>(chargedDiodes.element()->getIdHelper());
    int barrel_ec = pixelId->barrel_ec(chargedDiodes.element()->identify());
    int layerIndex = pixelId->layer_disk(chargedDiodes.element()->identify());
    const double totalNoiseOccupancy = moduleData->getNoiseOccupancy(barrel_ec,layerIndex) * nBcid;
    //prepare to enter loop
    const std::vector<float> &noiseShape = moduleData->getNoiseShape(barrel_ec, layerIndex);
    const auto technology = p_design->getReadoutTechnology();
    // protection to the overflow ToT, that depends on the sensor technology
    float overflowToT = std::numeric_limits<float>::max();
    if (technology == InDetDD::PixelReadoutTechnology::FEI4) {
      overflowToT = chargeCalibData->getFEI4OverflowToT();
    } else if (technology == InDetDD::PixelReadoutTechnology::FEI3) {
      overflowToT = moduleData->getFEI3Latency(barrel_ec, layerIndex);
    }
    return randomNoise(chargedDiodes, totalNoiseOccupancy, noiseShape, overflowToT, chargeCalibData, rndmEngine, pixelReadout);
  }

randomThreshold()

double PixelDigitization::randomThreshold	(	const PixelChargeCalib::Thresholds &	t,
		CLHEP::HepRandomEngine *	pEngine )

Definition at line 105 of file PixelDigitizationUtilities.cxx.

                                                                                      {
    const double & thrand1 = CLHEP::RandGaussZiggurat::shoot(pEngine);
    const double & thrand2 = CLHEP::RandGaussZiggurat::shoot(pEngine);
    return t.value + t.sigma * thrand1 + t.noise * thrand2;
  }

thermalNoise()

void PixelDigitization::thermalNoise	(	double	thermalNoise,
		SiChargedDiodeCollection &	chargedDiodes,
		CLHEP::HepRandomEngine *	rndmEngine )

Definition at line 64 of file PixelNoiseFunctions.cxx.

                                      {
    for (SiChargedDiodeOrderedIterator i_chargedDiode = chargedDiodes.orderedBegin();
         i_chargedDiode != chargedDiodes.orderedEnd(); ++i_chargedDiode) {
      SiCharge charge(thermalNoise * CLHEP::RandGaussZiggurat::shoot(rndmEngine), 0, SiCharge::noise);
      (*i_chargedDiode)->add(charge);
    }
    return;
  }