feat: ITK SeedFinder integration

[LuisFelipeCoelho]

This PR introduces several changes to the SeedFinder algorithm:

1. Introduced a variable radius range (rMinMiddleSP, rMaxMiddleSP) for the middle SP:

• Obtained by a floor approximation to an even number of the minimum and maximum SP radius found plus a ΔR (deltaRMiddleSPRange) defined by the user
• An Extent rRangeSPExtent is used to get the min and max values
• This cut is only applied if a boolean useVariableMiddleSPRange defined by the user is true
• If useVariableMiddleSPRange is set to false, the vector rRangeMiddleSP can be used to define a fixed r range. If the vector is empty the cuts won't be applied.

2. Check if middle SP is on the first or last disk with zMax and zMin

3. Introduced seedConfirmation step that requires a minimum number of top SP depending on whether the middle SP is in the central or forward region:

• If the boolean seedConfirmation is set to true the cut will be applied

4. Changed the order of the loops over the top and bottom space points:

• Looping over the top SP first. The algorithm doesn’t need to unnecessarily loop over the bottom SP if the minimum number of top SP is not greater than nTopSeedConf when seedConfirmation is set to true

5. Introduced deltaRMinBottomSP, deltaRMaxBottomSP, deltaRMinTopSP and deltaRMaxTopSP:

• ΔR minimum and maximum between middle and top/bottom SP can now be defined separately, as opposed to having the same value for all

6. Added a cut on A and B coefficients for the top and bottom SP

During SP comparison:

7. linCircleBottom and linCircleTop are sorted by cotTheta of the bottom and top space points inside transformCoordinates

8. Added the t0 index

9. In the cut on the compatibility between the r-z slope of the two seed segments, deltaCotTheta2 - error2 > 0 was changed to deltaCotTheta2 - error2 > sigmaSquaredScatteringMinPt, where sigmaSquaredScatteringMinPt is an approximate worst case multiple scattering term assuming the lowest pT we allow and the estimated theta angle

• dCotThetaMinusError2 > scatteringInRegion2 cut removed
• if deltaCotTheta < 0 → break
• else → t0=t+1 and continue

10. Added a second 1/tan(theta) compatibility cut (deltaCotTheta2 - error2) * S2 > B2 * iSinTheta2 * m_config.kConstant * std::pow(2 / m_config.pTPerHelixRadius, 2)

• if deltaCotTheta < 0 → break
• else → t0=t and continue

11. (deltaCotTheta2-error2 > 0) && (dCotThetaMinusError2 > p2scatter * m_config.sigmaScattering * m_config.sigmaScattering cut removed

12. Added the evaluation of eta of the seed

@noemina @asalzburger @paulgessinger @robertlangenberg

[codecov]

Codecov Report

Merging #1084 (b44ab7a) into main (f4cc9e3) will decrease coverage by 0.22%.
The diff coverage is 0.00%.

@@            Coverage Diff             @@
##             main    #1084      +/-   ##
==========================================
- Coverage   48.40%   48.18%   -0.23%     
==========================================
  Files         341      341              
  Lines       17563    17644      +81     
  Branches     8296     8323      +27     
==========================================
  Hits         8502     8502              
- Misses       3286     3367      +81     
  Partials     5775     5775              

Impacted Files	Coverage Δ
Core/include/Acts/Seeding/SeedFinderUtils.ipp	0.00% <0.00%> (ø)
Core/include/Acts/Seeding/Seedfinder.hpp	0.00% <ø> (ø)
Core/include/Acts/Seeding/Seedfinder.ipp	0.00% <0.00%> (ø)
Core/include/Acts/Seeding/SeedfinderConfig.hpp	0.00% <ø> (ø)

---

Continue to review full report at Codecov.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update f4cc9e3...b44ab7a. Read the comment docs.

[robertlangenberg]

Hi @LuisFelipeCoelho, that's an impressive list of changes :)

I have a couple of clarification questions: Could you explain these two points in a bit more detail? I'm not sure what you mean.

Obtained by a floor approximation to an even number of the minimum and maximum SP radius found plus a ΔR (deltaRMiddleSPRange) defined by the user

An Extent rRangeSPExtent is used to get the min and max values

For efficiency I tried to exclude space points which can be cut by looking only at a single space point already during the grid building step, but middle sp being in the outermost loop it probably doesn't matter all that much. The check for zMin and zMax is one such example, which is already applied during the grid creation (so there shouldn't be any sp with z > zMax.

3 ) seems very ATLAS specific, isn't this something that could be implemented in the experiment specific cuts?

4 ) did you measure the performance change from this?

6 ) I don't exaclty understand the cut, but it also sounds like it would be more efficient to exclude these in the grid building step. The Grid is separate from the Seedfinder exactly for this reason, to be able to more intelligently select space points than what the SPGrid offers, i.e. replacing the SPGrid with something else. Using cut 1) and 5) e.g. it sounds like it would be reasonable to have three grids: one with all SP in the middle range, one with SP in the bottom range and one with SP in the top range, which could reduce the number of iterations significantly.

9 ) and 10 ) Please check to factor this out as discussed. also we should find out if it is (significantly) faster and how much and under which conditions this deviates from the accurate scattering?

[robertlangenberg]

Regarding point 3)

In the SeedFilter, the experimentCuts are applied in two locations. The "minimum number of top SP for confirmation, depending on the detector region" introduced in this PR is very specific. The Seedfinder itself is unaware of any layers (though of course you could define a forward region for any detector). Instead of putting this functionality into the Seedfinder algorithm itself, I think this is so ATLAS-specific that it would make sense to move it to such an experiment-specific cut which would be ATLAS-only and not necessarily implemented in Acts.

---

after a chat we decided to put this in the algorithm directly as it allows rejecting middle SP for which only few compatible top SP exist at an early stage (before even looking at bottom SP), such that this could save time.

[LuisFelipeCoelho]

Hi! @robertlangenberg

Regarding the other comments:

1. Obtained by a floor approximation to an even number of the minimum and maximum SP radius found plus a ΔR (deltaRMiddleSPRange) defined by the user
   An Extent rRangeSPExtent is used to get the min and max values

What I meant is that I am filling an extent with (x, y, z) information of the SP in the SeedingAlgorithm.cpp. Then, in the SeedFinder, I get the maximum and minimum R values from that extent and use them to calculate rMinMiddleSP and rMaxMiddleSP. In Athena 21.9 they do an approximation to an even number, which I believe is the same as std::floor( value/2 ) * 2

2. I removed the cut on zMin and zMax, since it is already applied during the grid creation, as you said.
   Do you think check 1 should also be applied during grid creation?

3. I compared the performance of this change, and looping over the top SP first seems to be a bit faster.

9. and 10. I actually managed to get the same results without the magic kConstant.
   I also checked the performance and it is the same, so I don’t think it is worth using the approximation.

[paulgessinger]

I think the only thing that remains are the root file hash failures. This means that the output of the following root files changes:

• test_seeding__estimatedparams.root
• test_seeding__performance_seeding_trees.root
• test_ckf_tracks_example_full_seeding__performance_seeding_trees.root
• test_ckf_tracks_example_full_seeding__performance_seeding_trees.root
• test_ckf_tracks_example_full_seeding__trackstates_ckf.root
• test_ckf_tracks_example_full_seeding__tracksummary_ckf.root

However, that doesn't mean that there's something wrong with this PR necessarily. I assume some change in output is expected, because the hash will change if the outputs are not exactly identical (event ordering is ignored). If the seeding algorithms are changed, the output might change as well.

Can you

1. Check whether you expect the output to be the same? I.e. do you expect the "default" case to produce identical output as before? If you do, then there's maybe a bug somewhere
2. If you don't, check (at least briefly) that the new root output files contain sensible contents. Basically just check that it doesn't look broken, since a broken reference doesn't help us a lot.

If you conclude the root file changes are expected and acceptable, we can just update the reference hash, which should make the CI go green this PR ready to go.

[LuisFelipeCoelho]

We have studied the performance and we saw a degradation in tracking efficiency both for seeds and tracks when sorting the SP in cotangent of theta and applying cuts based on the sorting. However, since we want to have this code in for emulating the ITk behaviour, I added a new boolean in the SeedFinderConfig called EnableCutsForSortedSP which enables the sorting and the cuts in cotTheta if needed. It is false by default and the code runs as before.

The performance should also be tested once the code is integrated in Athena for proper testing with ITk.

[paulgessinger]

I think the reduction in coverage is acceptable.