Derived Class representing the SVD cluster position computed with the old algorithm (up to release-05). More...

#include <SVDOldDefaultPosition.h>

Inheritance diagram for SVDOldDefaultPosition:

Public Member Functions
void	computeClusterPosition (Belle2::SVD::RawCluster &rawCluster, double &position, double &positionError) override
	computes the cluster position and position error with the OldDefault algorithm

virtual	~SVDOldDefaultPosition ()
	virtual destructor

void	applyCoGPosition (const Belle2::SVD::RawCluster &rawCluster, double &position, double &positionError)
	CoG Position Algorithm.

void	applyAHTPosition (const Belle2::SVD::RawCluster &rawCluster, double &position, double &positionError)
	AHT Position Algorithm.

void	reconstructStrips (Belle2::SVD::RawCluster &rawCluster)
	reconstruct strips

void	applyUnfolding (Belle2::SVD::RawCluster &rawCluster)
	Apply cluster charges unfolding.

void	set_stripChargeAlgo (const std::string &user_stripChargeAlgo)
	set which algorithm to use for strip charge in cluster position reconstruction

void	set_stripTimeAlgo (const std::string &user_stripTimeAlgo)
	set which algorithm to use for strip time in cluster position reconstruction, 'dontdo' will skip it

Protected Member Functions
double	getSumOfStripCharges (const Belle2::SVD::RawCluster &rawCluster)
	helper, returns the sum of the strip charges

double	getClusterNoise (const Belle2::SVD::RawCluster &rawCluster)
	helper, returns the sum in quadrature of the strip noise

double	getAverageStripNoise (const Belle2::SVD::RawCluster &rawCluster)
	helper, returns the average strip noise

Protected Attributes
SVDCoGOnlyPositionError	m_CoGOnlyErr
	CoGOnly Position Error.

SVDCoGOnlyErrorScaleFactors	m_CoGOnlyCal
	Scaling Factors for the CoGOnly algorithm.

SVDOldDefaultErrorScaleFactors	m_OldDefaultCal
	Scaling Factors for the OldDefault algorithm.

SVDClustering	m_ClusterCal
	SVD clustering parameters.

SVDNoiseCalibrations	m_NoiseCal
	Noise calibrations for the position error.

Private Attributes
std::string	m_stripChargeAlgo
	algorithm used to reconstruct strip charge for cluster position

std::string	m_stripTimeAlgo
	algorithm used to reconstruct strip time for cluster position

Detailed Description

Derived Class representing the SVD cluster position computed with the old algorithm (up to release-05).

Definition at line 22 of file SVDOldDefaultPosition.h.

Constructor & Destructor Documentation

◆ ~SVDOldDefaultPosition()

virtual ~SVDOldDefaultPosition ( )

inlinevirtual

virtual destructor

Definition at line 35 of file SVDOldDefaultPosition.h.

35{};

Member Function Documentation

◆ applyAHTPosition()

void applyAHTPosition	(	const Belle2::SVD::RawCluster &	rawCluster,
		double &	position,
		double &	positionError
	)

inherited

AHT Position Algorithm.

Definition at line 71 of file SVDClusterPosition.cc.

    {
 
      // NOTE:
      // tail and head are the two strips at the edge of the cluster
 
      const VXD::GeoCache& geo = VXD::GeoCache::getInstance();
      const VXD::SensorInfoBase& info = geo.getSensorInfo(rawCluster.getSensorID());
      double pitch = rawCluster.isUSide() ? info.getUPitch() : info.getVPitch();
 
      //take the strips in the rawCluster
      std::vector<Belle2::SVD::StripInRawCluster> strips = rawCluster.getStripsInRawCluster();
 
      //informations about the head strip
      int headStripCellID = strips.at(strips.size() - 1).cellID;
      double headStripCharge = strips.at(strips.size() - 1).charge;
      //informations about the tail strip
      int tailStripCellID = strips.at(0).cellID;
      double tailStripCharge = strips.at(0).charge;
 
      // average strip charge of the center of the cluster
 
      double centreCharge = (getSumOfStripCharges(rawCluster) - tailStripCharge - headStripCharge) / (strips.size() - 2);
 
      tailStripCharge = (tailStripCharge < centreCharge) ? tailStripCharge : centreCharge;
      headStripCharge = (headStripCharge < centreCharge) ? headStripCharge : centreCharge;
      double tailPos = rawCluster.isUSide() ? info.getUCellPosition(tailStripCellID) : info.getVCellPosition(tailStripCellID);
      double headPos = rawCluster.isUSide() ? info.getUCellPosition(headStripCellID) : info.getVCellPosition(headStripCellID);
      position = 0.5 * (tailPos + headPos + (headStripCharge - tailStripCharge) / centreCharge * pitch);
 
      //now compute position error
      double cutAdjacent = m_ClusterCal.getMinAdjSNR(rawCluster.getSensorID(), rawCluster.isUSide());
      double sn = centreCharge / cutAdjacent / getClusterNoise(rawCluster);
 
      // Rough estimates of Landau noise
      double landauHead = tailStripCharge / centreCharge;
      double landauTail = headStripCharge / centreCharge;
      positionError = 0.5 * pitch * sqrt(1.0 / sn / sn +
                                         0.5 * landauHead * landauHead +
                                         0.5 * landauTail * landauTail);
 
    }

◆ applyCoGPosition()

void applyCoGPosition	(	const Belle2::SVD::RawCluster &	rawCluster,
		double &	position,
		double &	positionError
	)

inherited

CoG Position Algorithm.

Definition at line 34 of file SVDClusterPosition.cc.

    {
 
      const VXD::GeoCache& geo = VXD::GeoCache::getInstance();
      const VXD::SensorInfoBase& info = geo.getSensorInfo(rawCluster.getSensorID());
 
      position = 0;
      double charge = 0;
 
      //take the strips in the rawCluster
      std::vector<Belle2::SVD::StripInRawCluster> strips = rawCluster.getStripsInRawCluster();
 
      for (auto aStrip : strips) {
 
        double stripPos = rawCluster.isUSide() ? info.getUCellPosition(aStrip.cellID) : info.getVCellPosition(aStrip.cellID);
 
        //getting the charge of the strip
        double stripCharge  = aStrip.charge;
 
        position += stripPos * stripCharge;
        charge += stripCharge;
      }
 
      position /= charge;
 
      //now compute position error
      positionError = 0;
      double pitch = rawCluster.isUSide() ? info.getUPitch() : info.getVPitch();
      double sumStripCharge = getSumOfStripCharges(rawCluster);
 
      positionError = m_CoGOnlyErr.getPositionError(rawCluster.getSensorID(), rawCluster.isUSide(), 0,
                                                    sumStripCharge / getClusterNoise(rawCluster), rawCluster.getSize(), pitch);
 
    }

◆ applyUnfolding()

void applyUnfolding ( Belle2::SVD::RawCluster & rawCluster )

inherited

Apply cluster charges unfolding.

Definition at line 240 of file SVDClusterPosition.cc.

    {
 
 
      std::vector<Belle2::SVD::StripInRawCluster> strips = rawCluster.getStripsInRawCluster();
      double unfoldingCoefficient = m_ClusterCal.getUnfoldingCoeff(rawCluster.getSensorID(), rawCluster.isUSide());
      unsigned int Size = strips.size();
      double threshold = 0;
      Eigen::VectorXd Charges(Size);
      Eigen::MatrixXd Couplings(Size, Size);
      // Unfolding Matrix
      for (unsigned int i = 0; i < Size; ++i) {
        for (unsigned int j = 0; j < Size; ++j) {
          if (i == j) {Couplings(i, j) = 1 - 2 * unfoldingCoefficient;}
          else if (j == i + 1) {Couplings(i, j) = unfoldingCoefficient;}
          else if (j == i - 1) {Couplings(i, j) = unfoldingCoefficient;}
          else {Couplings(i, j) = 0;}
        }
 
        Belle2::SVD::StripInRawCluster strip = strips.at(i);
 
        RawCluster tmp(rawCluster.getSensorID(), rawCluster.isUSide(), 0, 0);
        if (tmp.add(rawCluster.getSensorID(), rawCluster.isUSide(), strip)) {
          //Fill a vector with strip charges
          Charges(i) = strip.charge;
        }
 
      }
      //Apply the unfolding
      Charges = Couplings.inverse() * Charges;
      for (unsigned i = 0; i < Size; i++) {
        if (Charges(i) < threshold) {Charges(i) = 0;}
        rawCluster.setStripCharge(i, Charges(i));
      }
 
    }

◆ computeClusterPosition()

void computeClusterPosition	(	Belle2::SVD::RawCluster &	rawCluster,
		double &	position,
		double &	positionError
	)

overridevirtual

computes the cluster position and position error with the OldDefault algorithm

Implements SVDClusterPosition.

Definition at line 23 of file SVDOldDefaultPosition.cc.

    {
 
      reconstructStrips(rawCluster);
 
      if (rawCluster.getSize() < 3)
        applyCoGPosition(rawCluster, position, positionError);
      else
        applyAHTPosition(rawCluster, position, positionError);
 
      //apply scale factors for the position errors
      positionError = m_OldDefaultCal.getCorrectedClusterPositionError(rawCluster.getSensorID(), rawCluster.isUSide(),
                      rawCluster.getSize(),
                      positionError);
    }

◆ getAverageStripNoise()

double getAverageStripNoise ( const Belle2::SVD::RawCluster & rawCluster )

protectedinherited

helper, returns the average strip noise

Definition at line 148 of file SVDClusterPosition.cc.

    {
 
      double averageNoise = 0;
 
      //take the strips in the rawCluster
      std::vector<Belle2::SVD::StripInRawCluster> strips = rawCluster.getStripsInRawCluster();
 
      // compute the average strip noise
      for (auto aStrip : strips) {
 
        float averageNoiseInElectrons =  m_NoiseCal.getNoiseInElectrons(rawCluster.getSensorID(), rawCluster.isUSide(), aStrip.cellID);
        averageNoise += averageNoiseInElectrons;
      }
      return averageNoise / strips.size();
    }

◆ getClusterNoise()

double getClusterNoise ( const Belle2::SVD::RawCluster & rawCluster )

protectedinherited

helper, returns the sum in quadrature of the strip noise

Definition at line 131 of file SVDClusterPosition.cc.

    {
 
      double clusterNoise = 0;
 
      //take the strips in the rawCluster
      std::vector<Belle2::SVD::StripInRawCluster> strips = rawCluster.getStripsInRawCluster();
 
      // compute the cluster noise as sum in quadrature of strip noise
      for (auto aStrip : strips) {
 
        float averageNoiseInElectrons =  m_NoiseCal.getNoiseInElectrons(rawCluster.getSensorID(), rawCluster.isUSide(), aStrip.cellID);
        clusterNoise += averageNoiseInElectrons * averageNoiseInElectrons;
      }
      return sqrt(clusterNoise);
    }

◆ getSumOfStripCharges()

double getSumOfStripCharges ( const Belle2::SVD::RawCluster & rawCluster )

protectedinherited

helper, returns the sum of the strip charges

Definition at line 114 of file SVDClusterPosition.cc.

    {
 
      double sumStripCharge = 0;
 
      //take the strips in the rawCluster
      std::vector<Belle2::SVD::StripInRawCluster> strips = rawCluster.getStripsInRawCluster();
 
      // compute the sum of strip charges
      for (auto aStrip : strips) {
 
        double stripCharge  = aStrip.charge;
        sumStripCharge += stripCharge;
      }
      return sumStripCharge;
    }

◆ reconstructStrips()

void reconstructStrips ( Belle2::SVD::RawCluster & rawCluster )

inherited

reconstruct strips

Definition at line 165 of file SVDClusterPosition.cc.

    {
 
 
      std::vector<Belle2::SVD::StripInRawCluster> strips = rawCluster.getStripsInRawCluster();
 
      //loop on strips
      for (int i = 0; i < (int)strips.size(); i++) {
 
        Belle2::SVD::StripInRawCluster strip = strips.at(i);
 
        RawCluster tmp(rawCluster.getSensorID(), rawCluster.isUSide(), 0, 0);
        if (tmp.add(rawCluster.getSensorID(), rawCluster.isUSide(), strip)) {
 
          // time computation
          if (m_stripTimeAlgo.compare("dontdo") != 0) {
 
            double time = 0;
            double timeError = 0;
            int firstFrame = 0;
 
            if (m_stripTimeAlgo == "ELS3") {
              SVDELS3Time ct;
              ct.computeClusterTime(tmp, time, timeError, firstFrame);
 
            } else if (m_stripTimeAlgo == "CoG3") {
              SVDCoG3Time ct;
              ct.computeClusterTime(tmp, time, timeError, firstFrame);
            }
            rawCluster.setStripTime(i, time);
          }
 
          // charge computation
          // may be not needed in case the cluster position is computed using APV samples
          // and not using reconstructed strips
          if (m_stripChargeAlgo.compare("dontdo") != 0) {
            double charge = 0;
            double SNR;
            double seedCharge;
 
            if (m_stripChargeAlgo == "ELS3") {
              // ELS3 can return non-sense values for off-time or low-charge strips)
              // if returned charge is negative or more than 30% different than MaxSample, we use MaxSample
              // without notice to the user!
 
              SVDELS3Charge cc;
              cc.computeClusterCharge(tmp, charge, SNR, seedCharge);
 
              double maxSample_charge = 0;
              SVDMaxSampleCharge maxSample_cc;
              maxSample_cc.computeClusterCharge(tmp, maxSample_charge, SNR, seedCharge);
 
              if ((abs(charge - maxSample_charge) / maxSample_charge > 0.3) || charge < 0)
                rawCluster.setStripCharge(i, maxSample_charge);
              else
                rawCluster.setStripCharge(i, charge);
 
            } else if (m_stripChargeAlgo == "SumSamples") {
              SVDSumSamplesCharge cc;
              cc.computeClusterCharge(tmp, charge, SNR, seedCharge);
              rawCluster.setStripCharge(i, charge);
            } else  {
              // MaxSample is used when the algorithm is not recognized
              SVDMaxSampleCharge cc;
              cc.computeClusterCharge(tmp, charge, SNR, seedCharge);
              rawCluster.setStripCharge(i, charge);
            }
          }
        } else
          B2ERROR("this should not happen...");
 
      }
 
    }

◆ set_stripChargeAlgo()

void set_stripChargeAlgo ( const std::string & user_stripChargeAlgo )

inlineinherited

set which algorithm to use for strip charge in cluster position reconstruction

Definition at line 59 of file SVDClusterPosition.h.

59{m_stripChargeAlgo = user_stripChargeAlgo;}

◆ set_stripTimeAlgo()

void set_stripTimeAlgo ( const std::string & user_stripTimeAlgo )

inlineinherited

set which algorithm to use for strip time in cluster position reconstruction, 'dontdo' will skip it

Definition at line 62 of file SVDClusterPosition.h.

62{m_stripTimeAlgo = user_stripTimeAlgo;}

Member Data Documentation

◆ m_ClusterCal

SVDClustering m_ClusterCal

protectedinherited

SVD clustering parameters.

Definition at line 77 of file SVDClusterPosition.h.

◆ m_CoGOnlyCal

SVDCoGOnlyErrorScaleFactors m_CoGOnlyCal

protectedinherited

Scaling Factors for the CoGOnly algorithm.

Definition at line 75 of file SVDClusterPosition.h.

◆ m_CoGOnlyErr

SVDCoGOnlyPositionError m_CoGOnlyErr

protectedinherited

CoGOnly Position Error.

Definition at line 74 of file SVDClusterPosition.h.

◆ m_NoiseCal

SVDNoiseCalibrations m_NoiseCal

protectedinherited

Noise calibrations for the position error.

Definition at line 78 of file SVDClusterPosition.h.

◆ m_OldDefaultCal

SVDOldDefaultErrorScaleFactors m_OldDefaultCal

protectedinherited

Scaling Factors for the OldDefault algorithm.

Definition at line 76 of file SVDClusterPosition.h.

◆ m_stripChargeAlgo

std::string m_stripChargeAlgo

privateinherited

algorithm used to reconstruct strip charge for cluster position

Definition at line 82 of file SVDClusterPosition.h.

◆ m_stripTimeAlgo

std::string m_stripTimeAlgo

privateinherited

algorithm used to reconstruct strip time for cluster position

Definition at line 83 of file SVDClusterPosition.h.

The documentation for this class was generated from the following files:

svd/reconstruction/include/SVDOldDefaultPosition.h
svd/reconstruction/src/SVDOldDefaultPosition.cc

Public Member Functions

Protected Member Functions

Protected Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ~SVDOldDefaultPosition()

Member Function Documentation

◆ applyAHTPosition()

◆ applyCoGPosition()

◆ applyUnfolding()

◆ computeClusterPosition()

◆ getAverageStripNoise()

◆ getClusterNoise()

◆ getSumOfStripCharges()

◆ reconstructStrips()

◆ set_stripChargeAlgo()

◆ set_stripTimeAlgo()

Member Data Documentation

◆ m_ClusterCal

◆ m_CoGOnlyCal

◆ m_CoGOnlyErr

◆ m_NoiseCal

◆ m_OldDefaultCal

◆ m_stripChargeAlgo

◆ m_stripTimeAlgo