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

#include <AlignablePXDRecoHit.h>

Inheritance diagram for AlignablePXDRecoHit:

[legend]

Collaboration diagram for AlignablePXDRecoHit:

[legend]

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. More...

	PXDRecoHit ()
	Inherit constructors.

	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. More...

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. More...

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

int	getPlaneId () const

virtual SharedPlanePtr	constructPlane (const StateOnPlane &state) const override
	Construct (virtual) detector plane (use state's AbsTrackRep). More...

virtual void	setPlane (const SharedPlanePtr &physicalPlane, int planeId=-1)

void	setStripV (bool v=true)
	Use if the coordinate for 1D hits measured in V direction. More...

TrackPoint *	getTrackPoint () const

void	setTrackPoint (TrackPoint *tp)

const TVectorD &	getRawHitCoords () const

TVectorD &	getRawHitCoords ()

const TMatrixDSym &	getRawHitCov () const

TMatrixDSym &	getRawHitCov ()

int	getDetId () const

int	getHitId () const

virtual bool	isLeftRightMeasurement () const
	If the AbsMeasurement is a wire hit, the left/right resolution will be used.

virtual int	getLeftRightResolution () const

unsigned int	getDim () const

void	setRawHitCoords (const TVectorD &coords)

void	setRawHitCov (const TMatrixDSym &cov)

void	setDetId (int detId)

void	setHitId (int hitId)

virtual void	Print (const Option_t *="") const

virtual std::vector< int >	labels ()
	Vector of integer labels for calibration/alignment parameters available (must match #columns of derivatives(...)) More...

virtual TMatrixD	derivatives (const genfit::StateOnPlane *)
	Derivatives of residuals (local measurement coordinates) w.r.t. More...

virtual TMatrixD	localDerivatives (const genfit::StateOnPlane *)
	Derivatives for additional local parameters to be fitted in global calibration algorithms together with with global parameters. More...

virtual std::vector< int >	localLabels ()
	Vector of integer labels for local calibration parameters available (must match #columns of localDerivatives(...)) More...

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

Protected Attributes
SharedPlanePtr	physicalPlane_

int	planeId_
	This is persistent, but '!' makes ROOT shut up.

bool	stripV_

TVectorD	rawHitCoords_

TMatrixDSym	rawHitCov_

int	detId_

int	hitId_

TrackPoint *	trackPoint_
	Pointer to TrackPoint where the measurement belongs to.

Private Types
enum	{ HIT_DIMENSIONS = 2 }

Private Member Functions
	ClassDefOverride (AlignablePXDRecoHit, 3)
	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
unsigned short	m_sensorID
	Unique sensor identifier.

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

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

float	m_energyDep
	transient member (not written out during streaming) More...

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 134 of file PXDRecoHit.h.

134 { HIT_DIMENSIONS = 2 };

Belle2::PXDRecoHit::HIT_DIMENSIONS

@ HIT_DIMENSIONS

sensitive Dimensions of the Hit

Definition: PXDRecoHit.h:134

Member Function Documentation

◆ constructMeasurementsOnPlane()

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

overridevirtualinherited

Methods that actually interface to Genfit.

Reimplemented from PlanarMeasurement.

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::get(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::get(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::get(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())
                                                   ));
 }

◆ constructPlane()

SharedPlanePtr constructPlane ( const StateOnPlane & state ) const

overridevirtualinherited

Construct (virtual) detector plane (use state's AbsTrackRep).

It's possible to make corrections to the plane here. The state should be defined somewhere near the measurement. For virtual planes, the state will be extrapolated to the POCA to point (SpacepointMeasurement) or line (WireMeasurement), and from this info the plane will be constructed.

Implements AbsMeasurement.

Definition at line 46 of file PlanarMeasurement.cc.

◆ derivatives()

virtual TMatrixD derivatives ( const genfit::StateOnPlane * )

inlinevirtualinherited

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 both forms are allowed:

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,

or :

G = ( d_sensitive/da d_sensitive/db d_sensitive/dc ... ) as matrix with one row.

A possible algorithm using these derivatives should be able to resolve this based on the measurement HMatrix. Measurements with more dimesions (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: TMatrixD Matrix with #rows = dimension of residual, #columns = number of parameters. #columns must match labels().size().

Definition at line 129 of file ICalibrationParametersDerivatives.h.

◆ getShapeLikelyhood()

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

inherited

Get deposited energy error.

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

Definition at line 137 of file PXDRecoHit.cc.

◆ 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 dimesions (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().

Reimplemented from ICalibrationParametersDerivatives.

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::get(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);
 }

◆ labels()

virtual std::vector<int> labels ( )

inlinevirtualinherited

Vector of integer labels for calibration/alignment parameters available (must match #columns of derivatives(...))

unique across all sub-detectors in calibration

Returns: std::vector< int > Vector of integer labels

Definition at line 90 of file ICalibrationParametersDerivatives.h.

◆ localDerivatives()

virtual TMatrixD localDerivatives ( const genfit::StateOnPlane * )

inlinevirtualinherited

Derivatives for additional local parameters to be fitted in global calibration algorithms together with with global parameters.

Local parameters are not neccesarily identified by label because their number is proportional to number of measurements included in calibration (possibly very huge number!)

Returns: TMatrixD Matrix in form d_residual_i/d_parameter_j

Reimplemented in AlignableCDCRecoHit.

Definition at line 141 of file ICalibrationParametersDerivatives.h.

◆ localLabels()

virtual std::vector<int> localLabels ( )

inlinevirtualinherited

Vector of integer labels for local calibration parameters available (must match #columns of localDerivatives(...))

This will be usually ignored (e.g. does not have to match localDerivatives), but it is a good practice to return vector of zeros of correct size

Returns: std::vector< int > Vector of integer labels

Definition at line 151 of file ICalibrationParametersDerivatives.h.

◆ setStripV()

void setStripV ( bool v = true )

inlineinherited

Use if the coordinate for 1D hits measured in V direction.

Per default for 1D planar hits, the coordinate is measured in U direction. With this function you can set it to be measured in V direction. This affects the outcoe of constructHMatrix().

Definition at line 70 of file PlanarMeasurement.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 140 of file PXDRecoHit.h.

◆ m_energyDep

float m_energyDep

privateinherited

transient member (not written out during streaming)

deposited energy.

Definition at line 141 of file PXDRecoHit.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

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Enumeration Documentation

◆ anonymous enum

Member Function Documentation

◆ constructMeasurementsOnPlane()

◆ constructPlane()

◆ derivatives()

◆ getShapeLikelyhood()

◆ globalDerivatives()

◆ labels()

◆ localDerivatives()

◆ localLabels()

◆ setStripV()

Member Data Documentation

◆ m_cluster

◆ m_energyDep