ROIFinder Class Reference

Findlet for performing the simple SVDHoughTracking ROI calculation. More...

#include <ROIFinder.h>

Inheritance diagram for ROIFinder:

Collaboration diagram for ROIFinder:

Public Types
using	IOTypes = std::tuple< AIOTypes... >
	Types that should be served to apply on invokation.
using	IOVectors = std::tuple< std::vector< AIOTypes >... >
	Vector types that should be served to apply on invokation.

Public Member Functions
	ROIFinder ()
	Constructor for adding the subfindlets.
	~ROIFinder ()
	Default desctructor.
void	exposeParameters (ModuleParamList *moduleParamList, const std::string &prefix) override
	Expose the parameters of the sub findlets.
void	apply (const std::vector< SpacePointTrackCand > &finalTracks) override
	Function to call all the sub-findlets. More...
void	initialize () override
	Initialize the StoreArrays. More...
void	beginRun () override
	Initialize the BField.
void	beginEvent () override
	Clear the object pools.
virtual std::string	getDescription ()
	Brief description of the purpose of the concret findlet.
virtual void	apply (ToVector< AIOTypes > &... ioVectors)=0
	Main function executing the algorithm.
void	endRun () override
	Receive and dispatch signal for the end of the run.
void	terminate () override
	Receive and dispatch Signal for termination of the event processing.

Protected Types
using	ToVector = typename ToVectorImpl< T >::Type
	Short hand for ToRangeImpl.

Protected Member Functions
void	addProcessingSignalListener (ProcessingSignalListener *psl)
	Register a processing signal listener to be notified.
int	getNProcessingSignalListener ()
	Get the number of currently registered listeners.

Private Types
using	Super = TrackFindingCDC::Findlet< const SpacePointTrackCand >
	Parent class.

Private Attributes
bool	m_calculateROI = false
	Calculate ROI in this findlet?
std::string	m_storePXDInterceptsName = "SVDHoughPXDIntercepts"
	Name of the PXDIntercepts StoreArray.
std::string	m_storeROIsName = "SVDHoughROIs"
	Name of the ROIs StoreArray.
StoreArray< PXDIntercept >	m_storePXDIntercepts
	PXDIntercepts StoreArray.
StoreArray< ROIid >	m_storeROIs
	ROIs StoreArray.
bool	m_refit = true
	Refit the tracks with m_ROIFitMethod.
bool	m_addVirtualIP = true
	Add a virtual IP for the refit?
std::string	m_ROIFitMethod = "helixFit"
	Refit with this estimator, options are circleFit, tripletFit, helixFit.
std::unique_ptr< QualityEstimatorBase >	m_estimator
	pointer to the selected QualityEstimator
double	m_tolerancePhi = 0.15
	Allowed tolerance (in radians) phi to create intercepts per sensor.
double	m_toleranceZ = 0.5
	Allowed tolerance (in cm) in z to create intercepts per sensor.
double	m_radiusCorrectionFactorL1 = -2.0
	Correction factor for radial bias for L1: factor * charge / radius.
double	m_radiusCorrectionFactorL2 = -5.0
	Correction factor for radial bias for L2: factor * charge / radius.
double	m_sinPhiCorrectionFactor = 0.0
	Correction factor for the sin(phi) modulation.
double	m_cosPhiCorrectionFactor = 0.0
	Correction factor for the cos(phi) modulation.
double	m_zPositionCorrectionFactor = 1.0
	Correction factor for the z position.
double	m_minimumROISizeUL1 = 40
	Minimum size of ROI in u-direction on L1 in pixel.
double	m_minimumROISizeVL1 = 40
	Minimum size of ROI in v-direction on L1 in pixel.
double	m_minimumROISizeUL2 = 35
	Minimum size of ROI in u-direction on L2 in pixel.
double	m_minimumROISizeVL2 = 30
	Minimum size of ROI in v-direction on L2 in pixel.
double	m_multiplierUL1 = 500
	Multiplier term in ROI size estimation For u: size = multiplier * 1/R + minimumROISize For v: size = (1 + abs(tan(lambda)) * multiplier) + minimumROISize Multiplier term for u-direction on L1.
double	m_multiplierUL2 = 600
	Multiplier term for u-direction on L2.
double	m_multiplierVL1 = 0.8
	Multiplier term for v-direction on L1.
double	m_multiplierVL2 = 0.8
	Multiplier term for v-direction on L2.
unsigned short	m_maximumROISizeU = 100
	maximum ROI size in u in pixel
unsigned short	m_maximumROISizeV = 100
	maximum ROI size in v in pixel
const double	c_centerZShiftLayer1 [2] = {3.68255, -0.88255}
	Shift of the center of the active area of each sensor in a ladder of layer 1 For use of mhp_z > (lengh/-2)+shiftZ && mhp_z < (lengh/2)+shiftZ.
const double	c_centerZShiftLayer2 [2] = {5.01455, -1.21455}
	Shift of the center of the active area of each sensor in a ladder of layer 2 For use of mhp_z > (lengh/-2)+shiftZ && mhp_z < (lengh/2)+shiftZ.
const double	c_sensorMinY = -0.36
	PXD is shifted to create the windmill structure. More...
const double	c_sensorMaxY = 0.89
	Maximum y coordinate if x-axis is perpendicular to the sensor:
const double	c_activeSensorWidth = (c_sensorMaxY - c_sensorMinY)
	PXD sensors in L1 and L2 have the same size in u direction (=width):
const double	c_shiftY = (c_sensorMaxY + c_sensorMinY) / 2.0
	Shift of the center position in y if the x-axis is perpendicular to the sensor:
const double	c_layerRadius [2] = {1.42854, 2.21218}
	Radius of the two layers.
const double	c_activeSensorLength [2] = {4.48, 6.144}
	Length of the active region for L1 and L2.
const double	c_ladderPhiL1 [8] = {0., 0.25 * M_PI, M_PI_2, 0.75 * M_PI, M_PI, -0.75 * M_PI, -M_PI_2, -0.25 * M_PI}
	Phi values of the ladders of L1.
const double	c_ladderPhiL2 [12] = {0., 1. / 6. * M_PI, 1. / 3. * M_PI, M_PI_2, 2. / 3. * M_PI, 5. / 6. * M_PI, M_PI, -5. / 6. * M_PI, -2. / 3. * M_PI, -M_PI_2, -1. / 3. * M_PI, -1. / 6. * M_PI}
	Phi values of the ladders of L2.
double	m_bFieldZ = 1.5
	BField in Tesla.
B2Vector3D	m_BeamSpotPosition
	B2Vector3D actually contining the BeamSpot position. This will be used as the starting point of the extrapolation.
B2Vector3D	m_BeamSpotPositionError
	B2Vector3D actually contining the BeamSpot position error.
std::vector< ProcessingSignalListener * >	m_subordinaryProcessingSignalListeners
	References to subordinary signal processing listener contained in this findlet.
bool	m_initialized = false
	Flag to keep track whether initialization happend before.
bool	m_terminated = false
	Flag to keep track whether termination happend before.
std::string	m_initializedAs
	Name of the type during initialisation.

Detailed Description

Findlet for performing the simple SVDHoughTracking ROI calculation.

Definition at line 33 of file ROIFinder.h.

Member Function Documentation

apply()

void apply ( const std::vector< SpacePointTrackCand > &  finalTracks )

override

Function to call all the sub-findlets.

Loop over both PXD layer

Loop over all ladders of layer

Loop over both modules of a ladder

Lower left corner

Upper right corner

Definition at line 179 of file ROIFinder.cc.

{
  // If no ROIs shall be calculated, return rightaway and don't do anything
  if (not m_calculateROI) {
    return;
  }
 
  for (auto& track : finalTracks) {
    // do nothing if the SpacePointTrackCand is not active
    if (!track.hasRefereeStatus(SpacePointTrackCand::c_isActive)) {
      continue;
    }
 
    QualityEstimationResults refittedTrackEstimate;
    if (m_refit) {
      auto sortedHits = track.getSortedHits();
 
      if (m_addVirtualIP) {
        SpacePoint virtualIPSpacePoint = SpacePoint(m_BeamSpotPosition, m_BeamSpotPositionError, {0.5, 0.5}, {false, false},
                                                    VxdID(0), Belle2::VXD::SensorInfoBase::VXD);
        sortedHits.push_back(&virtualIPSpacePoint);
      }
 
      std::sort(sortedHits.begin(), sortedHits.end(),
      [](const SpacePoint * a, const SpacePoint * b) {return a->getPosition().Perp() < b->getPosition().Perp(); });
 
      refittedTrackEstimate = m_estimator->estimateQualityAndProperties(sortedHits);
    }
 
    std::vector<PXDIntercept> thisTracksIntercepts;
    thisTracksIntercepts.reserve(8);
 
    B2Vector3D momentumEstimate = track.getMomSeed();
    if (m_refit) {
      momentumEstimate = *refittedTrackEstimate.p;
    }
 
    const double trackPhi       = momentumEstimate.Phi();
    const double trackTheta     = momentumEstimate.Theta();
    const double tanTrackLambda = tan(M_PI_2 - trackTheta);
    const double trackRadius    = momentumEstimate.Perp() / (0.00299792458 * m_bFieldZ) ;
    const double trackCharge    = track.getChargeSeed();
 
    for (int layer = 1; layer <= 2; layer++) {
      const double sensorPerpRadius = c_layerRadius[layer - 1];
 
      for (int ladder = 1; ladder <= (layer == 1 ? 8 : 12); ladder++) {
        const double sensorPhi = (layer == 1) ? c_ladderPhiL1[ladder - 1] : c_ladderPhiL2[ladder - 1];
        const double rotatedBeamSpotX =  m_BeamSpotPosition.X() * cos(sensorPhi) + m_BeamSpotPosition.Y() * sin(sensorPhi);
        const double rotatedBeamSpotY = -m_BeamSpotPosition.X() * sin(sensorPhi) + m_BeamSpotPosition.Y() * cos(sensorPhi);
 
        // in the rotated coordinate the sensor is perpendicular to the x axis at position sensorLocalX
        const double sensorLocalX = sensorPerpRadius - rotatedBeamSpotX;
 
        double phiDiff = trackPhi - sensorPhi;
        if (phiDiff < -M_PI) {
          phiDiff += 2. * M_PI;
        }
        if (phiDiff > M_PI) {
          phiDiff -= 2. * M_PI;
        }
 
        // Don't try to extrapolate if track direction and sensor are too different (in phi)
        // this should speed up the calculation as wrong combinations are not checked at all.
        // Two values to check both the outgoing (0.3) and incoming (0.8) arm.
        if (fabs(phiDiff) > 0.25 * M_PI and fabs(phiDiff) < 0.75 * M_PI) {
          continue;
        }
        if (fabs(phiDiff) > 0.75 * M_PI and fabs(tanTrackLambda) > 0.2 /*and fabs(trackRadius) > 20*/) {
          continue;
        }
 
 
        // relative phi value of the track center compared to the rotated
        // coordinate system defined by the (rotated) line perpendicular
        // to the sensor (with length sensorPerpRadius)
        double relTrackCenterPhi = 0;
        if (trackCharge < 0) {
          relTrackCenterPhi = trackPhi - M_PI_2 - sensorPhi;
        } else if (trackCharge > 0) {
          relTrackCenterPhi = trackPhi + M_PI_2 - sensorPhi;
        }
        const double xCenter  = trackRadius * cos(relTrackCenterPhi);
        const double yCenter  = trackRadius * sin(relTrackCenterPhi);
 
        // continue if radicant of sqrt is negative
        if ((trackRadius * trackRadius - (sensorLocalX - xCenter) * (sensorLocalX - xCenter)) < 0) {
          continue;
        }
        const double ytmp     = sqrt(trackRadius * trackRadius - (sensorLocalX - xCenter) * (sensorLocalX - xCenter));
        const double yplus    = yCenter + ytmp + rotatedBeamSpotY;
        const double yminus   = yCenter - ytmp + rotatedBeamSpotY;
 
        const double correctionterm = ((layer == 1 ? m_radiusCorrectionFactorL1 : m_radiusCorrectionFactorL2) * trackCharge /
                                       trackRadius) +
                                      m_sinPhiCorrectionFactor * sin(trackPhi) +
                                      m_cosPhiCorrectionFactor * cos(trackPhi);
 
        const double localUPositionPlus   = yplus  - c_shiftY + correctionterm;
        const double localUPositionMinus  = yminus - c_shiftY + correctionterm;
        const double toleranceRPhi        = m_tolerancePhi * sensorLocalX;
 
        // if the hit for sure is out of reach of the current ladder, continue
        if (not(yplus  >= c_sensorMinY - toleranceRPhi and yplus  <= c_sensorMaxY + toleranceRPhi) and
            not(yminus >= c_sensorMinY - toleranceRPhi and yminus <= c_sensorMaxY + toleranceRPhi)) {
          continue;
        }
 
        // estimate the z coordinate of the extrapolation on this layer
        const double z      = sensorLocalX * tanTrackLambda - m_BeamSpotPosition.Z();
        const double zPlus  = sqrt(sensorLocalX * sensorLocalX + yplus * yplus)   * tanTrackLambda * m_zPositionCorrectionFactor -
                              m_BeamSpotPosition.Z();
        const double zMinus = sqrt(sensorLocalX * sensorLocalX + yminus * yminus) * tanTrackLambda * m_zPositionCorrectionFactor -
                              m_BeamSpotPosition.Z();
 
        for (int sensor = 1; sensor <= 2; sensor++) {
 
          const double shiftZ = (layer == 1) ? c_centerZShiftLayer1[sensor - 1] : c_centerZShiftLayer2[sensor - 1];
 
          double localVPosition       = z - shiftZ;
          double localVPositionPlus   = zPlus - shiftZ;
          double localVPositionMinus  = zMinus - shiftZ;
          // check whether z intersection possibly is on sensor to be checked, only continue with the rest of calculations if that's the case
          if (localVPosition >= ((-c_activeSensorLength[layer - 1] / 2.0) - m_toleranceZ) and
              localVPosition <= ((c_activeSensorLength[layer - 1] / 2.0) + m_toleranceZ)) {
 
            const VxdID sensorID = VxdID(layer, ladder, sensor);
 
            // check for first option of the intersection
            if (localUPositionPlus >= -c_activeSensorWidth / 2.0 - toleranceRPhi and
                localUPositionPlus <=  c_activeSensorWidth / 2.0 + toleranceRPhi) {
              PXDIntercept intercept;
              intercept.setCoorU(localUPositionPlus);
              intercept.setCoorV(localVPositionPlus);
              intercept.setVxdID(sensorID);
              m_storePXDIntercepts.appendNew(intercept);
              thisTracksIntercepts.push_back(intercept);
            }
            // check for second option of the intersection
            if (localUPositionMinus >= -c_activeSensorWidth / 2.0 - toleranceRPhi and
                localUPositionMinus <=  c_activeSensorWidth / 2.0 + toleranceRPhi) {
              PXDIntercept intercept;
              intercept.setCoorU(localUPositionMinus);
              intercept.setCoorV(localVPositionMinus);
              intercept.setVxdID(sensorID);
              m_storePXDIntercepts.appendNew(intercept);
              thisTracksIntercepts.push_back(intercept);
            }
          }
        }
      }
    }
 
    const double omega = 1. / trackRadius;
    unsigned short uSizeL1 = (unsigned short)(m_multiplierUL1 * omega + m_minimumROISizeUL1);
    unsigned short uSizeL2 = (unsigned short)(m_multiplierUL2 * omega + m_minimumROISizeUL2);
    unsigned short vSizeL1 = (unsigned short)((1. + fabs(tanTrackLambda) * m_multiplierVL1) * m_minimumROISizeVL1);
    unsigned short vSizeL2 = (unsigned short)((1. + fabs(tanTrackLambda) * m_multiplierVL2) * m_minimumROISizeVL2);
    for (auto& intercept : thisTracksIntercepts) {
      const VxdID& interceptSensorID = intercept.getSensorID();
 
      double uCoordinate = intercept.getCoorU();
      double vCoordinate = intercept.getCoorV();
 
      const PXD::SensorInfo* currentSensor = dynamic_cast<const PXD::SensorInfo*>(&VXD::GeoCache::get(interceptSensorID));
 
      int interceptUCell = currentSensor->getUCellID(uCoordinate, vCoordinate, false);
      int interceptVCell = currentSensor->getVCellID(vCoordinate, false);
      int nUCells = currentSensor->getUCells();
      int nVCells = currentSensor->getVCells();
 
      unsigned short uSize = (interceptSensorID.getLayerNumber() == 1 ? uSizeL1 : uSizeL2);
      unsigned short vSize = (interceptSensorID.getLayerNumber() == 1 ? vSizeL1 : vSizeL2);
      if (uSize > m_maximumROISizeU) {
        uSize = m_maximumROISizeU;
      }
      if (vSize > m_maximumROISizeV) {
        vSize = m_maximumROISizeV;
      }
 
      short uCellDownLeft = interceptUCell - uSize / 2;
      short vCellDownLeft = interceptVCell - vSize / 2;
 
      short uCellUpRight = interceptUCell + uSize / 2;
      short vCellUpRight = interceptVCell + vSize / 2;
 
      if (uCellDownLeft >= nUCells or vCellDownLeft >= nVCells or uCellUpRight < 0 or vCellUpRight < 0) {
        continue;
      }
 
      if (uCellDownLeft < 0) {
        uCellDownLeft = 0;
      }
      if (vCellDownLeft < 0) {
        vCellDownLeft = 0;
      }
 
      // minimum cell id is 0, maximum is nCells - 1
      if (uCellUpRight >= nUCells) {
        uCellUpRight = nUCells - 1;
      }
      if (vCellUpRight >= nVCells) {
        vCellUpRight = nVCells - 1;
      }
 
      m_storeROIs.appendNew(ROIid(uCellDownLeft, uCellUpRight, vCellDownLeft, vCellUpRight, interceptSensorID));
    }
 
  }
}

initialize()

void initialize ( void  )

overridevirtual

Initialize the StoreArrays.

Create the store arrays.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 112 of file ROIFinder.cc.

Member Data Documentation

c_sensorMinY

const double c_sensorMinY = -0.36

private

PXD is shifted to create the windmill structure.

Minimum y coordinate if x-axis is perpendicular to the sensor:

Definition at line 145 of file ROIFinder.h.

---

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

• tracking/vxdHoughTracking/findlets/include/ROIFinder.h
• tracking/vxdHoughTracking/findlets/src/ROIFinder.cc