Belle II Software development
ROIFinder Class Referenceabstract

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

#include <ROIFinder.h>

Inheritance diagram for ROIFinder:
Findlet< const SpacePointTrackCand > CompositeProcessingSignalListener ProcessingSignalListener

Public Types

using IOTypes = std::tuple< AIOTypes... >
 Types that should be served to apply on invocation.
 
using IOVectors = std::tuple< std::vector< AIOTypes >... >
 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 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< PXDInterceptm_storePXDIntercepts
 PXDIntercepts StoreArray.
 
StoreArray< ROIidm_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< QualityEstimatorBasem_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 = false
 Flag to keep track whether initialization happened before.
 
bool m_terminated = false
 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 33 of file ROIFinder.h.

Member Typedef Documentation

◆ IOTypes

using IOTypes = std::tuple<AIOTypes...>
inherited

Types that should be served to apply on invocation.

Definition at line 30 of file Findlet.h.

◆ IOVectors

using IOVectors = std::tuple< std::vector<AIOTypes>... >
inherited

Vector types that should be served to apply on invocation.

Definition at line 53 of file Findlet.h.

◆ Super

Parent class.

Definition at line 35 of file ROIFinder.h.

◆ ToVector

using ToVector = typename ToVectorImpl<T>::Type
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 29 of file ROIFinder.cc.

30{
31}

Member Function Documentation

◆ addProcessingSignalListener()

void addProcessingSignalListener ( ProcessingSignalListener psl)
protectedinherited

Register a processing signal listener to be notified.

Definition at line 55 of file CompositeProcessingSignalListener.cc.

56{
58}
std::vector< ProcessingSignalListener * > m_subordinaryProcessingSignalListeners
References to subordinary signal processing listener contained in this findlet.

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

180{
181 // If no ROIs shall be calculated, return rightaway and don't do anything
182 if (not m_calculateROI) {
183 return;
184 }
185
186 for (auto& track : finalTracks) {
187 // do nothing if the SpacePointTrackCand is not active
188 if (!track.hasRefereeStatus(SpacePointTrackCand::c_isActive)) {
189 continue;
190 }
191
192 QualityEstimationResults refittedTrackEstimate;
193 if (m_refit) {
194 auto sortedHits = track.getSortedHits();
195
196 if (m_addVirtualIP) {
197 SpacePoint virtualIPSpacePoint = SpacePoint(m_BeamSpotPosition, m_BeamSpotPositionError, {0.5, 0.5}, {false, false},
199 sortedHits.push_back(&virtualIPSpacePoint);
200 }
201
202 std::sort(sortedHits.begin(), sortedHits.end(),
203 [](const SpacePoint * a, const SpacePoint * b) {return a->getPosition().Perp() < b->getPosition().Perp(); });
204
205 refittedTrackEstimate = m_estimator->estimateQualityAndProperties(sortedHits);
206 }
207
208 std::vector<PXDIntercept> thisTracksIntercepts;
209 thisTracksIntercepts.reserve(8);
210
211 B2Vector3D momentumEstimate = track.getMomSeed();
212 if (m_refit) {
213 momentumEstimate = *refittedTrackEstimate.p;
214 }
215
216 const double trackPhi = momentumEstimate.Phi();
217 const double trackTheta = momentumEstimate.Theta();
218 const double tanTrackLambda = tan(M_PI_2 - trackTheta);
219 const double trackRadius = momentumEstimate.Perp() / (0.00299792458 * m_bFieldZ) ;
220 const double trackCharge = track.getChargeSeed();
221
223 for (int layer = 1; layer <= 2; layer++) {
224 const double sensorPerpRadius = c_layerRadius[layer - 1];
225
227 for (int ladder = 1; ladder <= (layer == 1 ? 8 : 12); ladder++) {
228 const double sensorPhi = (layer == 1) ? c_ladderPhiL1[ladder - 1] : c_ladderPhiL2[ladder - 1];
229 const double rotatedBeamSpotX = m_BeamSpotPosition.X() * cos(sensorPhi) + m_BeamSpotPosition.Y() * sin(sensorPhi);
230 const double rotatedBeamSpotY = -m_BeamSpotPosition.X() * sin(sensorPhi) + m_BeamSpotPosition.Y() * cos(sensorPhi);
231
232 // in the rotated coordinate the sensor is perpendicular to the x axis at position sensorLocalX
233 const double sensorLocalX = sensorPerpRadius - rotatedBeamSpotX;
234
235 double phiDiff = trackPhi - sensorPhi;
236 if (phiDiff < -M_PI) {
237 phiDiff += 2. * M_PI;
238 }
239 if (phiDiff > M_PI) {
240 phiDiff -= 2. * M_PI;
241 }
242
243 // Don't try to extrapolate if track direction and sensor are too different (in phi)
244 // this should speed up the calculation as wrong combinations are not checked at all.
245 // Two values to check both the outgoing (0.3) and incoming (0.8) arm.
246 if (fabs(phiDiff) > 0.25 * M_PI and fabs(phiDiff) < 0.75 * M_PI) {
247 continue;
248 }
249 if (fabs(phiDiff) > 0.75 * M_PI and fabs(tanTrackLambda) > 0.2 /*and fabs(trackRadius) > 20*/) {
250 continue;
251 }
252
253
254 // relative phi value of the track center compared to the rotated
255 // coordinate system defined by the (rotated) line perpendicular
256 // to the sensor (with length sensorPerpRadius)
257 double relTrackCenterPhi = 0;
258 if (trackCharge < 0) {
259 relTrackCenterPhi = trackPhi - M_PI_2 - sensorPhi;
260 } else if (trackCharge > 0) {
261 relTrackCenterPhi = trackPhi + M_PI_2 - sensorPhi;
262 }
263 const double xCenter = trackRadius * cos(relTrackCenterPhi);
264 const double yCenter = trackRadius * sin(relTrackCenterPhi);
265
266 // continue if radicant of sqrt is negative
267 if ((trackRadius * trackRadius - (sensorLocalX - xCenter) * (sensorLocalX - xCenter)) < 0) {
268 continue;
269 }
270 const double ytmp = sqrt(trackRadius * trackRadius - (sensorLocalX - xCenter) * (sensorLocalX - xCenter));
271 const double yplus = yCenter + ytmp + rotatedBeamSpotY;
272 const double yminus = yCenter - ytmp + rotatedBeamSpotY;
273
274 const double correctionterm = ((layer == 1 ? m_radiusCorrectionFactorL1 : m_radiusCorrectionFactorL2) * trackCharge /
275 trackRadius) +
276 m_sinPhiCorrectionFactor * sin(trackPhi) +
277 m_cosPhiCorrectionFactor * cos(trackPhi);
278
279 const double localUPositionPlus = yplus - c_shiftY + correctionterm;
280 const double localUPositionMinus = yminus - c_shiftY + correctionterm;
281 const double toleranceRPhi = m_tolerancePhi * sensorLocalX;
282
283 // if the hit for sure is out of reach of the current ladder, continue
284 if (not(yplus >= c_sensorMinY - toleranceRPhi and yplus <= c_sensorMaxY + toleranceRPhi) and
285 not(yminus >= c_sensorMinY - toleranceRPhi and yminus <= c_sensorMaxY + toleranceRPhi)) {
286 continue;
287 }
288
289 // estimate the z coordinate of the extrapolation on this layer
290 const double z = sensorLocalX * tanTrackLambda - m_BeamSpotPosition.Z();
291 const double zPlus = sqrt(sensorLocalX * sensorLocalX + yplus * yplus) * tanTrackLambda * m_zPositionCorrectionFactor -
293 const double zMinus = sqrt(sensorLocalX * sensorLocalX + yminus * yminus) * tanTrackLambda * m_zPositionCorrectionFactor -
295
297 for (int sensor = 1; sensor <= 2; sensor++) {
298
299 const double shiftZ = (layer == 1) ? c_centerZShiftLayer1[sensor - 1] : c_centerZShiftLayer2[sensor - 1];
300
301 double localVPosition = z - shiftZ;
302 double localVPositionPlus = zPlus - shiftZ;
303 double localVPositionMinus = zMinus - shiftZ;
304 // check whether z intersection possibly is on sensor to be checked, only continue with the rest of calculations if that's the case
305 if (localVPosition >= ((-c_activeSensorLength[layer - 1] / 2.0) - m_toleranceZ) and
306 localVPosition <= ((c_activeSensorLength[layer - 1] / 2.0) + m_toleranceZ)) {
307
308 const VxdID sensorID = VxdID(layer, ladder, sensor);
309
310 // check for first option of the intersection
311 if (localUPositionPlus >= -c_activeSensorWidth / 2.0 - toleranceRPhi and
312 localUPositionPlus <= c_activeSensorWidth / 2.0 + toleranceRPhi) {
313 PXDIntercept intercept;
314 intercept.setCoorU(localUPositionPlus);
315 intercept.setCoorV(localVPositionPlus);
316 intercept.setVxdID(sensorID);
317 m_storePXDIntercepts.appendNew(intercept);
318 thisTracksIntercepts.push_back(intercept);
319 }
320 // check for second option of the intersection
321 if (localUPositionMinus >= -c_activeSensorWidth / 2.0 - toleranceRPhi and
322 localUPositionMinus <= c_activeSensorWidth / 2.0 + toleranceRPhi) {
323 PXDIntercept intercept;
324 intercept.setCoorU(localUPositionMinus);
325 intercept.setCoorV(localVPositionMinus);
326 intercept.setVxdID(sensorID);
327 m_storePXDIntercepts.appendNew(intercept);
328 thisTracksIntercepts.push_back(intercept);
329 }
330 }
331 }
332 }
333 }
334
335 const double omega = 1. / trackRadius;
336 unsigned short uSizeL1 = (unsigned short)(m_multiplierUL1 * omega + m_minimumROISizeUL1);
337 unsigned short uSizeL2 = (unsigned short)(m_multiplierUL2 * omega + m_minimumROISizeUL2);
338 unsigned short vSizeL1 = (unsigned short)((1. + fabs(tanTrackLambda) * m_multiplierVL1) * m_minimumROISizeVL1);
339 unsigned short vSizeL2 = (unsigned short)((1. + fabs(tanTrackLambda) * m_multiplierVL2) * m_minimumROISizeVL2);
340 for (auto& intercept : thisTracksIntercepts) {
341 const VxdID& interceptSensorID = intercept.getSensorID();
342
343 double uCoordinate = intercept.getCoorU();
344 double vCoordinate = intercept.getCoorV();
345
346 const PXD::SensorInfo* currentSensor = dynamic_cast<const PXD::SensorInfo*>(&VXD::GeoCache::getInstance().getSensorInfo(
347 interceptSensorID));
348
349 int interceptUCell = currentSensor->getUCellID(uCoordinate, vCoordinate, false);
350 int interceptVCell = currentSensor->getVCellID(vCoordinate, false);
351 int nUCells = currentSensor->getUCells();
352 int nVCells = currentSensor->getVCells();
353
354 unsigned short uSize = (interceptSensorID.getLayerNumber() == 1 ? uSizeL1 : uSizeL2);
355 unsigned short vSize = (interceptSensorID.getLayerNumber() == 1 ? vSizeL1 : vSizeL2);
356 if (uSize > m_maximumROISizeU) {
357 uSize = m_maximumROISizeU;
358 }
359 if (vSize > m_maximumROISizeV) {
360 vSize = m_maximumROISizeV;
361 }
362
364 short uCellDownLeft = interceptUCell - uSize / 2;
365 short vCellDownLeft = interceptVCell - vSize / 2;
366
368 short uCellUpRight = interceptUCell + uSize / 2;
369 short vCellUpRight = interceptVCell + vSize / 2;
370
371 if (uCellDownLeft >= nUCells or vCellDownLeft >= nVCells or uCellUpRight < 0 or vCellUpRight < 0) {
372 continue;
373 }
374
375 if (uCellDownLeft < 0) {
376 uCellDownLeft = 0;
377 }
378 if (vCellDownLeft < 0) {
379 vCellDownLeft = 0;
380 }
381
382 // minimum cell id is 0, maximum is nCells - 1
383 if (uCellUpRight >= nUCells) {
384 uCellUpRight = nUCells - 1;
385 }
386 if (vCellUpRight >= nVCells) {
387 vCellUpRight = nVCells - 1;
388 }
389
390 m_storeROIs.appendNew(ROIid(uCellDownLeft, uCellUpRight, vCellDownLeft, vCellUpRight, interceptSensorID));
391 }
392
393 }
394}
DataType Phi() const
The azimuth angle.
Definition: B2Vector3.h:151
DataType Z() const
access variable Z (= .at(2) without boundary check)
Definition: B2Vector3.h:435
DataType Theta() const
The polar angle.
Definition: B2Vector3.h:153
DataType X() const
access variable X (= .at(0) without boundary check)
Definition: B2Vector3.h:431
DataType Y() const
access variable Y (= .at(1) without boundary check)
Definition: B2Vector3.h:433
DataType Perp() const
The transverse component (R in cylindrical coordinate system).
Definition: B2Vector3.h:200
PXDIntercept stores the U,V coordinates and uncertainties of the intersection of a track with an PXD ...
Definition: PXDIntercept.h:22
Specific implementation of SensorInfo for PXD Sensors which provides additional pixel specific inform...
Definition: SensorInfo.h:23
ROIid stores the U and V ids and the sensor id of the Region Of Interest.
Definition: ROIid.h:25
@ c_isActive
bit 11: SPTC is active (i.e.
SpacePoint typically is build from 1 PXDCluster or 1-2 SVDClusters.
Definition: SpacePoint.h:42
void setVxdID(VxdID::baseType user_vxdID)
set the sensor ID
Definition: VXDIntercept.h:77
void setCoorU(double user_coorU)
set the U coordinate of the intercept
Definition: VXDIntercept.h:70
void setCoorV(double user_coorV)
set the V coordinate of the intercept
Definition: VXDIntercept.h:71
double getCoorV() const
return the V coordinate of the intercept
Definition: VXDIntercept.h:60
VxdID::baseType getSensorID() const
return the sensor ID
Definition: VXDIntercept.h:68
double getCoorU() const
return the U coordinate of the intercept
Definition: VXDIntercept.h:59
const SensorInfoBase & getSensorInfo(Belle2::VxdID id) const
Return a referecne to the SensorInfo of a given SensorID.
Definition: GeoCache.cc:67
static GeoCache & getInstance()
Return a reference to the singleton instance.
Definition: GeoCache.cc:214
int getVCells() const
Return number of pixel/strips in v direction.
@ VXD
Any type of VXD Sensor.
int getUCells() const
Return number of pixel/strips in u direction.
int getVCellID(double v, bool clamp=false) const
Return the corresponding pixel/strip ID of a given v coordinate.
int getUCellID(double u, double v=0, bool clamp=false) const
Return the corresponding pixel/strip ID of a given u coordinate.
Class to uniquely identify a any structure of the PXD and SVD.
Definition: VxdID.h:33
baseType getLayerNumber() const
Get the layer id.
Definition: VxdID.h:96
double m_radiusCorrectionFactorL2
Correction factor for radial bias for L2: factor * charge / radius.
Definition: ROIFinder.h:98
unsigned short m_maximumROISizeV
maximum ROI size in v in pixel
Definition: ROIFinder.h:133
double m_minimumROISizeUL1
Minimum size of ROI in u-direction on L1 in pixel.
Definition: ROIFinder.h:110
const double c_ladderPhiL2[12]
Phi values of the ladders of L2.
Definition: ROIFinder.h:159
B2Vector3D m_BeamSpotPosition
B2Vector3D actually containing the BeamSpot position. This will be used as the starting point of the ...
Definition: ROIFinder.h:166
bool m_calculateROI
Calculate ROI in this findlet?
Definition: ROIFinder.h:61
double m_multiplierVL1
Multiplier term for v-direction on L1.
Definition: ROIFinder.h:126
double m_radiusCorrectionFactorL1
Correction factor for radial bias for L1: factor * charge / radius.
Definition: ROIFinder.h:96
const double c_centerZShiftLayer2[2]
Shift of the center of the active area of each sensor in a ladder of layer 2 For use of mhp_z > (leng...
Definition: ROIFinder.h:142
double m_minimumROISizeVL2
Minimum size of ROI in v-direction on L2 in pixel.
Definition: ROIFinder.h:116
double m_multiplierUL2
Multiplier term for u-direction on L2.
Definition: ROIFinder.h:124
const double c_centerZShiftLayer1[2]
Shift of the center of the active area of each sensor in a ladder of layer 1 For use of mhp_z > (leng...
Definition: ROIFinder.h:139
double m_multiplierVL2
Multiplier term for v-direction on L2.
Definition: ROIFinder.h:128
StoreArray< ROIid > m_storeROIs
ROIs StoreArray.
Definition: ROIFinder.h:71
double m_sinPhiCorrectionFactor
Correction factor for the sin(phi) modulation.
Definition: ROIFinder.h:100
const double c_activeSensorLength[2]
Length of the active region for L1 and L2.
Definition: ROIFinder.h:155
const double c_sensorMaxY
Maximum y coordinate if x-axis is perpendicular to the sensor:
Definition: ROIFinder.h:147
const double c_ladderPhiL1[8]
Phi values of the ladders of L1.
Definition: ROIFinder.h:157
double m_tolerancePhi
Allowed tolerance (in radians) phi to create intercepts per sensor.
Definition: ROIFinder.h:87
const double c_layerRadius[2]
Radius of the two layers.
Definition: ROIFinder.h:153
bool m_addVirtualIP
Add a virtual IP for the refit?
Definition: ROIFinder.h:77
StoreArray< PXDIntercept > m_storePXDIntercepts
PXDIntercepts StoreArray.
Definition: ROIFinder.h:69
B2Vector3D m_BeamSpotPositionError
B2Vector3D actually containing the BeamSpot position error.
Definition: ROIFinder.h:168
bool m_refit
Refit the tracks with m_ROIFitMethod.
Definition: ROIFinder.h:75
double m_zPositionCorrectionFactor
Correction factor for the z position.
Definition: ROIFinder.h:105
double m_cosPhiCorrectionFactor
Correction factor for the cos(phi) modulation.
Definition: ROIFinder.h:102
std::unique_ptr< QualityEstimatorBase > m_estimator
pointer to the selected QualityEstimator
Definition: ROIFinder.h:82
double m_bFieldZ
BField in Tesla.
Definition: ROIFinder.h:162
double m_minimumROISizeVL1
Minimum size of ROI in v-direction on L1 in pixel.
Definition: ROIFinder.h:112
const double c_shiftY
Shift of the center position in y if the x-axis is perpendicular to the sensor:
Definition: ROIFinder.h:151
const double c_sensorMinY
PXD is shifted to create the windmill structure.
Definition: ROIFinder.h:145
double m_minimumROISizeUL2
Minimum size of ROI in u-direction on L2 in pixel.
Definition: ROIFinder.h:114
unsigned short m_maximumROISizeU
maximum ROI size in u in pixel
Definition: ROIFinder.h:131
double m_multiplierUL1
Multiplier term in ROI size estimation For u: size = multiplier * 1/R + minimumROISize For v: size = ...
Definition: ROIFinder.h:122
double m_toleranceZ
Allowed tolerance (in cm) in z to create intercepts per sensor.
Definition: ROIFinder.h:89
const double c_activeSensorWidth
PXD sensors in L1 and L2 have the same size in u direction (=width):
Definition: ROIFinder.h:149
double sqrt(double a)
sqrt for double
Definition: beamHelpers.h:28
Container for complete fit/estimation results.
std::optional< B2Vector3D > p
momentum vector estimate from the QE

◆ beginEvent()

void beginEvent ( )
overridevirtual

Clear the object pools.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 169 of file ROIFinder.cc.

170{
171 // If no ROIs shall be calculated, return rightaway and don't do anything
172 if (not m_calculateROI) {
173 return;
174 }
175
177}
void beginEvent() override
Receive and dispatch signal for the start of a new event.

◆ beginRun()

void beginRun ( )
overridevirtual

Initialize the BField.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 145 of file ROIFinder.cc.

146{
147 // If no ROIs shall be calculated, return rightaway and don't do anything
148 if (not m_calculateROI) {
149 return;
150 }
151
153
155 m_estimator->setMagneticFieldStrength(m_bFieldZ);
156
157 DBObjPtr<BeamSpot> beamSpotDB;
158 if (beamSpotDB.isValid()) {
159 m_BeamSpotPosition = (*beamSpotDB).getIPPosition();
160 const TMatrixDSym posErr = (*beamSpotDB).getIPPositionCovMatrix();
161 m_BeamSpotPositionError.SetXYZ(sqrt(posErr[0][0]), sqrt(posErr[1][1]), sqrt(posErr[2][2]));
162 } else {
163 m_BeamSpotPosition.SetXYZ(0., 0., 0.);
165 }
166}
void SetXYZ(DataType x, DataType y, DataType z)
set all coordinates using data type
Definition: B2Vector3.h:464
bool isValid() const
Check whether a valid object was obtained from the database.
Class for accessing objects in the database.
Definition: DBObjPtr.h:21
void beginRun() override
Receive and dispatch signal for the beginning of a new run.
static const double T
[tesla]
Definition: Unit.h:120
static void getField(const double *pos, double *field)
return the magnetic field at a given position.
Definition: BFieldManager.h:91

◆ endRun()

void endRun ( )
overridevirtualinherited

Receive and dispatch signal for the end of the run.

Reimplemented from ProcessingSignalListener.

Definition at line 39 of file CompositeProcessingSignalListener.cc.

40{
42 psl->endRun();
43 }
45}
Interface for an algorithm part that needs to receive the module processing signals.
virtual void endRun()
Receive signal for the end of the run.

◆ exposeParameters()

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

Expose the parameters of the sub findlets.

Reimplemented from Findlet< const SpacePointTrackCand >.

Definition at line 33 of file ROIFinder.cc.

34{
35 Super::exposeParameters(moduleParamList, prefix);
36
37 moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "calculateROI"), m_calculateROI,
38 "Calculate PXDIntercepts and ROIs in this findlet based on a simple circle extrapolation (r-phi) and straight line extrapolation (z, theta)?",
40
41 moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "storePXDInterceptsName"), m_storePXDInterceptsName,
42 "Name of the PXDIntercepts StoreArray produced by SVDHoughTracking using a simple circle extrapolation in r-phi and a straight line extrapolation in theta.",
44
45 moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "storeROIsName"), m_storeROIsName,
46 "Name of the ROIs StoreArray produced by SVDHoughTracking using a simple circle extrapolation in r-phi and a straight line extrapolation in theta.",
48
49 moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "tolerancePhi"), m_tolerancePhi,
50 "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.",
52 moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "toleranceZ"), m_toleranceZ,
53 "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.",
55
56 moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "radiusCorrectionFactorL1"), m_radiusCorrectionFactorL1,
57 "Correct charge-dependent bias of the extrapolated hit on L1 with radiusCorrectionFactor * trackCharge / trackRadius.",
59 moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "radiusCorrectionFactorL2"), m_radiusCorrectionFactorL2,
60 "Correct charge-dependent bias of the extrapolated hit on L2 with radiusCorrectionFactor * trackCharge / trackRadius.",
62 moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "sinPhiCorrectionFactor"), m_sinPhiCorrectionFactor,
63 "Correct sin(trackPhi) dependent bias with sinPhiCorrectionFactor * sin(trackPhi).",
65 moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "cosPhiCorrectionFactor"), m_cosPhiCorrectionFactor,
66 "Correct cos(trackPhi) dependent bias with cosPhiCorrectionFactor * cos(trackPhi).",
68
69 moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "zPositionCorrectionFactor"), m_zPositionCorrectionFactor,
70 "Correction factor for the extrapolated z position.",
72
73 moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "minimumROISizeUL1"), m_minimumROISizeUL1,
74 "Minimum ROI size (in pixel) in u direction on L1.", m_minimumROISizeUL1);
75 moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "minimumROISizeVL1"), m_minimumROISizeVL1,
76 "Minimum ROI size (in pixel) in v direction on L1.", m_minimumROISizeVL1);
77 moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "minimumROISizeUL2"), m_minimumROISizeUL2,
78 "Minimum ROI size (in pixel) in u direction on L2.", m_minimumROISizeUL2);
79 moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "minimumROISizeVL2"), m_minimumROISizeVL2,
80 "Minimum ROI size (in pixel) in v direction on L2.", m_minimumROISizeVL2);
81
82 moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "multiplierUL1"), m_multiplierUL1,
83 "Multiplier term for ROI size estimation for L1 u direction. Usage: multiplierUL1 * 1/R + minimumROISizeUL1, with R in cm.",
85 moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "multiplierUL2"), m_multiplierUL2,
86 "Multiplier term for ROI size estimation for L2 u direction. Usage: multiplierUL2 * 1/R + minimumROISizeUL2, with R in cm.",
88 moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "multiplierVL1"), m_multiplierVL1,
89 "Multiplier term for ROI size estimation for L1 v direction. Usage: (1 + abs(tan(lambda)) * multiplierVL1) + minimumROISizeVL1.",
91 moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "multiplierVL2"), m_multiplierVL2,
92 "Multiplier term for ROI size estimation for L2 v direction. Usage: (1 + abs(tan(lambda)) * multiplierVL2) + minimumROISizeVL2.",
94
95 moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "maximumROISizeU"), m_maximumROISizeU,
96 "Maximum ROI size in u.", m_maximumROISizeU);
97 moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "maximumROISizeV"), m_maximumROISizeV,
98 "Maximum ROI size in v.", m_maximumROISizeV);
99
100
101 moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "refit"), m_refit,
102 "Refit the track with trackQualityEstimationMethod?", m_refit);
103 moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "addVirtualIP"), m_addVirtualIP,
104 "Add virtual IP to fit the tracks again for ROI creation?", m_addVirtualIP);
105 moduleParamList->addParameter(TrackFindingCDC::prefixed(prefix, "ROIFitMethod"), m_ROIFitMethod,
106 "Identifier which fit method to use. Valid identifiers are: [circleFit, tripletFit, helixFit]",
108
109}
virtual void exposeParameters(ModuleParamList *moduleParamList, const std::string &prefix)
Forward prefixed parameters of this findlet to the module parameter list.
Definition: Findlet.h:69
std::string m_ROIFitMethod
Refit with this estimator, options are circleFit, tripletFit, helixFit.
Definition: ROIFinder.h:79
std::string m_storeROIsName
Name of the ROIs StoreArray.
Definition: ROIFinder.h:67
std::string m_storePXDInterceptsName
Name of the PXDIntercepts StoreArray.
Definition: ROIFinder.h:65
void addParameter(const std::string &name, T &paramVariable, const std::string &description, const T &defaultValue)
Adds a new parameter to the module list.

◆ getDescription()

virtual std::string getDescription ( )
inlinevirtualinherited

Brief description of the purpose of the concrete findlet.

Definition at line 60 of file Findlet.h.

61 {
62 return "(no description)";
63 }

◆ getNProcessingSignalListener()

int getNProcessingSignalListener ( )
protectedinherited

Get the number of currently registered listeners.

Definition at line 60 of file CompositeProcessingSignalListener.cc.

61{
63}

◆ initialize()

void initialize ( )
overridevirtual

Initialize the StoreArrays.

Create the store arrays.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 112 of file ROIFinder.cc.

113{
114 // If no ROIs shall be calculated, return rightaway and don't do anything
115 if (not m_calculateROI) {
116 return;
117 }
118
120
122 m_storeROIs.registerInDataStore(m_storeROIsName);
123
126 m_multiplierUL1 < 0 or m_multiplierUL2 < 0 or
127 m_multiplierVL1 < 0 or m_multiplierVL2 < 0 or
128 m_tolerancePhi < 0 or m_toleranceZ < 0) {
129 B2ERROR("Please check the ROI size parameters. "
130 "None of minimumROISizeUL1, minimumROISizeUL2, minimumROISizeVL1, minimumROISizeVL2, "
131 "multiplierUL1, multiplierUL2, multiplierVL1, multiplierVL2, overlapU, overlapV must be < 0!");
132 }
133
134 if (m_ROIFitMethod == "tripletFit") {
135 m_estimator = std::make_unique<QualityEstimatorTripletFit>();
136 } else if (m_ROIFitMethod == "circleFit") {
137 m_estimator = std::make_unique<QualityEstimatorCircleFit>();
138 } else if (m_ROIFitMethod == "helixFit") {
139 m_estimator = std::make_unique<QualityEstimatorRiemannHelixFit>();
140 }
141 B2ASSERT("QualityEstimator could not be initialized with method: " << m_ROIFitMethod, m_estimator);
142
143};
void initialize() override
Receive and dispatch signal before the start of the event processing.

◆ terminate()

void terminate ( )
overridevirtualinherited

Receive and dispatch Signal for termination of the event processing.

Reimplemented from ProcessingSignalListener.

Reimplemented in StereoHitTrackQuadTreeMatcher< Belle2::TrackFindingCDC::HyperHough >, StereoHitTrackQuadTreeMatcher< Belle2::TrackFindingCDC::QuadraticLegendre >, and StereoHitTrackQuadTreeMatcher< Belle2::TrackFindingCDC::Z0TanLambdaLegendre >.

Definition at line 47 of file CompositeProcessingSignalListener.cc.

48{
50 psl->terminate();
51 }
53}
virtual void terminate()
Receive Signal for termination of the event processing.

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

◆ 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 149 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 139 of file ROIFinder.h.

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

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

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

◆ c_layerRadius

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

Radius of the two layers.

Definition at line 153 of file ROIFinder.h.

◆ c_sensorMaxY

const double c_sensorMaxY = 0.89
private

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

Definition at line 147 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 145 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 151 of file ROIFinder.h.

◆ m_addVirtualIP

bool m_addVirtualIP = true
private

Add a virtual IP for the refit?

Definition at line 77 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 166 of file ROIFinder.h.

◆ m_BeamSpotPositionError

B2Vector3D m_BeamSpotPositionError
private

B2Vector3D actually containing the BeamSpot position error.

Definition at line 168 of file ROIFinder.h.

◆ m_bFieldZ

double m_bFieldZ = 1.5
private

BField in Tesla.

Definition at line 162 of file ROIFinder.h.

◆ m_calculateROI

bool m_calculateROI = false
private

Calculate ROI in this findlet?

Definition at line 61 of file ROIFinder.h.

◆ m_cosPhiCorrectionFactor

double m_cosPhiCorrectionFactor = 0.0
private

Correction factor for the cos(phi) modulation.

Definition at line 102 of file ROIFinder.h.

◆ m_estimator

std::unique_ptr<QualityEstimatorBase> m_estimator
private

pointer to the selected QualityEstimator

Definition at line 82 of file ROIFinder.h.

◆ m_initialized

bool m_initialized = false
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 131 of file ROIFinder.h.

◆ m_maximumROISizeV

unsigned short m_maximumROISizeV = 100
private

maximum ROI size in v in pixel

Definition at line 133 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 110 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 114 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 112 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 116 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 122 of file ROIFinder.h.

◆ m_multiplierUL2

double m_multiplierUL2 = 600
private

Multiplier term for u-direction on L2.

Definition at line 124 of file ROIFinder.h.

◆ m_multiplierVL1

double m_multiplierVL1 = 0.8
private

Multiplier term for v-direction on L1.

Definition at line 126 of file ROIFinder.h.

◆ m_multiplierVL2

double m_multiplierVL2 = 0.8
private

Multiplier term for v-direction on L2.

Definition at line 128 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 96 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 98 of file ROIFinder.h.

◆ m_refit

bool m_refit = true
private

Refit the tracks with m_ROIFitMethod.

Definition at line 75 of file ROIFinder.h.

◆ m_ROIFitMethod

std::string m_ROIFitMethod = "helixFit"
private

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

Definition at line 79 of file ROIFinder.h.

◆ m_sinPhiCorrectionFactor

double m_sinPhiCorrectionFactor = 0.0
private

Correction factor for the sin(phi) modulation.

Definition at line 100 of file ROIFinder.h.

◆ m_storePXDIntercepts

StoreArray<PXDIntercept> m_storePXDIntercepts
private

PXDIntercepts StoreArray.

Definition at line 69 of file ROIFinder.h.

◆ m_storePXDInterceptsName

std::string m_storePXDInterceptsName = "SVDHoughPXDIntercepts"
private

Name of the PXDIntercepts StoreArray.

Definition at line 65 of file ROIFinder.h.

◆ m_storeROIs

StoreArray<ROIid> m_storeROIs
private

ROIs StoreArray.

Definition at line 71 of file ROIFinder.h.

◆ m_storeROIsName

std::string m_storeROIsName = "SVDHoughROIs"
private

Name of the ROIs StoreArray.

Definition at line 67 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 52 of file CompositeProcessingSignalListener.h.

◆ m_terminated

bool m_terminated = false
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 87 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 89 of file ROIFinder.h.

◆ m_zPositionCorrectionFactor

double m_zPositionCorrectionFactor = 1.0
private

Correction factor for the z position.

Definition at line 105 of file ROIFinder.h.


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