ROIFinder Class Reference

Findlet for performing the DATCON 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_param_calculateROI = false
	Calculate ROI in this findlet?
std::string	m_param_storePXDInterceptsName = "DATCONPXDIntercepts"
	Name of the PXDIntercepts StoreArray.
std::string	m_param_storeROIsName = "DATCONROIs"
	Name of the ROIs StoreArray.
StoreArray< PXDIntercept >	m_storePXDIntercepts
	PXDIntercepts StoreArray.
StoreArray< ROIid >	m_storeROIs
	ROIs StoreArray.
double	m_param_tolerancePhi = 0.15
	Allowed tolerance (in radians) phi to create intercepts per sensor.
double	m_param_toleranceZ = 0.5
	Allowed tolerance (in cm) in z to create intercepts per sensor.
double	m_param_radiusCorrectionFactor = 4.0
	Correction factor for radial bias: factor * charge / radius.
double	m_param_sinPhiCorrectionFactor = 0.0
	Correction factor for the sin(phi) modulation.
double	m_param_cosPhiCorrectionFactor = 0.0
	Correction factor for the cos(phi) modulation.
double	m_param_minimumROISizeUL1 = 40
	Minimum size of ROI in u-direction on L1 in pixel.
double	m_param_minimumROISizeVL1 = 40
	Minimum size of ROI in v-direction on L1 in pixel.
double	m_param_minimumROISizeUL2 = 40
	Minimum size of ROI in u-direction on L2 in pixel.
double	m_param_minimumROISizeVL2 = 40
	Minimum size of ROI in v-direction on L2 in pixel.
double	m_param_multiplierUL1 = 600
	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_param_multiplierUL2 = 800
	Multiplier term for u-direction on L2.
double	m_param_multiplierVL1 = 0.8
	Multiplier term for v-direction on L1.
double	m_param_multiplierVL2 = 1.2
	Multiplier term for v-direction on L2.
unsigned short	m_param_maximumROISizeU = 120
	maximum ROI size in u in pixel
unsigned short	m_param_maximumROISizeV = 192
	maximum ROI size in v in pixel
const double	m_const_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	m_const_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	m_const_sensorMinY = -0.36
	PXD is shifted to create the windmill structure. More...
const double	m_const_sensorMaxY = 0.89
	Maximum y coordinate if x-axis is perpendicular to the sensor:
const double	m_const_activeSensorWidth = (m_const_sensorMaxY - m_const_sensorMinY)
	PXD sensors in L1 and L2 have the same size in u direction (=width):
const double	m_const_shiftY = (m_const_sensorMaxY + m_const_sensorMinY) / 2.0
	Shift of the center position in y if the x-axis is perpendicular to the sensor:
const double	m_const_layerRadius [2] = {1.42854, 2.21218}
	Radius of the two layers.
const double	m_const_activeSensorLength [2] = {4.48, 6.144}
	Length of the active region for L1 and L2.
const double	m_const_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	m_const_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.
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 DATCON ROI calculation.

Definition at line 32 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 146 of file ROIFinder.cc.

{
  // If no ROIs shall be calculated, return rightaway and don't do anything
  if (not m_param_calculateROI) {
    return;
  }
 
  for (auto& track : finalTracks) {
    // do nothing if the SpacePointTrackCand is not active
    if (!track.hasRefereeStatus(SpacePointTrackCand::c_isActive)) {
      continue;
    }
 
    std::vector<PXDIntercept> thisTracksIntercepts;
    thisTracksIntercepts.reserve(8);
 
    const B2Vector3D& momentumEstimate = track.getMomSeed();
 
    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 = m_const_layerRadius[layer - 1];
 
      for (int ladder = 1; ladder <= (layer == 1 ? 8 : 12); ladder++) {
        const double sensorPhi = (layer == 1) ? m_const_ladderPhiL1[ladder - 1] : m_const_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.3 * M_PI /*and fabs(phiDiff) < 0.8 * M_PI*/) {
          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 = (m_param_radiusCorrectionFactor * trackCharge / trackRadius) +
                                      m_param_sinPhiCorrectionFactor * sin(trackPhi) +
                                      m_param_cosPhiCorrectionFactor * cos(trackPhi);
 
        const double localUPositionPlus   = yplus  - m_const_shiftY + correctionterm;
        const double localUPositionMinus  = yminus - m_const_shiftY + correctionterm;
        const double toleranceRPhi = m_param_tolerancePhi * sensorLocalX;
 
        // if the hit for sure is out of reach of the current ladder, continue
        if (not(yplus  >= m_const_sensorMinY - toleranceRPhi and yplus  <= m_const_sensorMaxY + toleranceRPhi) and
            not(yminus >= m_const_sensorMinY - toleranceRPhi and yminus <= m_const_sensorMaxY + toleranceRPhi)) {
          continue;
        }
 
        // estimate the z coordinate of the extrapolation on this layer
        const double z = sensorLocalX * tanTrackLambda - m_BeamSpotPosition.Z();
 
        for (int sensor = 1; sensor <= 2; sensor++) {
 
          const double shiftZ = (layer == 1) ? m_const_centerZShiftLayer1[sensor - 1] : m_const_centerZShiftLayer2[sensor - 1];
 
          double localVPosition = z - 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 >= ((-m_const_activeSensorLength[layer - 1] / 2.0) - m_param_toleranceZ) and
              localVPosition <= ((m_const_activeSensorLength[layer - 1] / 2.0) + m_param_toleranceZ)) {
 
            const VxdID sensorID = VxdID(layer, ladder, sensor);
 
            // double localVPosition = z - shiftZ;
            // check for first option of the intersection
            if (localUPositionPlus >= -m_const_activeSensorWidth / 2.0 - toleranceRPhi and
                localUPositionPlus <=  m_const_activeSensorWidth / 2.0 + toleranceRPhi) {
              PXDIntercept intercept;
              intercept.setCoorU(localUPositionPlus);
              intercept.setCoorV(localVPosition);
              intercept.setVxdID(sensorID);
              m_storePXDIntercepts.appendNew(intercept);
              thisTracksIntercepts.push_back(intercept);
            }
            // check for second option of the intersection
            if (localUPositionMinus >= -m_const_activeSensorWidth / 2.0 - toleranceRPhi and
                localUPositionMinus <=  m_const_activeSensorWidth / 2.0 + toleranceRPhi) {
              PXDIntercept intercept;
              intercept.setCoorU(localUPositionMinus);
              intercept.setCoorV(localVPosition);
              intercept.setVxdID(sensorID);
              m_storePXDIntercepts.appendNew(intercept);
              thisTracksIntercepts.push_back(intercept);
            }
          }
        }
      }
    }
 
    const double omega = 1. / trackRadius;
    unsigned short uSizeL1 = (unsigned short)(m_param_multiplierUL1 * omega + m_param_minimumROISizeUL1);
    unsigned short uSizeL2 = (unsigned short)(m_param_multiplierUL2 * omega + m_param_minimumROISizeUL2);
    unsigned short vSizeL1 = (unsigned short)((1. + fabs(tanTrackLambda) * m_param_multiplierVL1) * m_param_minimumROISizeVL1);
    unsigned short vSizeL2 = (unsigned short)((1. + fabs(tanTrackLambda) * m_param_multiplierVL2) * m_param_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_param_maximumROISizeU) {
        uSize = m_param_maximumROISizeU;
      }
      if (vSize > m_param_maximumROISizeV) {
        vSize = m_param_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 93 of file ROIFinder.cc.

Member Data Documentation

m_const_sensorMinY

const double m_const_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 128 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