ROIFinder Class Reference

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

#include <ROIFinder.h>

Inheritance diagram for ROIFinder:

Public Types
using	IOTypes
	Types that should be served to apply on invocation.
using	IOVectors
	Vector types that should be served to apply on invocation.

Public Member Functions
	ROIFinder ()
	Constructor for adding the subfindlets.
	~ROIFinder ()
	Default destructor.
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.
void	initialize () override
	Initialize the StoreArrays.
void	beginRun () override
	Initialize the BField.
void	beginEvent () override
	Clear the object pools.
virtual std::string	getDescription ()
	Brief description of the purpose of the concrete findlet.
virtual std::string	getDescription ()
	Brief description of the purpose of the concrete 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
	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 > (length/-2)+shiftZ && mhp_z < (length/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 > (length/-2)+shiftZ && mhp_z < (length/2)+shiftZ.
const double	c_sensorMinY = -0.36
	PXD is shifted to create the windmill structure.
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 containing the BeamSpot position. This will be used as the starting point of the extrapolation.
B2Vector3D	m_BeamSpotPositionError
	B2Vector3D actually containing the BeamSpot position error.
std::vector< ProcessingSignalListener * >	m_subordinaryProcessingSignalListeners
	References to subordinary signal processing listener contained in this findlet.
bool	m_initialized
	Flag to keep track whether initialization happened before.
bool	m_terminated
	Flag to keep track whether termination happened before.
std::string	m_initializedAs
	Name of the type during initialisation.

Detailed Description

Findlet for performing the simple SVDHoughTracking ROI calculation.

Definition at line 30 of file ROIFinder.h.

Member Typedef Documentation

IOTypes

using IOTypes

inherited

Types that should be served to apply on invocation.

Definition at line 30 of file Findlet.h.

IOVectors

using IOVectors

inherited

Vector types that should be served to apply on invocation.

Definition at line 53 of file Findlet.h.

Super

using Super = TrackFindingCDC::Findlet<const SpacePointTrackCand>

private

Parent class.

Definition at line 32 of file ROIFinder.h.

ToVector

using ToVector

protectedinherited

Short hand for ToRangeImpl.

Definition at line 49 of file Findlet.h.

Constructor & Destructor Documentation

ROIFinder()

ROIFinder

(

)

Constructor for adding the subfindlets.

Definition at line 30 of file ROIFinder.cc.

{
}

Member Function Documentation

addProcessingSignalListener()

void addProcessingSignalListener ( ProcessingSignalListener * psl )

protectedinherited

Register a processing signal listener to be notified.

Definition at line 53 of file CompositeProcessingSignalListener.cc.

{
  m_subordinaryProcessingSignalListeners.push_back(psl);
}

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 180 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::getInstance().getSensorInfo(
                                               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));
    }
 
  }
}

beginEvent()

void beginEvent ( )

overridevirtual

Clear the object pools.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 170 of file ROIFinder.cc.

{
  // If no ROIs shall be calculated, return rightaway and don't do anything
  if (not m_calculateROI) {
    return;
  }
 
  Super::beginEvent();
}

beginRun()

void beginRun ( )

overridevirtual

Initialize the BField.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 146 of file ROIFinder.cc.

{
  // If no ROIs shall be calculated, return rightaway and don't do anything
  if (not m_calculateROI) {
    return;
  }
 
  Super::beginRun();
 
  m_bFieldZ = BFieldManager::getField(0, 0, 0).Z() / Unit::T;
  m_estimator->setMagneticFieldStrength(m_bFieldZ);
 
  DBObjPtr<BeamSpot> beamSpotDB;
  if (beamSpotDB.isValid()) {
    m_BeamSpotPosition = (*beamSpotDB).getIPPosition();
    const TMatrixDSym posErr = (*beamSpotDB).getIPPositionCovMatrix();
    m_BeamSpotPositionError.SetXYZ(sqrt(posErr[0][0]), sqrt(posErr[1][1]), sqrt(posErr[2][2]));
  } else {
    m_BeamSpotPosition.SetXYZ(0., 0., 0.);
    m_BeamSpotPositionError.SetXYZ(0., 0., 0.);
  }
}

endRun()

void endRun ( )

overrideinherited

Receive and dispatch signal for the end of the run.

Definition at line 39 of file CompositeProcessingSignalListener.cc.

{
  for (ProcessingSignalListener* psl : reversedRange(m_subordinaryProcessingSignalListeners)) {
    psl->endRun();
  }
  Super::endRun();
}

exposeParameters()

void exposeParameters ( ModuleParamList * moduleParamList, const std::string & prefix )

overridevirtual

Expose the parameters of the sub findlets.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 34 of file ROIFinder.cc.

{
  Super::exposeParameters(moduleParamList, prefix);
 
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "calculateROI"), m_calculateROI,
                                "Calculate PXDIntercepts and ROIs in this findlet based on a simple circle extrapolation (r-phi) and straight line extrapolation (z, theta)?",
                                m_calculateROI);
 
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "storePXDInterceptsName"), m_storePXDInterceptsName,
                                "Name of the PXDIntercepts StoreArray produced by SVDHoughTracking using a simple circle extrapolation in r-phi and a straight line extrapolation in theta.",
                                m_storePXDInterceptsName);
 
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "storeROIsName"), m_storeROIsName,
                                "Name of the ROIs StoreArray produced by SVDHoughTracking using a simple circle extrapolation in r-phi and a straight line extrapolation in theta.",
                                m_storeROIsName);
 
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "tolerancePhi"), m_tolerancePhi,
                                "Allowed tolerance in phi (in radians) (for ROI calculation in u direction). If the intercept is within this range of the active region, an intercept is created.",
                                m_tolerancePhi);
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "toleranceZ"), m_toleranceZ,
                                "Allowed tolerance in z (in cm) (for ROI calculation in v direction). If the intercept is within this range of the active region of a sensor, an intercept is created.",
                                m_toleranceZ);
 
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "radiusCorrectionFactorL1"), m_radiusCorrectionFactorL1,
                                "Correct charge-dependent bias of the extrapolated hit on L1 with radiusCorrectionFactor * trackCharge / trackRadius.",
                                m_radiusCorrectionFactorL1);
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "radiusCorrectionFactorL2"), m_radiusCorrectionFactorL2,
                                "Correct charge-dependent bias of the extrapolated hit on L2 with radiusCorrectionFactor * trackCharge / trackRadius.",
                                m_radiusCorrectionFactorL2);
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "sinPhiCorrectionFactor"), m_sinPhiCorrectionFactor,
                                "Correct sin(trackPhi) dependent bias with sinPhiCorrectionFactor * sin(trackPhi).",
                                m_sinPhiCorrectionFactor);
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "cosPhiCorrectionFactor"), m_cosPhiCorrectionFactor,
                                "Correct cos(trackPhi) dependent bias with cosPhiCorrectionFactor * cos(trackPhi).",
                                m_cosPhiCorrectionFactor);
 
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "zPositionCorrectionFactor"), m_zPositionCorrectionFactor,
                                "Correction factor for the extrapolated z position.",
                                m_zPositionCorrectionFactor);
 
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "minimumROISizeUL1"), m_minimumROISizeUL1,
                                "Minimum ROI size (in pixel) in u direction on L1.", m_minimumROISizeUL1);
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "minimumROISizeVL1"), m_minimumROISizeVL1,
                                "Minimum ROI size (in pixel) in v direction on L1.", m_minimumROISizeVL1);
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "minimumROISizeUL2"), m_minimumROISizeUL2,
                                "Minimum ROI size (in pixel) in u direction on L2.", m_minimumROISizeUL2);
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "minimumROISizeVL2"), m_minimumROISizeVL2,
                                "Minimum ROI size (in pixel) in v direction on L2.", m_minimumROISizeVL2);
 
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "multiplierUL1"), m_multiplierUL1,
                                "Multiplier term for ROI size estimation for L1 u direction. Usage: multiplierUL1 * 1/R + minimumROISizeUL1, with R in cm.",
                                m_multiplierUL1);
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "multiplierUL2"), m_multiplierUL2,
                                "Multiplier term for ROI size estimation for L2 u direction. Usage: multiplierUL2 * 1/R + minimumROISizeUL2, with R in cm.",
                                m_multiplierUL2);
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "multiplierVL1"), m_multiplierVL1,
                                "Multiplier term for ROI size estimation for L1 v direction. Usage: (1 + abs(tan(lambda)) * multiplierVL1) + minimumROISizeVL1.",
                                m_multiplierVL1);
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "multiplierVL2"), m_multiplierVL2,
                                "Multiplier term for ROI size estimation for L2 v direction. Usage: (1 + abs(tan(lambda)) * multiplierVL2) + minimumROISizeVL2.",
                                m_multiplierVL2);
 
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "maximumROISizeU"), m_maximumROISizeU,
                                "Maximum ROI size in u.", m_maximumROISizeU);
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "maximumROISizeV"), m_maximumROISizeV,
                                "Maximum ROI size in v.", m_maximumROISizeV);
 
 
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "refit"), m_refit,
                                "Refit the track with trackQualityEstimationMethod?", m_refit);
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "addVirtualIP"), m_addVirtualIP,
                                "Add virtual IP to fit the tracks again for ROI creation?", m_addVirtualIP);
  moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "ROIFitMethod"), m_ROIFitMethod,
                                "Identifier which fit method to use. Valid identifiers are: [circleFit, tripletFit, helixFit]",
                                m_ROIFitMethod);
 
}

getDescription() [1/2]

virtual std::string getDescription ( )

inlinevirtualinherited

Brief description of the purpose of the concrete findlet.

Definition at line 60 of file Findlet.h.

      {
        return "(no description)";
      }

getDescription() [2/2]

virtual std::string getDescription ( )

inlinevirtualinherited

Brief description of the purpose of the concrete findlet.

Definition at line 60 of file Findlet.h.

      {
        return "(no description)";
      }

getNProcessingSignalListener()

int getNProcessingSignalListener ( )

protectedinherited

Get the number of currently registered listeners.

Definition at line 56 of file CompositeProcessingSignalListener.cc.

{
  return m_subordinaryProcessingSignalListeners.size();
}

initialize()

void initialize ( )

overridevirtual

Initialize the StoreArrays.

Create the store arrays.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 113 of file ROIFinder.cc.

{
  // If no ROIs shall be calculated, return rightaway and don't do anything
  if (not m_calculateROI) {
    return;
  }
 
  Super::initialize();
 
  m_storePXDIntercepts.registerInDataStore(m_storePXDInterceptsName);
  m_storeROIs.registerInDataStore(m_storeROIsName);
 
  if (m_minimumROISizeUL1 < 0 or m_minimumROISizeUL2 < 0 or
      m_minimumROISizeVL1 < 0 or m_minimumROISizeVL2 < 0 or
      m_multiplierUL1 < 0 or m_multiplierUL2 < 0 or
      m_multiplierVL1 < 0 or m_multiplierVL2 < 0 or
      m_tolerancePhi < 0 or m_toleranceZ < 0) {
    B2ERROR("Please check the ROI size parameters. "
            "None of minimumROISizeUL1, minimumROISizeUL2, minimumROISizeVL1, minimumROISizeVL2, "
            "multiplierUL1, multiplierUL2, multiplierVL1, multiplierVL2, overlapU, overlapV must be < 0!");
  }
 
  if (m_ROIFitMethod == "tripletFit") {
    m_estimator = std::make_unique<QualityEstimatorTripletFit>();
  } else if (m_ROIFitMethod == "circleFit") {
    m_estimator = std::make_unique<QualityEstimatorCircleFit>();
  } else if (m_ROIFitMethod == "helixFit") {
    m_estimator = std::make_unique<QualityEstimatorRiemannHelixFit>();
  }
  B2ASSERT("QualityEstimator could not be initialized with method: " << m_ROIFitMethod, m_estimator);
 
};

terminate()

void terminate ( )

overrideinherited

Receive and dispatch Signal for termination of the event processing.

Definition at line 42 of file CompositeProcessingSignalListener.cc.

{
  for (ProcessingSignalListener* psl : reversedRange(m_subordinaryProcessingSignalListeners)) {
    psl->terminate();
  }
  Super::terminate();
}

Member Data Documentation

c_activeSensorLength

const double c_activeSensorLength[2] = {4.48, 6.144}

private

Length of the active region for L1 and L2.

Definition at line 152 of file ROIFinder.h.

{4.48, 6.144};

c_activeSensorWidth

const double c_activeSensorWidth = (c_sensorMaxY - c_sensorMinY)

private

PXD sensors in L1 and L2 have the same size in u direction (=width):

Definition at line 146 of file ROIFinder.h.

c_centerZShiftLayer1

const double c_centerZShiftLayer1[2] = {3.68255, -0.88255}

private

Shift of the center of the active area of each sensor in a ladder of layer 1 For use of mhp_z > (length/-2)+shiftZ && mhp_z < (length/2)+shiftZ.

Definition at line 136 of file ROIFinder.h.

{3.68255, -0.88255};

c_centerZShiftLayer2

const double c_centerZShiftLayer2[2] = {5.01455, -1.21455}

private

Shift of the center of the active area of each sensor in a ladder of layer 2 For use of mhp_z > (length/-2)+shiftZ && mhp_z < (length/2)+shiftZ.

Definition at line 139 of file ROIFinder.h.

{5.01455, -1.21455};

c_ladderPhiL1

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}

private

Phi values of the ladders of L1.

Definition at line 154 of file ROIFinder.h.

{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};

c_ladderPhiL2

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}

private

Phi values of the ladders of L2.

Definition at line 156 of file ROIFinder.h.

{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};

c_layerRadius

const double c_layerRadius[2] = {1.42854, 2.21218}

private

Radius of the two layers.

Definition at line 150 of file ROIFinder.h.

{1.42854, 2.21218};

c_sensorMaxY

const double c_sensorMaxY = 0.89

private

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

Definition at line 144 of file ROIFinder.h.

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 142 of file ROIFinder.h.

c_shiftY

const double c_shiftY = (c_sensorMaxY + c_sensorMinY) / 2.0

private

Shift of the center position in y if the x-axis is perpendicular to the sensor:

Definition at line 148 of file ROIFinder.h.

m_addVirtualIP

bool m_addVirtualIP = true

private

Add a virtual IP for the refit?

Definition at line 74 of file ROIFinder.h.

m_BeamSpotPosition

B2Vector3D m_BeamSpotPosition

private

B2Vector3D actually containing the BeamSpot position. This will be used as the starting point of the extrapolation.

Definition at line 163 of file ROIFinder.h.

m_BeamSpotPositionError

B2Vector3D m_BeamSpotPositionError

private

B2Vector3D actually containing the BeamSpot position error.

Definition at line 165 of file ROIFinder.h.

m_bFieldZ

double m_bFieldZ = 1.5

private

BField in Tesla.

Definition at line 159 of file ROIFinder.h.

m_calculateROI

bool m_calculateROI = false

private

Calculate ROI in this findlet?

Definition at line 58 of file ROIFinder.h.

m_cosPhiCorrectionFactor

double m_cosPhiCorrectionFactor = 0.0

private

Correction factor for the cos(phi) modulation.

Definition at line 99 of file ROIFinder.h.

m_estimator

std::unique_ptr<QualityEstimatorBase> m_estimator

private

pointer to the selected QualityEstimator

Definition at line 79 of file ROIFinder.h.

m_initialized

bool m_initialized

privateinherited

Flag to keep track whether initialization happened before.

Definition at line 52 of file ProcessingSignalListener.h.

m_initializedAs

std::string m_initializedAs

privateinherited

Name of the type during initialisation.

Definition at line 58 of file ProcessingSignalListener.h.

m_maximumROISizeU

unsigned short m_maximumROISizeU = 100

private

maximum ROI size in u in pixel

Definition at line 128 of file ROIFinder.h.

m_maximumROISizeV

unsigned short m_maximumROISizeV = 100

private

maximum ROI size in v in pixel

Definition at line 130 of file ROIFinder.h.

m_minimumROISizeUL1

double m_minimumROISizeUL1 = 40

private

Minimum size of ROI in u-direction on L1 in pixel.

Definition at line 107 of file ROIFinder.h.

m_minimumROISizeUL2

double m_minimumROISizeUL2 = 35

private

Minimum size of ROI in u-direction on L2 in pixel.

Definition at line 111 of file ROIFinder.h.

m_minimumROISizeVL1

double m_minimumROISizeVL1 = 40

private

Minimum size of ROI in v-direction on L1 in pixel.

Definition at line 109 of file ROIFinder.h.

m_minimumROISizeVL2

double m_minimumROISizeVL2 = 30

private

Minimum size of ROI in v-direction on L2 in pixel.

Definition at line 113 of file ROIFinder.h.

m_multiplierUL1

double m_multiplierUL1 = 500

private

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.

Definition at line 119 of file ROIFinder.h.

m_multiplierUL2

double m_multiplierUL2 = 600

private

Multiplier term for u-direction on L2.

Definition at line 121 of file ROIFinder.h.

m_multiplierVL1

double m_multiplierVL1 = 0.8

private

Multiplier term for v-direction on L1.

Definition at line 123 of file ROIFinder.h.

m_multiplierVL2

double m_multiplierVL2 = 0.8

private

Multiplier term for v-direction on L2.

Definition at line 125 of file ROIFinder.h.

m_radiusCorrectionFactorL1

double m_radiusCorrectionFactorL1 = -2.0

private

Correction factor for radial bias for L1: factor * charge / radius.

Definition at line 93 of file ROIFinder.h.

m_radiusCorrectionFactorL2

double m_radiusCorrectionFactorL2 = -5.0

private

Correction factor for radial bias for L2: factor * charge / radius.

Definition at line 95 of file ROIFinder.h.

m_refit

bool m_refit = true

private

Refit the tracks with m_ROIFitMethod.

Definition at line 72 of file ROIFinder.h.

m_ROIFitMethod

std::string m_ROIFitMethod = "helixFit"

private

Refit with this estimator, options are circleFit, tripletFit, helixFit.

Definition at line 76 of file ROIFinder.h.

m_sinPhiCorrectionFactor

double m_sinPhiCorrectionFactor = 0.0

private

Correction factor for the sin(phi) modulation.

Definition at line 97 of file ROIFinder.h.

m_storePXDIntercepts

StoreArray<PXDIntercept> m_storePXDIntercepts

private

PXDIntercepts StoreArray.

Definition at line 66 of file ROIFinder.h.

m_storePXDInterceptsName

std::string m_storePXDInterceptsName = "SVDHoughPXDIntercepts"

private

Name of the PXDIntercepts StoreArray.

Definition at line 62 of file ROIFinder.h.

m_storeROIs

StoreArray<ROIid> m_storeROIs

private

ROIs StoreArray.

Definition at line 68 of file ROIFinder.h.

m_storeROIsName

std::string m_storeROIsName = "SVDHoughROIs"

private

Name of the ROIs StoreArray.

Definition at line 64 of file ROIFinder.h.

m_subordinaryProcessingSignalListeners

std::vector<ProcessingSignalListener*> m_subordinaryProcessingSignalListeners

privateinherited

References to subordinary signal processing listener contained in this findlet.

Definition at line 60 of file CompositeProcessingSignalListener.h.

m_terminated

bool m_terminated

privateinherited

Flag to keep track whether termination happened before.

Definition at line 55 of file ProcessingSignalListener.h.

m_tolerancePhi

double m_tolerancePhi = 0.15

private

Allowed tolerance (in radians) phi to create intercepts per sensor.

Definition at line 84 of file ROIFinder.h.

m_toleranceZ

double m_toleranceZ = 0.5

private

Allowed tolerance (in cm) in z to create intercepts per sensor.

Definition at line 86 of file ROIFinder.h.

m_zPositionCorrectionFactor

double m_zPositionCorrectionFactor = 1.0

private

Correction factor for the z position.

Definition at line 102 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