Derived Class representing the SVD cluster position computed with the CoGOnly algorithm. More...

#include <SVDCoGOnlyPosition.h>

Inheritance diagram for SVDCoGOnlyPosition:

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

virtual	~SVDCoGOnlyPosition ()
	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 CoGOnly algorithm.

Definition at line 22 of file SVDCoGOnlyPosition.h.

Constructor & Destructor Documentation

◆ ~SVDCoGOnlyPosition()

virtual ~SVDCoGOnlyPosition ( )

inlinevirtual

virtual destructor

Definition at line 35 of file SVDCoGOnlyPosition.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 CoG algorithm

Implements SVDClusterPosition.

Definition at line 23 of file SVDCoGOnlyPosition.cc.

    {
      reconstructStrips(rawCluster);
      applyUnfolding(rawCluster);
      applyCoGPosition(rawCluster, position, positionError);
 
      //apply scale factors for the position errors
      positionError = m_CoGOnlyCal.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/SVDCoGOnlyPosition.h
svd/reconstruction/src/SVDCoGOnlyPosition.cc

Public Member Functions

Protected Member Functions

Protected Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ~SVDCoGOnlyPosition()

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