This class is used to transfer PXD information to the track fit. More...

#include <AlignablePXDRecoHit.h>

Inheritance diagram for AlignablePXDRecoHit:

Public Member Functions
virtual	~AlignablePXDRecoHit ()
	Destructor.

genfit::AbsMeasurement *	clone () const override
	Creating a deep copy of this hit.

virtual std::pair< std::vector< int >, TMatrixD >	globalDerivatives (const genfit::StateOnPlane *sop) override
	Labels and derivatives of residuals (local measurement coordinates) w.r.t.

	PXDRecoHit (const PXDTrueHit hit, const genfit::TrackCandHit trackCandHit=NULL, float sigmaU=-1, float sigmaV=-1)
	Inherit constructors.

	PXDRecoHit (const PXDCluster *hit, float sigmaU, float sigmaV, float covUV)
	Inherit constructors.

	PXDRecoHit (const PXDCluster hit, const genfit::TrackCandHit trackCandHit=NULL)
	Inherit constructors.

virtual std::vector< genfit::MeasurementOnPlane * >	constructMeasurementsOnPlane (const genfit::StateOnPlane &state) const override
	Methods that actually interface to Genfit.

VxdID	getSensorID () const
	Get the compact ID.

const PXDTrueHit *	getTrueHit () const
	Get pointer to the TrueHit used when creating this RecoHit, can be NULL if created from something else.

const PXDCluster *	getCluster () const
	Get pointer to the Cluster used when creating this RecoHit, can be NULL if created from something else.

float	getU () const
	Get u coordinate.

float	getV () const
	Get v coordinate.

float	getUVariance () const
	Get u coordinate variance.

float	getVVariance () const
	Get v coordinate variance.

float	getUVCov () const
	Get u-v error covariance.

float	getEnergyDep () const
	Get deposited energy.

float	getShapeLikelyhood (const genfit::StateOnPlane &state) const
	Get deposited energy error.

virtual const genfit::AbsHMatrix *	constructHMatrix (const genfit::AbsTrackRep *) const override
	Construct the hessian matrix.

Static Public Attributes
static bool	s_enableLorentzGlobalDerivatives = false
	Static enabling(true) or disabling(false) addition of global derivatives for Lorentz shift.

Private Types
enum	{ HIT_DIMENSIONS = 2 }

Private Member Functions
	ClassDefOverride (AlignablePXDRecoHit, 4)
	PXD RecoHit extended for alignment/calibration.

void	setDetectorPlane ()
	Set up Detector plane information.

TVectorD	applyPlanarDeformation (TVectorD hitCoords, std::vector< double > planarParameters, const genfit::StateOnPlane &state) const
	Apply planar deformation of sensors.

Private Attributes
const PXDTrueHit *	m_trueHit
	Pointer to the TrueHit used when creating this object.

const PXDCluster *	m_cluster
	transient member (not written out during streaming)

float	m_energyDep
	transient member (not written out during streaming)

unsigned short	m_sensorID
	Unique sensor identifier.

Friends
class	PXDRecoHit

Detailed Description

This class is used to transfer PXD information to the track fit.

Definition at line 28 of file AlignablePXDRecoHit.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

privateinherited

Enumerator
HIT_DIMENSIONS	sensitive Dimensions of the Hit

Definition at line 138 of file PXDRecoHit.h.

138{ HIT_DIMENSIONS = 2 };

Constructor & Destructor Documentation

◆ ~AlignablePXDRecoHit()

virtual ~AlignablePXDRecoHit ( )

inlinevirtual

Destructor.

Definition at line 38 of file AlignablePXDRecoHit.h.

38{}

Member Function Documentation

◆ applyPlanarDeformation()

TVectorD applyPlanarDeformation	(	TVectorD	hitCoords,
		std::vector< double >	planarParameters,
		const genfit::StateOnPlane &	state ) const

privateinherited

Apply planar deformation of sensors.

Definition at line 149 of file PXDRecoHit.cc.

{
  // Legendre parametrization of deformation
  auto L1 = [](double x) {return x;};
  auto L2 = [](double x) {return (3 * x * x - 1) / 2;};
  auto L3 = [](double x) {return (5 * x * x * x - 3 * x) / 2;};
  auto L4 = [](double x) {return (35 * x * x * x * x - 30 * x * x + 3) / 8;};
 
  const PXD::SensorInfo& geometry = dynamic_cast<const PXD::SensorInfo&>(VXD::GeoCache::getInstance().getSensorInfo(m_sensorID));
 
  double u = hitCoords[0];
  double v = hitCoords[1];
  double width = geometry.getWidth(v);              // Width of sensor (U side)
  double length = geometry.getLength();             // Length of sensor (V side)
  u = u * 2 / width;                                // Legendre parametrization required U in (-1, 1)
  v = v * 2 / length;                               // Legendre parametrization required V in (-1, 1)
 
  /* Planar deformation using Legendre parametrization
     w(u, v) = L_{31} * L2(u) + L_{32} * L1(u) * L1(v) + L_{33} * L2(v) +
               L_{41} * L3(u) + L_{42} * L2(u) * L1(v) + L_{43} * L1(u) * L2(v) + L_{44} * L3(v) +
               L_{51} * L4(u) + L_{52} * L3(u) * L1(v) + L_{53} * L2(u) * L2(v) + L_{54} * L1(u) * L3(v) + L_{55} * L4(v); */
  double dw =
    planarParameters[0] * L2(u) + planarParameters[1] * L1(u) * L1(v) + planarParameters[2] * L2(v) +
    planarParameters[3] * L3(u) + planarParameters[4] * L2(u) * L1(v) + planarParameters[5] * L1(u) * L2(v) + planarParameters[6] * L3(
      v) +
    planarParameters[7] * L4(u) + planarParameters[8] * L3(u) * L1(v) + planarParameters[9] * L2(u) * L2(v) + planarParameters[10] * L1(
      u) * L3(v) + planarParameters[11] * L4(v);
 
  double du_dw = state.getState()[1]; // slope in U direction
  double dv_dw = state.getState()[2]; // slope in V direction
 
  u = u * width / 2;  // from Legendre to Local parametrization
  v = v * length / 2; // from Legendre to Local parametrization
 
  TVectorD pos(2);
 
  pos[0] = u + dw * du_dw;
  pos[1] = v + dw * dv_dw;
 
  return pos;
}

◆ clone()

genfit::AbsMeasurement * clone ( ) const

inlineoverride

Creating a deep copy of this hit.

Definition at line 41 of file AlignablePXDRecoHit.h.

    {
      return new AlignablePXDRecoHit(*this);
    }

◆ constructHMatrix()

virtual const genfit::AbsHMatrix * constructHMatrix ( const genfit::AbsTrackRep * ) const

inlineoverridevirtualinherited

Construct the hessian matrix.

Definition at line 134 of file PXDRecoHit.h.

134{ return new genfit::HMatrixUV(); };

◆ constructMeasurementsOnPlane()

std::vector< genfit::MeasurementOnPlane * > constructMeasurementsOnPlane ( const genfit::StateOnPlane & state ) const

overridevirtualinherited

Methods that actually interface to Genfit.

Definition at line 192 of file PXDRecoHit.cc.

{
  // Track-based update only takes place when the RecoHit has an associated cluster
  if (this->getCluster()) {
    // Check if we can correct position coordinates based on track info
    const TVectorD& state5 = state.getState();
    auto offset = PXD::PXDClusterPositionEstimator::getInstance().getClusterOffset(*this->getCluster(), state5[1], state5[2]);
 
    if (offset != nullptr) {
      // Found a valid offset, lets apply it
      const Belle2::VxdID& sensorID = (*this->getCluster()).getSensorID();
      const Belle2::PXD::SensorInfo& Info = dynamic_cast<const Belle2::PXD::SensorInfo&>(VXD::GeoCache::getInstance().getSensorInfo(
                                              sensorID));
      double posU = Info.getUCellPosition((*this->getCluster()).getUStart());
      double posV = Info.getVCellPosition((*this->getCluster()).getVStart());
 
      TVectorD hitCoords(2);
      hitCoords(0) = posU + offset->getU();
      hitCoords(1) = posV + offset->getV();
      TMatrixDSym hitCov(2);
      hitCov(0, 0) = offset->getUSigma2();
      hitCov(0, 1) = offset->getUVCovariance();
      hitCov(1, 0) = offset->getUVCovariance();
      hitCov(1, 1) = offset->getVSigma2();
 
      // Apply planar deformation
      TVectorD pos = applyPlanarDeformation(hitCoords, VXD::GeoCache::getInstance().getSensorInfo(m_sensorID).getSurfaceParameters(),
                                            state);
 
      return std::vector<genfit::MeasurementOnPlane*>(1, new genfit::MeasurementOnPlane(
                                                        pos, hitCov, state.getPlane(), state.getRep(), this->constructHMatrix(state.getRep())
                                                      ));
    }
  }
 
  // Apply planar deformation
  TVectorD pos = applyPlanarDeformation(rawHitCoords_, VXD::GeoCache::getInstance().getSensorInfo(m_sensorID).getSurfaceParameters(),
                                        state);
 
  // If we reach here, we can do no better than what we have
  return std::vector<genfit::MeasurementOnPlane*>(1, new genfit::MeasurementOnPlane(
                                                    pos, rawHitCov_, state.getPlane(), state.getRep(), this->constructHMatrix(state.getRep())
                                                  ));
}

◆ getCluster()

const PXDCluster * getCluster ( ) const

inlineinherited

Get pointer to the Cluster used when creating this RecoHit, can be NULL if created from something else.

Definition at line 110 of file PXDRecoHit.h.

110{ return m_cluster; }

◆ getEnergyDep()

float getEnergyDep ( ) const

inlineinherited

Get deposited energy.

Definition at line 125 of file PXDRecoHit.h.

125{ return m_energyDep; }

◆ getSensorID()

VxdID getSensorID ( ) const

inlineinherited

Get the compact ID.

Definition at line 105 of file PXDRecoHit.h.

105{ return m_sensorID; }

◆ getShapeLikelyhood()

float getShapeLikelyhood ( const genfit::StateOnPlane & state ) const

inherited

Get deposited energy error.

Get the likelihood that cluster shape is likely to be created from track state.

Definition at line 137 of file PXDRecoHit.cc.

{
  // We need an associated cluster
  if (this->getCluster()) {
    // Likelihood depends on the fitted incidence angles into the sensor
    const TVectorD& state5 = state.getState();
    return PXD::PXDClusterPositionEstimator::getInstance().getShapeLikelyhood(*this->getCluster(), state5[1], state5[2]);
  }
  // If we reach here, we can do no better than return zero
  return 0;
}

◆ getTrueHit()

const PXDTrueHit * getTrueHit ( ) const

inlineinherited

Get pointer to the TrueHit used when creating this RecoHit, can be NULL if created from something else.

Definition at line 108 of file PXDRecoHit.h.

108{ return m_trueHit; }

◆ getU()

float getU ( ) const

inlineinherited

Get u coordinate.

Definition at line 113 of file PXDRecoHit.h.

113{ return rawHitCoords_(0); }

◆ getUVariance()

float getUVariance ( ) const

inlineinherited

Get u coordinate variance.

Definition at line 118 of file PXDRecoHit.h.

118{ return rawHitCov_(0, 0); }

◆ getUVCov()

float getUVCov ( ) const

inlineinherited

Get u-v error covariance.

Definition at line 122 of file PXDRecoHit.h.

122{ return rawHitCov_(0, 1); }

◆ getV()

float getV ( ) const

inlineinherited

Get v coordinate.

Definition at line 115 of file PXDRecoHit.h.

115{ return rawHitCoords_(1); }

◆ getVVariance()

float getVVariance ( ) const

inlineinherited

Get v coordinate variance.

Definition at line 120 of file PXDRecoHit.h.

120{ return rawHitCov_(1, 1); }

◆ globalDerivatives()

std::pair< std::vector< int >, TMatrixD > globalDerivatives ( const genfit::StateOnPlane * sop )

overridevirtual

Labels and derivatives of residuals (local measurement coordinates) w.r.t.

alignment/calibration parameters Matrix "G" of derivatives valid for given prediction of track state:

G(i, j) = d_residual_i/d_parameter_j

For 2D measurement (u,v):

G = ( du/da du/db du/dc ... ) ( dv/da dv/db dv/dc ... )

for calibration parameters a, b, c.

For 1D measurement:

G = ( 0 0 0 ... ) ( dv/da dv/db dv/dc ... ) for V-strip,

G = ( du/da du/db du/dc ... ) ( 0 0 0 ... ) for U-strip,

Measurements with more dimensions (slopes, curvature) should provide full 4-5Dx(n params) matrix (state as (q/p, u', v', u, v) or (u', v', u, v))

Parameters

sop	Predicted state of the track as linearization point around which derivatives of alignment/calibration parameters shall be computed

Returns: pair<vector<int>, TMatrixD> With matrix with number of rows = dimension of residual, number of columns = number of parameters. number of columns must match vector<int>.size().

Definition at line 25 of file AlignablePXDRecoHit.cc.

{
  auto alignment = GlobalCalibrationManager::getInstance().getAlignmentHierarchy().getGlobalDerivatives<VXDAlignment>(getPlaneId(),
                   sop);
 
  auto globals = GlobalDerivatives(alignment);
 
  if (s_enableLorentzGlobalDerivatives) {
    auto lorentz = GlobalCalibrationManager::getInstance().getLorentzShiftHierarchy().getGlobalDerivatives<VXDAlignment>(getPlaneId(),
                   sop, BFieldManager::getInstance().getField(ROOT::Math::XYZVector(sop->getPos())));
    globals.add(lorentz);
  }
 
  const PXD::SensorInfo& geometry = dynamic_cast<const PXD::SensorInfo&>(VXD::GeoCache::getInstance().getSensorInfo(getSensorID()));
 
  // Legendre parametrization of deformation
  auto L1 = [](double x) {return x;};
  auto L2 = [](double x) {return (3 * x * x - 1) / 2;};
  auto L3 = [](double x) {return (5 * x * x * x - 3 * x) / 2;};
  auto L4 = [](double x) {return (35 * x * x * x * x - 30 * x * x + 3) / 8;};
 
  double du_dw = sop->getState()[1];       // slope in U direction
  double dv_dw = sop->getState()[2];       // slope in V direction
  double u = getU();                       // U coordinate of hit
  double v = getV();                       // V coordinate of hit
  double width = geometry.getWidth(v);     // Width of sensor (U side)
  double length = geometry.getLength();    // Length of sensor (V side)
  u = u * 2 / width;                       // Legendre parametrization required U in (-1, 1)
  v = v * 2 / length;                      // Legendre parametrization required V in (-1, 1)
 
  // Add parameters of surface deformation to alignment
  // Numbering of VXD alignment parameters:
  //  -> 0-6:   Rigid body alignment
  //  -> 31-33: First level of surface deformation
  //  -> 41-44: Second level of surface deformation
  //  -> 51-55: Third level of surface deformation
  globals.add(GlobalLabel::construct<VXDAlignment>(getSensorID(), 31), std::vector<double> {L2(u)*du_dw,       L2(u)*dv_dw});
  globals.add(GlobalLabel::construct<VXDAlignment>(getSensorID(), 32), std::vector<double> {L1(u)*L1(v)*du_dw, L1(u)*L1(v)*dv_dw});
  globals.add(GlobalLabel::construct<VXDAlignment>(getSensorID(), 33), std::vector<double> {L2(v)*du_dw,       L2(v)*dv_dw});
 
  globals.add(GlobalLabel::construct<VXDAlignment>(getSensorID(), 41), std::vector<double> {L3(u)*du_dw,       L3(u)*dv_dw});
  globals.add(GlobalLabel::construct<VXDAlignment>(getSensorID(), 42), std::vector<double> {L2(u)*L1(v)*du_dw, L2(u)*L1(v)*dv_dw});
  globals.add(GlobalLabel::construct<VXDAlignment>(getSensorID(), 43), std::vector<double> {L1(u)*L2(v)*du_dw, L1(u)*L2(v)*dv_dw});
  globals.add(GlobalLabel::construct<VXDAlignment>(getSensorID(), 44), std::vector<double> {L3(v)*du_dw,       L3(v)*dv_dw});
 
  globals.add(GlobalLabel::construct<VXDAlignment>(getSensorID(), 51), std::vector<double> {L4(u)*du_dw,       L4(u)*dv_dw});
  globals.add(GlobalLabel::construct<VXDAlignment>(getSensorID(), 52), std::vector<double> {L3(u)*L1(v)*du_dw, L3(u)*L1(v)*dv_dw});
  globals.add(GlobalLabel::construct<VXDAlignment>(getSensorID(), 53), std::vector<double> {L2(u)*L2(v)*du_dw, L2(u)*L2(v)*dv_dw});
  globals.add(GlobalLabel::construct<VXDAlignment>(getSensorID(), 54), std::vector<double> {L1(u)*L3(v)*du_dw, L1(u)*L3(v)*dv_dw});
  globals.add(GlobalLabel::construct<VXDAlignment>(getSensorID(), 55), std::vector<double> {L4(v)*du_dw,       L4(v)*dv_dw});
 
  return GlobalDerivatives(globals);
}

◆ PXDRecoHit() [1/3]

PXDRecoHit	(	const PXDCluster *	hit,
		const genfit::TrackCandHit *	trackCandHit = NULL )

explicit

Inherit constructors.

Definition at line 95 of file PXDRecoHit.cc.

                                                                      :
  genfit::PlanarMeasurement(HIT_DIMENSIONS), m_trueHit(0), m_cluster(hit),
  m_energyDep(0), m_sensorID(0)//, m_energyDepError(0)
{
  // Set the sensor UID
  m_sensorID = hit->getSensorID();
  // Set positions
  rawHitCoords_(0) = hit->getU();
  rawHitCoords_(1) = hit->getV();
  // Set the error covariance matrix
  rawHitCov_(0, 0) = hit->getUSigma() * hit->getUSigma();
  rawHitCov_(0, 1) = hit->getRho() * hit->getUSigma() * hit->getVSigma();
  rawHitCov_(1, 0) = hit->getRho() * hit->getUSigma() * hit->getVSigma();
  rawHitCov_(1, 1) = hit->getVSigma() * hit->getVSigma();
  // Set physical parameters
  const PXD::SensorInfo& SensorInfo = dynamic_cast<const PXD::SensorInfo&>(VXD::GeoCache::getInstance().getSensorInfo(m_sensorID));
  auto ADUToEnergy = PXD::PXDGainCalibrator::getInstance().getADUToEnergy(m_sensorID, SensorInfo.getUCellID(hit->getU()),
                     SensorInfo.getVCellID(hit->getV()));
  m_energyDep = hit->getCharge() * ADUToEnergy;
  //m_energyDepError = 0;
  // Setup geometry information
  setDetectorPlane();
}

◆ PXDRecoHit() [2/3]

PXDRecoHit	(	const PXDCluster *	hit,
		float	sigmaU,
		float	sigmaV,
		float	covUV )

explicit

Inherit constructors.

Definition at line 82 of file PXDRecoHit.cc.

                                                                                    :
  genfit::PlanarMeasurement(HIT_DIMENSIONS), m_trueHit(0), m_cluster(hit),
  m_energyDep(0), m_sensorID(0)//, m_energyDepError(0)
{
  // Set the sensor UID
  m_sensorID = hit->getSensorID();
  // Set positions
  rawHitCoords_(0) = hit->getU();
  rawHitCoords_(1) = hit->getV();
  // Set the error covariance matrix
  rawHitCov_(0, 0) = sigmaU * sigmaU;
  rawHitCov_(0, 1) = covUV;
  rawHitCov_(1, 0) = covUV;
  rawHitCov_(1, 1) = sigmaV * sigmaV;
  // Set physical parameters
  const PXD::SensorInfo& SensorInfo = dynamic_cast<const PXD::SensorInfo&>(VXD::GeoCache::getInstance().getSensorInfo(m_sensorID));
  auto ADUToEnergy = PXD::PXDGainCalibrator::getInstance().getADUToEnergy(m_sensorID, SensorInfo.getUCellID(hit->getU()),
                     SensorInfo.getVCellID(hit->getV()));
  m_energyDep = hit->getCharge() * ADUToEnergy;
  //m_energyDepError = 0;
  // Setup geometry information
  setDetectorPlane();
}

◆ PXDRecoHit() [3/3]

PXDRecoHit	(	const PXDTrueHit *	hit,
		const genfit::TrackCandHit *	trackCandHit = NULL,
		float	sigmaU = -1,
		float	sigmaV = -1 )

explicit

Inherit constructors.

Definition at line 72 of file PXDRecoHit.cc.

                                                                                                  :
  genfit::PlanarMeasurement(HIT_DIMENSIONS), m_trueHit(hit), m_cluster(0),
  m_energyDep(0), m_sensorID(0)//, m_energyDepError(0)
{
  if (!gRandom) B2FATAL("gRandom not initialized, please set up gRandom first");
 
  // Set the sensor UID
  m_sensorID = hit->getSensorID();
 
  //If no error is given, estimate the error by dividing the pixel size by sqrt(12)
  if (sigmaU < 0 || sigmaV < 0) {
    const PXD::SensorInfo& geometry = dynamic_cast<const PXD::SensorInfo&>(VXD::GeoCache::getInstance().getSensorInfo(m_sensorID));
    sigmaU = geometry.getUPitch(hit->getV()) / sqrt(12);
    sigmaV = geometry.getVPitch(hit->getV()) / sqrt(12);
  }
 
  // Set positions
  rawHitCoords_(0) = gRandom->Gaus(hit->getU(), sigmaU);
  rawHitCoords_(1) = gRandom->Gaus(hit->getV(), sigmaV);
  // Set the error covariance matrix
  rawHitCov_(0, 0) = sigmaU * sigmaU;
  rawHitCov_(0, 1) = 0;
  rawHitCov_(1, 0) = 0;
  rawHitCov_(1, 1) = sigmaV * sigmaV;
  // Set physical parameters
  m_energyDep = hit->getEnergyDep();
  // Setup geometry information
  setDetectorPlane();
}

◆ setDetectorPlane()

void setDetectorPlane ( )

privateinherited

Set up Detector plane information.

Definition at line 117 of file PXDRecoHit.cc.

{
  // Construct a finite detector plane and set it.
  const PXD::SensorInfo& geometry = dynamic_cast<const PXD::SensorInfo&>(VXD::GeoCache::getInstance().getSensorInfo(m_sensorID));
 
  // Construct vectors o, u, v
  ROOT::Math::XYZVector uLocal(1, 0, 0);
  ROOT::Math::XYZVector vLocal(0, 1, 0);
  ROOT::Math::XYZVector origin  = geometry.pointToGlobal(ROOT::Math::XYZVector(0, 0, 0), true);
  ROOT::Math::XYZVector uGlobal = geometry.vectorToGlobal(uLocal, true);
  ROOT::Math::XYZVector vGlobal = geometry.vectorToGlobal(vLocal, true);
 
  //Construct the detector plane
  VXD::SensorPlane* finitePlane = new VXD::SensorPlane(m_sensorID, 20.0, 20.0);
  genfit::SharedPlanePtr detPlane(new genfit::DetPlane(XYZToTVector(origin), XYZToTVector(uGlobal), XYZToTVector(vGlobal),
                                                       finitePlane));
  setPlane(detPlane, m_sensorID);
}

Friends And Related Symbol Documentation

◆ PXDRecoHit

friend class PXDRecoHit

friend

Definition at line 29 of file AlignablePXDRecoHit.h.

Member Data Documentation

◆ m_cluster

const PXDCluster* m_cluster

privateinherited

transient member (not written out during streaming)

Pointer to the Cluster used when creating this object

Definition at line 143 of file PXDRecoHit.h.

◆ m_energyDep

float m_energyDep

privateinherited

transient member (not written out during streaming)

deposited energy.

Definition at line 144 of file PXDRecoHit.h.

◆ m_sensorID

unsigned short m_sensorID

privateinherited

Unique sensor identifier.

Definition at line 147 of file PXDRecoHit.h.

◆ m_trueHit

const PXDTrueHit* m_trueHit

privateinherited

Pointer to the TrueHit used when creating this object.

Definition at line 141 of file PXDRecoHit.h.

◆ s_enableLorentzGlobalDerivatives

bool s_enableLorentzGlobalDerivatives = false

static

Static enabling(true) or disabling(false) addition of global derivatives for Lorentz shift.

Definition at line 32 of file AlignablePXDRecoHit.h.

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

alignment/reconstruction/include/AlignablePXDRecoHit.h
alignment/reconstruction/src/AlignablePXDRecoHit.cc

Public Member Functions

Static Public Attributes

Private Types

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ ~AlignablePXDRecoHit()

Member Function Documentation

◆ applyPlanarDeformation()

◆ clone()

◆ constructHMatrix()

◆ constructMeasurementsOnPlane()

◆ getCluster()

◆ getEnergyDep()

◆ getSensorID()

◆ getShapeLikelyhood()

◆ getTrueHit()

◆ getU()

◆ getUVariance()

◆ getUVCov()

◆ getV()

◆ getVVariance()

◆ globalDerivatives()

◆ PXDRecoHit() [1/3]

◆ PXDRecoHit() [2/3]

◆ PXDRecoHit() [3/3]

◆ setDetectorPlane()

Friends And Related Symbol Documentation

◆ PXDRecoHit

Member Data Documentation

◆ m_cluster

◆ m_energyDep

◆ m_sensorID

◆ m_trueHit

◆ s_enableLorentzGlobalDerivatives