svd modules

Namespaces
namespace	Belle2::SVD
	Namespace to encapsulate code needed for simulation and reconstrucion of the SVD.

Classes
class	SVDChannelMappingModule
	The Channel Mapping Check Module. More...
class	SVDClusterCalibrationsMonitorModule
	Module to produce a list of histogram showing the uploaded calibration constants. More...
class	SVDHotStripFinderModule
	A module template. More...
class	SVDLatencyCalibrationModule
	this module performs an analysis to find the APV25 latency More...
class	SVDLocalCalibrationsCheckModule
	Module to produce a list of histogram showing the uploaded local calibration constants. More...
class	SVDLocalCalibrationsMonitorModule
	Module to produce a list of histogram showing the uploaded local calibration constants. More...
class	SVDPositionErrorScaleFactorImporterModule
	Module that produces a localdb with position error scale factors for different position algorithms. More...
class	SVDTimeCalibrationsMonitorModule
	Module to produce a list of histogram showing the uploaded calibration constants. More...
class	SVDChargeSharingAnalysisModule
	Module for monitoring DSSD cluster charge deposition in regard of capacitive charge sharing between adjacent strips in a cluster for data and the simulation. More...
class	SVDClusterQualityEstimatorCalibrationModule
	Generate PDFs for assigning probability that cluster generated from signal particle. More...
class	SVDClusterQualityEstimatorModule
	Calculates the probability of a cluster originating from signal hit. More...
class	SVDCrossTalkCalibrationsCollectorModule
	Collector module used to create the histograms needed for the cross talk calibration. More...
class	SVDCrossTalkFinderModule
	Flags potential cross talk strips on Origami sensors. More...
class	SVDdEdxCollectorModule
	Collector module used to create the histograms needed for the SVD dE/dx calibration. More...
class	SVDdEdxValidationCollectorModule
	Collector module used to create the histograms needed for the SVD dE/dx calibration. More...
class	SVDDQMClustersOnTrackModule
	SVD DQM Module for Clusters related to Tracks. More...
class	SVDDQMEfficiencyModule
	Creates the basic histograms for SVD Efficiency DQM. More...
class	SVDDQMExpressRecoModule
	SVD DQM Module for Express Reco. More...
class	SVDDQMHitTimeModule
	This module to design collect the svd hit time for different detectors trigger timing and physics processes. More...
class	SVDUnpackerDQMModule
	SVD DQM Module for the Unpacker. More...
class	svdDumpModule
	Class definition of svdClsHistoManager module. More...
class	SVDTrackingEventLevelMdstInfoFillerModule
	This module adds additional global event level information about SVD track finding to the MDST object 'EventLevelTrackingInfo'. More...
class	SVDOccupancyCalibrationsCollectorModule
	This This module collects hits from shaper digits to compute per sensor SVD occupancy using mu+mu- events for calibration of the SVDOccupancyCalibration payload using CAF. More...
class	SVDB4CommissioningPlotsModule
	The SVD B4CommissioningPlots Module. More...
class	SVDClusterEvaluationModule
	The SVD ClusterEvaluation Module. More...
class	SVDClusterEvaluationTrueInfoModule
	Clustering Performance, using true information. More...
class	SVDClusterFilterModule
	generates a new StoreArray from the input StoreArray which has all specified Clusters removed More...
class	SVDEventT0PerformanceTTreeModule
	The module is used to create a TTree to study SVD EventT0. More...
class	SVDMaxStripTTreeModule
	The module is used to create a TTree to study the number of strips fired per event per APV chip. More...
class	SVDOccupancyAnalysisModule
	The SVD OccupancyAnalysis Module. More...
class	SVDPerformanceModule
	The (TB) SVD Performance Module. More...
class	SVDPerformanceTTreeModule
	The module is used to create a TTree to study SVD clusters, genfit unbiased residuals and many other properties related to the track they belong to. More...
class	SVDShaperDigitsFromTracksModule
	generates two new StoreArray from the input StoreArray. More...
class	SVDCoGTimeEstimatorModule
	This module builds the SVDRecoDigits (calibrated and fitted strips) from the SVDShaperDigits. More...
class	SVDDataFormatCheckModule
	This module checks the format of the data that we are going to reconstruct checking the SVDModeByte and the SVDDAQDiagnostic. More...
class	SVDStripMaskingModule
	This module removes the strips to be masked read form the SVDHotStripsCalibration. More...
class	SVD3SamplesEmulatorModule
	This module takes the SVDShaperDigit as input and select three consecutive samples starting from the one chosen by the user. More...
class	SVDEventInfoSetterModule
	Module to set the SVDEventInfo in the simulation. More...
class	SVDTriggerQualityGeneratorModule
	This module generates a StoreObjPtr that contains random trigger quality chosen between FINE and COARSE. More...
class	SVDZeroSuppressionEmulatorModule
	This module filters out strips that do not pass a ZS cut from the SVDShaperDigit StoreArray. More...
class	SVD6SampleEventSkimModule
	SVD 6-sample event skim module. More...
struct	ClustersOnSensor
	small struct for storing all clusters of the same sensor in one container. More...
class	SVDSpacePointCreatorModule
	Imports Clusters of the SVD detector and converts them to spacePoints. More...
class	SVDSpacePointQICalibrationModule
	Imports Clusters of the SVD detector and converts them to spacePoints. More...
class	SVDClusterAbsoluteTimeShifterCollectorModule
	This module creates and fills histograms based on cluster-sizes so that the mean of SVD-cluster time distribution could be calculated. More...
class	SVDClusterTimeShifterCollectorModule
	This module creates and fills histograms based on cluster-sizes so that the mean of SVD-cluster time distribution could be calculated. More...
class	SVDTimeCalibrationCollectorModule
	Collector module used to create the histograms needed for the SVD CoG-Time calibration. More...
class	SVDTimeGroupingModule
	Imports Clusters of the SVD detector and converts them to spacePoints. More...
class	SVDTimeValidationCollectorModule
	Collector module used to create the histograms needed for the SVD CoG-Time calibration. More...

Typedefs
typedef std::tuple< double, double, double >	GroupInfo
	typedef to be used to store Gauss parameters (integral, center, sigma)

Functions
void	clusterPDFName (const VxdID &sensor, int size, int side, int maxClusterSize, std::string &PDFName, std::string &errorPDFName, bool useLegacyNaming)
	Function to set name of PDF for cluster quality estimation.
void	occupancyPDFName (const VxdID &sensor, int side, std::string &PDFName)
	Function to maintain common naming convention between calibration occupancy file generation and occupancy value extraction in main crossTalkFinder module.
template<class SpacePointType>
void	provideSVDClusterSingles (const StoreArray< SVDCluster > &svdClusters, StoreArray< SpacePointType > &spacePoints)
	simply store one spacePoint for each existing SVDCluster.
void	storeInputVectorFromSingleCluster (const SVDCluster *cls, std::vector< float > &inputVector, const SVDNoiseCalibrations &noiseCal)
	Store the input values for SVDSpacePoint selection from the given SVDCluster.
void	findPossibleCombinations (const Belle2::ClustersOnSensor &aSensor, std::vector< std::vector< const SVDCluster * > > &foundCombinations, std::vector< std::pair< int, int > > &foundCombinationIndices, const SVDHitTimeSelection &hitTimeCut, const bool &useSVDGroupInfo, const int &numberOfSignalGroups, const bool &formSingleSignalGroup, const SVDNoiseCalibrations &noiseCal, const DBObjPtr< SVDSpacePointSNRFractionSelector > &svdSpacePointSelectionFunction, bool useSVDSpacePointSNRFractionSelector)
	stores all possible 2-Cluster-combinations.
void	spPDFName (const VxdID &sensor, int uSize, int vSize, int maxClusterSize, std::string &PDFName, std::string &errorPDFName, bool useLegacyNaming)
	Function to set name of PDF for spacePoint quality estimation.
void	calculatePairingProb (TFile *pdfFile, const std::vector< const SVDCluster * > &clusters, double &prob, double &error, bool useLegacyNaming)
	Function to extract probability of correct (pair from signal hit) cluster pairing from preconfigured pdfs Probability defined as Pcharge * Ptime * Pucluster * Pvcluster.
template<class SpacePointType>
void	provideSVDClusterCombinations (const StoreArray< SVDCluster > &svdClusters, StoreArray< SpacePointType > &spacePoints, SVDHitTimeSelection &hitTimeCut, bool useQualityEstimator, TFile *pdfFile, bool useLegacyNaming, unsigned int numMaxSpacePoints, std::string m_eventLevelTrackingInfoName, const bool &useSVDGroupInfo, const int &numberOfSignalGroups, const bool &formSingleSignalGroup, const SVDNoiseCalibrations &noiseCal, const DBObjPtr< SVDSpacePointSNRFractionSelector > &svdSpacePointSelectionFunction, bool useSVDSpacePointSNRFractionSelector)
	finds all possible combinations of U and V Clusters for SVDClusters.
double	myGaus (const double *x, const double *par)
	Gauss function to be used in the fit.
void	addGausToHistogram (TH1D &hist, const double &integral, const double &center, const double &sigma, const double &sigmaN, const bool &isAddition=true)
	Add (or Subtract) a Gaussian to (or from) a histogram.
void	subtractGausFromHistogram (TH1D &hist, const double &integral, const double &center, const double &sigma, const double &sigmaN)
	Subtract a Gaussian from a histogram.
int	getSensorType (const VxdID &sensorID)
	Get Sensor Type of SVD sensors.

Detailed Description

Typedef Documentation

GroupInfo

typedef std::tuple<double, double, double> GroupInfo

typedef to be used to store Gauss parameters (integral, center, sigma)

Definition at line 39 of file SVDTimeGroupingModule.h.

Function Documentation

addGausToHistogram()

void addGausToHistogram ( TH1D & hist, const double & integral, const double & center, const double & sigma, const double & sigmaN, const bool & isAddition = true )

inline

Add (or Subtract) a Gaussian to (or from) a histogram.

The gauss is calculated upto the sigmaN passed to the function.

Definition at line 174 of file SVDTimeGroupingModule.h.

  {
    int startBin = hist.FindBin(center - sigmaN * sigma);
    int   endBin = hist.FindBin(center + sigmaN * sigma);
    if (startBin < 1) startBin = 1;
    if (endBin > (hist.GetNbinsX())) endBin = hist.GetNbinsX();
 
    for (int ijx = startBin; ijx <= endBin; ijx++) {
      double tbinc       = hist.GetBinCenter(ijx);
      double tbincontent = hist.GetBinContent(ijx);
 
      if (isAddition) tbincontent += integral * TMath::Gaus(tbinc, center, sigma, true);
      else tbincontent -= integral * TMath::Gaus(tbinc, center, sigma, true);
 
      hist.SetBinContent(ijx, tbincontent);
    }
  }

calculatePairingProb()

void calculatePairingProb ( TFile * pdfFile, const std::vector< const SVDCluster * > & clusters, double & prob, double & error, bool useLegacyNaming )

inline

Function to extract probability of correct (pair from signal hit) cluster pairing from preconfigured pdfs Probability defined as Pcharge * Ptime * Pucluster * Pvcluster.

Definition at line 281 of file SpacePointHelperFunctions.h.

  {
 
    int maxSize;
    int pdfEntries = pdfFile->GetListOfKeys()->GetSize();
    if (useLegacyNaming == true) {
      maxSize = floor(sqrt((pdfEntries - 4) / 6)); //4(time+size)+3(sensors)*2(prob/error)*size^2(u/v combo.)
    } else {
      maxSize = floor(sqrt((pdfEntries - 4) / 344)); //4(time+size)+172(sensorType)*2(prob/error)*size^2(u/v combo.)
    }
    std::string chargeProbInput;
    std::string chargeErrorInput;
 
    spPDFName(clusters[0]->getSensorID(), clusters[0]->getSize(), clusters[1]->getSize(), maxSize,
              chargeProbInput, chargeErrorInput, useLegacyNaming);
    std::string timeProbInput = "timeProb";
    std::string timeErrorInput = "timeError";
    std::string sizeProbInput = "sizeProb";
    std::string sizeErrorInput = "sizeError";
 
 
    TH2F* chargePDF = nullptr;
    TH2F* chargeError = nullptr;
    TH2F* timePDF = nullptr;
    TH2F* timeError = nullptr;
    TH2F* sizePDF = nullptr;
    TH2F* sizeError = nullptr;
 
    pdfFile->GetObject(chargeProbInput.c_str(), chargePDF);
    pdfFile->GetObject(chargeErrorInput.c_str(), chargeError);
    pdfFile->GetObject(timeProbInput.c_str(), timePDF);
    pdfFile->GetObject(timeErrorInput.c_str(), timeError);
    pdfFile->GetObject(sizeProbInput.c_str(), sizePDF);
    pdfFile->GetObject(sizeErrorInput.c_str(), sizeError);
 
    int xChargeBin = chargePDF->GetXaxis()->FindFixBin(clusters[0]->getCharge());
    int yChargeBin = chargePDF->GetYaxis()->FindFixBin(clusters[1]->getCharge());
 
    int xTimeBin = timePDF->GetXaxis()->FindFixBin(clusters[0]->getClsTime());
    int yTimeBin = timePDF->GetYaxis()->FindFixBin(clusters[1]->getClsTime());
 
 
    int xSizeBin = sizePDF->GetXaxis()->FindFixBin(clusters[0]->getSize());
    int ySizeBin = sizePDF->GetYaxis()->FindFixBin(clusters[1]->getSize());
 
    double chargeProb = chargePDF->GetBinContent(xChargeBin, yChargeBin);
    double timeProb = timePDF->GetBinContent(xTimeBin, yTimeBin);
    double sizeProb = sizePDF->GetBinContent(xSizeBin, ySizeBin);
    double chargeProbError = chargePDF->GetBinContent(xChargeBin, yChargeBin);
    double timeProbError = timePDF->GetBinContent(xTimeBin, yTimeBin);
    double sizeProbError = sizePDF->GetBinContent(xSizeBin, ySizeBin);
 
 
    if (chargeProbError == 0) {
      B2DEBUG(21, "svdClusterProbabilityEstimator has not been run, spacePoint QI will return zero!");
    }
 
    prob = chargeProb * timeProb * sizeProb * clusters[0]->getQuality() * clusters[1]->getQuality();
    error = prob * sqrt(square(timeProb * sizeProb * clusters[0]->getQuality() * clusters[1]->getQuality() * chargeProbError) +
                        square(chargeProb * sizeProb * clusters[0]->getQuality() * clusters[1]->getQuality() * timeProbError) +
                        square(chargeProb * timeProb * clusters[0]->getQuality() * clusters[1]->getQuality() * sizeProbError) +
                        square(chargeProb * timeProb * sizeProb * clusters[1]->getQuality() * clusters[0]->getQualityError()) +
                        square(chargeProb * timeProb * sizeProb * clusters[0]->getQuality() * clusters[1]->getQualityError()));
  }

clusterPDFName()

void clusterPDFName ( const VxdID & sensor, int size, int side, int maxClusterSize, std::string & PDFName, std::string & errorPDFName, bool useLegacyNaming )

inline

Function to set name of PDF for cluster quality estimation.

Legacy naming convention for PDFs distributed by sensor type rather than sensor ID, not used after 2018 MC calibrated PDFs.

Definition at line 24 of file ClusterQualityHelperFunctions.h.

  {
    if (useLegacyNaming == true) {
      std::string sensorSide;
      if (side == 1) sensorSide = "u";
      if (side == 0) sensorSide = "v";
 
      if (size > maxClusterSize) size = maxClusterSize;
      std::string sensorName;
      if (sensor.getLayerNumber() == 3)  sensorName = "l3";
      if (sensor.getLayerNumber() > 3 && sensor.getSensorNumber() == 1)  sensorName = "trap";
      if (sensor.getLayerNumber() > 3 && sensor.getSensorNumber() > 1)  sensorName = "large";
 
      PDFName =  sensorSide + sensorName +  std::to_string(size);
      errorPDFName = PDFName + "Error";
    } else {
 
      std::string sensorSide;
      if (side == 1) sensorSide = "u";
      if (side == 0) sensorSide = "v";
      int layer = sensor.getLayerNumber();
      int ladder = sensor.getLadderNumber();
      int sens = sensor.getSensorNumber();
 
      if (size > maxClusterSize) size = maxClusterSize;
 
      PDFName =  std::to_string(layer) + "." + std::to_string(ladder) + "." + std::to_string(sens) + "."  + sensorSide + "."  +
                 std::to_string(size);
      errorPDFName = PDFName + "_Error";
 
    }
  }

findPossibleCombinations()

void findPossibleCombinations ( const Belle2::ClustersOnSensor & aSensor, std::vector< std::vector< const SVDCluster * > > & foundCombinations, std::vector< std::pair< int, int > > & foundCombinationIndices, const SVDHitTimeSelection & hitTimeCut, const bool & useSVDGroupInfo, const int & numberOfSignalGroups, const bool & formSingleSignalGroup, const SVDNoiseCalibrations & noiseCal, const DBObjPtr< SVDSpacePointSNRFractionSelector > & svdSpacePointSelectionFunction, bool useSVDSpacePointSNRFractionSelector )

inline

stores all possible 2-Cluster-combinations.

first parameter is a struct containing all clusters on current sensor. second parameter is the container which collects all combinations found.

for each u cluster, a v cluster is combined to a possible combination. Condition which has to be fulfilled: the first entry is always an u cluster, the second always a v-cluster

Definition at line 159 of file SpacePointHelperFunctions.h.

  {
 
    for (size_t iU = 0; iU < aSensor.clustersU.size(); ++iU) {
      const SVDCluster* uCluster = aSensor.clustersU[iU];
      if (! hitTimeCut.isClusterInTime(uCluster->getSensorID(), 1, uCluster->getClsTime())) {
        B2DEBUG(29, "Cluster rejected due to timing cut. Cluster time: " << uCluster->getClsTime());
        continue;
      }
      for (size_t iV = 0; iV < aSensor.clustersV.size(); ++iV) {
        const SVDCluster* vCluster = aSensor.clustersV[iV];
        if (! hitTimeCut.isClusterInTime(vCluster->getSensorID(), 0, vCluster->getClsTime())) {
          B2DEBUG(29, "Cluster rejected due to timing cut. Cluster time: " << vCluster->getClsTime());
          continue;
        }
 
        if (! hitTimeCut.areClusterTimesCompatible(vCluster->getSensorID(), uCluster->getClsTime(), vCluster->getClsTime())) {
          B2DEBUG(29, "Cluster combination rejected due to timing cut. Cluster time U (" << uCluster->getClsTime() <<
                  ") is incompatible with Cluster time V (" << vCluster->getClsTime() << ")");
          continue;
        }
 
        if (useSVDGroupInfo) {
          const std::vector<int>& uTimeGroupId = uCluster->getTimeGroupId();
          const std::vector<int>& vTimeGroupId = vCluster->getTimeGroupId();
 
          if (int(uTimeGroupId.size()) && int(vTimeGroupId.size())) { // indirect check if the clusterizer module is disabled
            bool isContinue = true;
            for (const auto& uitem : uTimeGroupId) {
              if (uitem < 0 || uitem >= numberOfSignalGroups) continue;
              for (const auto& vitem : vTimeGroupId) {
                if (vitem < 0 || vitem >= numberOfSignalGroups) continue;
                if ((uitem == vitem) || formSingleSignalGroup) { isContinue = false; break; }
              }
              if (!isContinue) break;
            }
 
            if (isContinue) {
              B2DEBUG(29, "Cluster combination rejected due to different time-group Id.");
              continue;
            }
          }
        }
 
        if (useSVDSpacePointSNRFractionSelector) {
          std::vector<float> inputU;
          std::vector<float> inputV;
 
          storeInputVectorFromSingleCluster(uCluster, inputU, noiseCal);
          storeInputVectorFromSingleCluster(vCluster, inputV, noiseCal);
 
          bool pass = svdSpacePointSelectionFunction->passSNRFractionSelection(inputU, inputV);
          if (!pass) {
            B2DEBUG(29, "Cluster combination rejected due to SVDSpacePointSNRFractionSelector");
            continue;
          }
        }
 
        foundCombinations.push_back({uCluster, vCluster});
        foundCombinationIndices.emplace_back(aSensor.indicesU[iU], aSensor.indicesV[iV]);
 
 
      }
    }
 
 
 
 
  }

getSensorType()

int getSensorType ( const VxdID & sensorID )

inline

Get Sensor Type of SVD sensors.

Definition at line 207 of file SVDTimeGroupingModule.h.

  {
    int layer  = sensorID.getLayerNumber();
    int sensor = sensorID.getSensorNumber();
    if (layer == 3)
      return 0;
    else {
      if (sensor == 1)
        return 1;
      else
        return 2;
    }
  }

myGaus()

double myGaus ( const double * x, const double * par )

inline

Gauss function to be used in the fit.

Definition at line 164 of file SVDTimeGroupingModule.h.

  {
    return par[0] * TMath::Gaus(x[0], par[1], par[2], true);
  }

occupancyPDFName()

void occupancyPDFName ( const VxdID & sensor, int side, std::string & PDFName )

inline

Function to maintain common naming convention between calibration occupancy file generation and occupancy value extraction in main crossTalkFinder module.

Definition at line 27 of file SVDCrossTalkFinderHelperFunctions.h.

  {
 
    int layer = sensor.getLayerNumber();
    int ladder = sensor.getLadderNumber();
    int sens = sensor.getSensorNumber();
 
 
    PDFName =  std::to_string(layer) + "." + std::to_string(ladder) + "." + std::to_string(sens) + "."  + std::to_string(side);
 
 
  }

provideSVDClusterCombinations()

template<class SpacePointType>

void provideSVDClusterCombinations	(	const StoreArray< SVDCluster > &	svdClusters,
		StoreArray< SpacePointType > &	spacePoints,
		SVDHitTimeSelection &	hitTimeCut,
		bool	useQualityEstimator,
		TFile *	pdfFile,
		bool	useLegacyNaming,
		unsigned int	numMaxSpacePoints,
		std::string	m_eventLevelTrackingInfoName,
		const bool &	useSVDGroupInfo,
		const int &	numberOfSignalGroups,
		const bool &	formSingleSignalGroup,
		const SVDNoiseCalibrations &	noiseCal,
		const DBObjPtr< SVDSpacePointSNRFractionSelector > &	svdSpacePointSelectionFunction,
		bool	useSVDSpacePointSNRFractionSelector )

finds all possible combinations of U and V Clusters for SVDClusters.

first parameter is a storeArray containing SVDClusters. second parameter is a storeArra containing SpacePoints (will be filled in the function). third parameter tels the spacePoint where to get the name of the storeArray containing the related clusters relationweights code the type of the cluster. +1 for u and -1 for v

Definition at line 354 of file SpacePointHelperFunctions.h.

  {
    std::unordered_map<VxdID::baseType, ClustersOnSensor>
    activatedSensors; // collects one entry per sensor, each entry will contain all Clusters on it TODO: better to use a sorted vector/list?
    std::vector<std::vector<const SVDCluster*> >
    foundCombinations; // collects all combinations of Clusters which were possible (condition: 1u+1v-Cluster on the same sensor)
    std::vector<std::pair<int, int> >
    foundCombinationIndices; // StoreArray indices of the (u, v) clusters of each entry of foundCombinations
 
    // sort Clusters by sensor. After the loop, each entry of activatedSensors contains all U and V-type clusters on that sensor
    for (unsigned int i = 0; i < uint(svdClusters.getEntries()); ++i) {
      SVDCluster* currentCluster = svdClusters[i];
 
      activatedSensors[currentCluster->getSensorID().getID()].addCluster(currentCluster, i);
    }
 
 
    for (const auto& aSensor : activatedSensors)
      findPossibleCombinations(aSensor.second, foundCombinations, foundCombinationIndices, hitTimeCut, useSVDGroupInfo,
                               numberOfSignalGroups, formSingleSignalGroup, noiseCal, svdSpacePointSelectionFunction,
                               useSVDSpacePointSNRFractionSelector);
 
    // Do not make space-points if their number would be too large to be considered by tracking
    if (foundCombinations.size() > numMaxSpacePoints) {
      StoreObjPtr<EventLevelTrackingInfo> m_eventLevelTrackingInfo(m_eventLevelTrackingInfoName);
      if (m_eventLevelTrackingInfo.isValid()) {
        m_eventLevelTrackingInfo->setSVDSpacePointCreatorAbortionFlag();
      }
      return;
    }
 
    // RelationArray is much cheaper than addRelationTo
    // The relation weight codes the type of the cluster: +1 for u and -1 for v.
    RelationArray spacePointsToClusters(spacePoints, svdClusters);
 
    for (size_t iCombi = 0; iCombi < foundCombinations.size(); ++iCombi) {
      auto& clusterCombi = foundCombinations[iCombi];
      const int spacePointIndex = spacePoints.getEntries();
      SpacePointType* newSP = spacePoints.appendNew(clusterCombi);
      if (useQualityEstimator == true) {
        double probability;
        double error;
        calculatePairingProb(pdfFile, clusterCombi, probability, error, useLegacyNaming);
        newSP->setQualityEstimation(probability);
        newSP->setQualityEstimationError(error);
      }
      // the first cluster of the combination is always the u one, the second one the v one
      spacePointsToClusters.add(spacePointIndex, foundCombinationIndices[iCombi].first, 1.);
      spacePointsToClusters.add(spacePointIndex, foundCombinationIndices[iCombi].second, -1.);
    }
  }

provideSVDClusterSingles()

template<class SpacePointType>

void provideSVDClusterSingles	(	const StoreArray< SVDCluster > &	svdClusters,
		StoreArray< SpacePointType > &	spacePoints )

simply store one spacePoint for each existing SVDCluster.

first parameter is a storeArray containing SVDClusters. second parameter is a storeArra containing SpacePoints (will be filled in the function).

Definition at line 97 of file SpacePointHelperFunctions.h.

  {
    // RelationArray is much cheaper than addRelationTo
    RelationArray spacePointsToClusters(spacePoints, svdClusters);
    for (unsigned int i = 0; i < uint(svdClusters.getEntries()); ++i) {
      const SVDCluster* currentCluster = svdClusters[i];
      std::vector<const SVDCluster*> currentClusterCombi = { currentCluster };
      const int spacePointIndex = spacePoints.getEntries();
      spacePoints.appendNew(currentClusterCombi);
      spacePointsToClusters.add(spacePointIndex, i);
    }
  }

spPDFName()

void spPDFName ( const VxdID & sensor, int uSize, int vSize, int maxClusterSize, std::string & PDFName, std::string & errorPDFName, bool useLegacyNaming )

inline

Function to set name of PDF for spacePoint quality estimation.

Legacy naming convention for PDFs distributed by sensor type rather than sensor ID, not used after 2018 MC calibrated PDFs.

Definition at line 239 of file SpacePointHelperFunctions.h.

  {
    if (useLegacyNaming == true) {
 
      if (uSize > maxClusterSize) uSize = maxClusterSize;
      if (vSize > maxClusterSize) vSize = maxClusterSize;
 
      std::string sensorName;
 
      if (sensor.getLayerNumber() == 3)  sensorName = "l3";
      if (sensor.getLayerNumber() > 3 && sensor.getSensorNumber() == 1)  sensorName = "trap";
      if (sensor.getLayerNumber() > 3 && sensor.getSensorNumber() > 1)  sensorName = "large";
 
      PDFName =  sensorName +  std::to_string(uSize)  + std::to_string(vSize);
      errorPDFName = "error" + PDFName;
    } else {
 
      if (uSize > maxClusterSize) uSize = maxClusterSize;
      if (vSize > maxClusterSize) vSize = maxClusterSize;
 
      int layer = sensor.getLayerNumber();
      int ladder = sensor.getLadderNumber();
      int sens = sensor.getSensorNumber();
 
      PDFName =  std::to_string(layer) + "." + std::to_string(ladder) + "." + std::to_string(sens) + "."  + std::to_string(
                   uSize) + "."  + std::to_string(vSize);
      errorPDFName = PDFName + "_Error";
    }
 
 
 
  }

storeInputVectorFromSingleCluster()

void storeInputVectorFromSingleCluster ( const SVDCluster * cls, std::vector< float > & inputVector, const SVDNoiseCalibrations & noiseCal )

inline

Store the input values for SVDSpacePoint selection from the given SVDCluster.

Definition at line 114 of file SpacePointHelperFunctions.h.

  {
    inputVector.clear();
    inputVector.resize(3, 0.0);
 
    auto shaperDigits = cls->getRelationsTo<SVDShaperDigit>();
    float noise = 0;
    for (auto iSD : shaperDigits) {
      auto samples = iSD.getSamples();
      std::vector<float> selectedSamples;
      if (samples.size() == 6) {
        Belle2::SVD::SVDMaxSumAlgorithm maxSum(samples);
        auto maxSamples = maxSum.getSelectedSamples();
        selectedSamples.assign(maxSamples.begin(), maxSamples.end());
      } else {
        selectedSamples.assign(samples.begin(), samples.end());
      }
      if (selectedSamples.size() < 3) continue;
 
      inputVector[0] += selectedSamples[0];
      inputVector[1] += selectedSamples[1];
      inputVector[2] += selectedSamples[2];
 
      VxdID thisSensorID = iSD.getSensorID();
      bool thisSide = iSD.isUStrip();
      int thisCellID = iSD.getCellID();
      float thisNoise = noiseCal.getNoise(thisSensorID, thisSide, thisCellID);
      noise += thisNoise * thisNoise;
    }
    noise = sqrt(noise);
    inputVector[0] = inputVector[0] / noise;
    inputVector[1] = inputVector[1] / noise;
    inputVector[2] = inputVector[2] / noise;
  }

subtractGausFromHistogram()

void subtractGausFromHistogram ( TH1D & hist, const double & integral, const double & center, const double & sigma, const double & sigmaN )

inline

Subtract a Gaussian from a histogram.

The gauss is calculated upto the sigmaN passed to the function.

Definition at line 199 of file SVDTimeGroupingModule.h.

  {
    addGausToHistogram(hist, integral, center, sigma, sigmaN, false);
  }