ACTS Developers Meeting

Tuesday 3 Nov 2026, 17:00 → 18:00 Europe/Zurich

ZOOM ONLY

Alexander J Pfleger (University of Innsbruck (AT)), Andreas Salzburger (CERN)

General discussion on developments in Acts.

Zoom passcode is visible for logged in users, if you don't have an account and want to join, let us know at acts-developers@cern.ch

17:00 → 17:30 Overview & Discussion on Breaking Changes for v49

Speaker: Andreas Stefl (CERN)

2026-11-03 acts dev meeting - towards v49.pdf

[Alexander J Pfleger] 21:32:04
Today we have two points on the agenda. One is discussion on the next breaking changes for version 49, which should come soon

[Alexander J Pfleger] 21:32:18
To figure out what we still need for this led by Andy. And then for the second half of the meeting, we have by Carlo

[Alexander J Pfleger] 21:32:30
Or the transform-based CEDA discussion that's C-targeted

[Alexander J Pfleger] 21:32:37
Do you have anything you would like to throw in or mention for this meeting or have like a quick question on something

[Paul Gessinger-Befurt] 21:32:46
I just wanted to mention, I tried to add like a new section to the auto-generated slides for review follow-up. If we have enough time today, I would like to try to go through that. But if we don't, I think the contributions are more important.

[Alexander J Pfleger] 21:33:00
Okay, sounds good in case we end earlier, then I will pop that in as well. Thanks.

[Alexander J Pfleger] 21:33:08
Then I think we can directly go to Andy. Would you like to share your screen already?

[Andreas Stefl] 21:33:15
Hope you can see that.

[Alexander J Pfleger] 21:33:18
Yeah, it's the slides

[Alexander J Pfleger] 21:33:25
Full screen now. It's working well.

[Andreas Stefl] 21:33:26
Okay, good.

[Andreas Stefl] 21:33:30
Then, yeah, similar to last time, I would give a quick overview of the…

[Andreas Stefl] 21:33:39
breaking PRs.

[Andreas Stefl] 21:33:42
And if people are connected to who are the authors of this PR, it would be nice if you could say one or two words about it. Otherwise, I will try to give

[Andreas Stefl] 21:33:55
a summary. So where do we stand today? Today we have the

[Andreas Stefl] 21:34:01
latest tag was end of last week with 48.4.

[Andreas Stefl] 21:34:07
And there are many, many open breaking PRs. So I counted 16 while two PRs are basically still missing or two to one for sure and one I would propose.

[Andreas Stefl] 21:34:22
And my proposal in terms of release schedule would be to try to take a minor version this week, maybe towards end of the week.

[Andreas Stefl] 21:34:35
And then clear the schedule basically for prioritizing breaking changes and prioritizing is important, I think, to keep the window as short as possible.

[Andreas Stefl] 21:34:47
So I think we should aim one or a maximum two weeks for the breaking cycle.

[Andreas Stefl] 21:34:55
So then I have one slide for each PR basically.

[Andreas Stefl] 21:35:01
Um, the first one is, I think, open for quite some time.

[Andreas Stefl] 21:35:06
And I don't see Joanna connected. So as far as I understand, this is only breaking because it touches the conversion API from that tray that we have in our plugins.

[Andreas Stefl] 21:35:23
I cannot really say more than this. I think, I guess it should be as straightforward. I don't know if anybody had a look at this already.

[Paul Gessinger-Befurt] 21:35:31
Yeah, I think this is fine. It's technically breaking because we consider this breaking now and we're changing the return type we were discussing potentially making this non-breaking, but ultimately decided to wait.

[Andreas Stefl] 21:35:44
Mm-hmm. That makes sense.

[Paul Gessinger-Befurt] 21:35:45
For the 29

[Andreas Stefl] 21:35:48
Then, the next one is, uh, from me, and this… the ID

[Andreas Stefl] 21:35:55
here is that currently our.

[Andreas Stefl] 21:35:59
navigation doesn't handle the target surface and we have a separate portal to do the target surface.

[Andreas Stefl] 21:36:08
Basically navigation, but also aborting. And the idea here would be to combine all of the navigation.

[Andreas Stefl] 21:36:21
Um… response.

[Andreas Stefl] 21:36:22
responsibility is in one component, and we already have.

[Andreas Stefl] 21:36:27
The ingredients for that, so since, uh…

[Andreas Stefl] 21:36:31
Since a few releases, we support these additional services. Previously,

[Andreas Stefl] 21:36:38
I think it was called free surfaces and I think we, and external surfaces as well. So the idea is to give the navigator additional services than the ones in the tracking geometry.

[Andreas Stefl] 21:36:51
And the target surface is usually exactly this.

[Andreas Stefl] 21:36:55
That you have a surface that is outside the tracking geometry that you want to reach. And then the additional.

[Andreas Stefl] 21:37:05
uh, work is to then basically abort when you reach the surface, which can be, you know, just an if statement, basically.

[Andreas Stefl] 21:37:12
And the way this is implemented right now is that all our navigators now have these additional surfaces and the void navigator doesn't have anything except these additional surfaces.

[Andreas Stefl] 21:37:27
This change composes the void navigator into all other navigators and then you basically end up with two navigation streams. And internally.

[Andreas Stefl] 21:37:39
You always check the next target from both navigation streams and then you pick the one that is closer, blending the different, um…

[Andreas Stefl] 21:37:49
candidates, uh…

[Andreas Stefl] 21:37:51
into one stream of candidates.

[Andreas Stefl] 21:37:56
So any questions or comments to this one?

[Paul Gessinger-Befurt] 21:38:02
So if I understand correctly that this essentially uses the white… that gets the code sharing through the void navigator, essentially.

[Andreas Stefl] 21:38:06
Exactly.

[Andreas Stefl] 21:38:09
Okay.

[Paul Gessinger-Befurt] 21:38:09
Pretty good idea.

[Paul Gessinger-Befurt] 21:38:18
No other thoughts. I think it's a good idea

[Andreas Stefl] 21:38:24
Good. Then I think we can move on to the next one. This is a shorter one. So there was already a change to get the number of split hits into the track EDM, but since our TrackEDM can be overwritten on the user side.

[Andreas Stefl] 21:38:44
I'm making this required column is a breaking change. So previously there was basically a compile guard to see if this column exists or not. And now we just require this.

[Andreas Stefl] 21:38:58
concepts and then can rely on this.

[Andreas Stefl] 21:39:02
in everywhere else, basically. So it's a very minor change.

[Andreas Stefl] 21:39:11
Okay, then moving on to the next one. This is from Thomas.

[Andreas Stefl] 21:39:20
I think you're connected. Do you want to say one or two words about this?

[Thomas Aksdal] 21:39:27
Yeah, it's just a small performance change. It's epic breaking just because some getters, spacebones and cotle getters are removed. Yeah

[Andreas Stefl] 21:39:39
Yeah, thank you. I think, uh, yeah, as Thomas said, on the user side, this shouldn't really be breaking because the APIs, we use the API only then in the triplet finder basically. But since it public API, it's technically breaking.

[Andreas Stefl] 21:40:02
Good, then moving on to the next one. This one is from Stephen. Do you want to add something here?

[Stephen] 21:40:09
Yes, hello. So a few things about this. So first of all, I wasn't sure whether or not to mark this as breaking. I went with it in the end because it changes the way TrackCC is built.

[Stephen] 21:40:21
And that is now used by consumers. So I think breaking is the right choice. I hadn't had it on my radar as going in for 49, but I'm definitely down with putting in for 49.

[Stephen] 21:40:33
The point of this is that when we did the Tractice integration, I accrued a bunch of technical debt in order to keep the source code as a one-to-one copy.

[Stephen] 21:40:45
And part of that debt lives in the ACTS build system.

[Stephen] 21:40:50
So what I want to do is I want to take that debt out and I want to make sure that Traxysi manages all of its own settings.

[Stephen] 21:41:00
And then ACTS doesn't have to mess with them. So I think that's a much more clean separation of concerns.

[Stephen] 21:41:06
And then this also moves towards this concept that we've talked about of making track CC a component of ACTS.

[Stephen] 21:41:16
means that eventually the mechanism for compiling TractorC by itself will disappear. This is one step towards that.

[Stephen] 21:41:25
So there were some comments by Paul, which I haven't addressed yet, but if we want to get this in for 49, then definitely I can get onto that.

[Andreas Stefl] 21:41:34
Yeah, thank you, sounds good to me. Any other comments to this one?

[Attila Krasznahorkay] 21:41:41
Just the quick, well, not so much technical, but more naming question. So

[Attila Krasznahorkay] 21:41:51
I think I said this a couple of times that, and I think I might be alone in this opinion.

[Attila Krasznahorkay] 21:42:00
I was thinking that eventually we would get rid of the TrekCC name.

[Attila Krasznahorkay] 21:42:08
And I wonder if we're at

[Attila Krasznahorkay] 21:42:11
least the ACTS cache variables, this would be a good time to do this so that instead of naming all of these things ACTS_TrackCC foo.

[Attila Krasznahorkay] 21:42:25
We would come up with some Trek CC last names for ACTS.

[Attila Krasznahorkay] 21:42:31
Because…

[Attila Krasznahorkay] 21:42:33
This was my…

[Attila Krasznahorkay] 21:42:36
idea.

[Attila Krasznahorkay] 21:42:38
That eventually we would just call it the ACTS GPU or ACTS device or

[Attila Krasznahorkay] 21:42:45
Whatever things.

[Attila Krasznahorkay] 21:42:48
So, yeah.

[Paul Gessinger-Befurt] 21:42:49
I don't have a strong opinion on this, to be honest. I don't think it's the end of the world if we keep the name sort of as a branding to identify subparts of the code. I think there's precedent in the world of software, essentially, to have, even if it's in a project

[Paul Gessinger-Befurt] 21:43:05
And on subsystems with specific names, but I could be convinced either way, I think.

[Attila Krasznahorkay] 21:43:10
Okay. How do you feel, Paul, about the…

[Attila Krasznahorkay] 21:43:15
coding style because that I thought we would for sure

[Attila Krasznahorkay] 21:43:21
migrate to ACTS's naming conventions and everything like that.

[Paul Gessinger-Befurt] 21:43:26
I mean, if there's willingness to do it, it would be nice, but for me, this is not a deal breaker in the end. I mean, so I mean, I think it's, you know, nicer if it's uniform, but I don't think it's the absolute end of the world in a subtree

[Paul Gessinger-Befurt] 21:43:43
the convention is different.

[Attila Krasznahorkay] 21:43:46
Interesting, because, yeah, I was operating absolutely under the assumption what we discussed, I think, about two years ago.

[Attila Krasznahorkay] 21:43:57
Yeah, eventually, we would harmonize everything, like actually harmonize.

[Paul Gessinger-Befurt] 21:44:01
I mean, this is

[Paul Gessinger-Befurt] 21:44:04
I'm okay with that, but I don't think we should just do this because I would want to, right? I think the reason for this should be if we agree that this is a good idea to have uniform and then for that reason, we decide to go in this direction. I don't think the point is to make

[Paul Gessinger-Befurt] 21:44:21
That the point of conventions is not to make the checker happy, the point of conventions is to make it kind of uniform, and everybody agrees that it's a good idea, I think, in general.

[Attila Krasznahorkay] 21:44:26
Yeah.

[Paul Gessinger-Befurt] 21:44:30
So I think we can still do that. I don't think this is a requirement for either removing the name or the other way around, though.

[Paul Gessinger-Befurt] 21:44:37
So I don't think before when we drop the name, we have to have the coding conventions in place or the other way around.

[Attila Krasznahorkay] 21:44:43
Again, I brought up the question because as long as we are introducing a whole bunch of new variables in this pull request, this could be a good opportunity.

[Attila Krasznahorkay] 21:44:55
either change or not change naming for right now for the cache variables.

[Paul Gessinger-Befurt] 21:45:07
Oh, Steven, what do you think

[Stephen] 21:45:08
I mean…

[Stephen] 21:45:10
I rather like the Track CC name, I'm not particularly attached to it, I'm happy to go anyway. We can always put this in and then deprecate the TraxCC name later.

[Andreas Stefl] 21:45:20
Yeah, I think this might be a discussion for another breaking or let's say a discussion for another meeting and then a discussion for another major release. But I wouldn't convoluted this with this change.

[Attila Krasznahorkay] 21:45:34
No, but let me be very clear. I'm not saying that inside the track CC subdirectory, we would change the

[Attila Krasznahorkay] 21:45:44
trick CC cache variable names. So right now I looked quickly at the pull request. What happens is that a whole bunch of ACTS prefixed variables get introduced, new variables get introduced, and then they are all translated into

[Attila Krasznahorkay] 21:46:00
to trekcc prefixed variables inside the trickcc subdirectory. So what I'm asking that for these new variables that we are introducing for ACTS.

[Attila Krasznahorkay] 21:46:13
Whether we want to call them ACTS_TrackCC underscore stuff.

[Attila Krasznahorkay] 21:46:19
Or we want to now introduce.

[Attila Krasznahorkay] 21:46:23
Maybe future looking variables because if we introduce ACTS trackCC foo, then…

[Attila Krasznahorkay] 21:46:32
Then they will definitely not change ever again, because that would once again be a…

[Attila Krasznahorkay] 21:46:38
A breaking change?

[Stephen] 21:46:41
Well, why can't we change them again? I mean, they're changing now.

[Stephen] 21:46:44
It doesn't cost anything.

[Attila Krasznahorkay] 21:46:47
Psychologically, I don't think it will change. If now we don't change it, then I don't see it ever changing.

[Andreas Salzburger] 21:46:57
Just a question for my… sorry, I had to accumulate from the AI study group. Are these one-to-one correspondence, or are we introducing some logic there? If you have some ACTS TrackCC

[Andreas Salzburger] 21:47:12
build variable that then gets translated or steered setting track CC ones aren't we just adding a layer on top of a layer or what's the… what's the

[Stephen] 21:47:24
So to motivate this a little bit, in my mind, this is an intermediate step.

[Stephen] 21:47:31
I want to eventually get rid of all of the internal TraxyCC

[Stephen] 21:47:36
We make variables. But for now, what I would like to do is have support for both the component model and the standalone model, and then we drop support for a standalone model on short notice within.

[Stephen] 21:47:51
X many weeks, months, release cycles.

[Stephen] 21:47:54
And then we can get rid of all of that. The point of this as an intermediate step is that this fixes the public API for the build from ACTS's perspective. And then we can do whatever we want on the inside of TrackCC.

[Andreas Salzburger] 21:48:05
Yeah, understood

[Stephen] 21:48:08
breaking anything, that's the point.

[Attila Krasznahorkay] 21:48:12
Yeah, and that part, I'm on board with.

[Andreas Salzburger] 21:48:12
Understood

[Attila Krasznahorkay] 21:48:16
I'm happy with this approach. It's just that, um…

[Attila Krasznahorkay] 21:48:22
With this change coming in, we will have to make some very

[Attila Krasznahorkay] 21:48:26
manageable changes in Atlas externals, which is fine. Let's go for it. But this is why I'm saying that we have to do that change now.

[Attila Krasznahorkay] 21:48:38
the willingness of changing names again in the future will be less and less, because, well, at that point, once again,

[Attila Krasznahorkay] 21:48:47
The scene would have to be adjusted whatever other project would have to be adjusted.

[Attila Krasznahorkay] 21:48:52
It's becoming less and less likely that we will change these names.

[Attila Krasznahorkay] 21:48:57
Right now we are introducing new names.

[Attila Krasznahorkay] 21:49:01
Here we could possibly get rid of the TrekCC name.

[Attila Krasznahorkay] 21:49:07
But, okay.

[Paul Gessinger-Befurt] 21:49:11
Yeah, maybe we can have another round of like in-person discussion about kind of the general future of the naming. I personally don't think we should necessarily complicate this. I think

[Paul Gessinger-Befurt] 21:49:20
I don't think this needs to be held until we have the final name configuration. I think having ACT struct and then potentially dropping the TrackCC in future is fine. I don't think the fallout from adapting downstream build is going to be a huge problem, especially if it's another breaking version. So I think I would

[Paul Gessinger-Befurt] 21:49:38
you know, tentatively go with this, if there's no technical reason not to do

[Attila Krasznahorkay] 21:49:43
Okay.

[Andreas Stefl] 21:49:49
Then moving on to the next one, which I think is from Andy. Do you want to say one or two words about this one?

[Andreas Salzburger] 21:49:59
So, yes, actually, unfortunately didn't get to there. Powell had a comment that we could make this unbreaking

[Andreas Salzburger] 21:50:07
By basically

[Andreas Salzburger] 21:50:11
Swallowing the fact that the eventual name that will stay will not be protosurface material, but proto-surface grid, or grid surface material, one of the two. So basically, with a little bit of work, we could make this unbreaking, keep the old interface, and just reintroduce a new class. So basically what this did was a templated class

[Andreas Salzburger] 21:50:34
With either bin utilities or either representing grid material to be filled or old bin material. And that's

[Andreas Salzburger] 21:50:45
Probably the better way to go there, to be honest, than it's a bit cleaner, so I'll try to do that tomorrow and see then we can remove that from the… from the breaking list

[Paul Gessinger-Befurt] 21:50:56
Yeah, and just to point out, I think even though, I guess if we have a breaking opportunity, we can also merge it as breaking. I think it's still a good idea to try to be careful with kind of code level

[Paul Gessinger-Befurt] 21:51:09
breaking changes, because I think it's just good practice to be mindful of, let's say, the blast radius of changes. So I think even though we have the opportunity to to correctly label it and merge this as is, I think it's a it's a good idea to try and keep compatibility if we can

[Andreas Stefl] 21:51:26
Okay, then let's see how far you can get Andy and then we can.

[Andreas Stefl] 21:51:34
re-evaluative if we need a braking change or not.

[Andreas Stefl] 21:51:40
Then, uh, the next one, I think, is from PF.

[Andreas Stefl] 21:51:44
I don't see connected. This changes the…

[Andreas Stefl] 21:51:50
API of the, I think, interpolated weird.

[Andreas Stefl] 21:51:55
Where there seems to be a bug and with mixing conventions.

[Andreas Stefl] 21:52:01
Yep.

[Paul Gessinger-Befurt] 21:52:02
But the problem here is really that previously, I think we were converting out the field cell endpoints at corner points, and then we were using those to interpolate between

[Paul Gessinger-Befurt] 21:52:17
The problem is, if you have a polar coordinate magnetic field and you convert out the endpoints and then you interpolate between those endpoints in Cartesian coordinates, you get wrong fields. So what this does basically, I think, is essentially return

[Paul Gessinger-Befurt] 21:52:32
the local field, and then it needs to run the local to global on each feed value each time, rather than caching the conversion. The problem with this, and I think I commented this, but maybe not, is this probably has performance implications

[Paul Gessinger-Befurt] 21:52:46
Because in principle, anytime you have anything that doesn't require this, you know, also adding an extra matrix multiplication on top

[Paul Gessinger-Befurt] 21:52:59
So yeah, I don't, I mean, I'm not 100% sure if this is

[Paul Gessinger-Befurt] 21:53:06
I mean, maybe one solution will be to specialize, let's say, linear transformed interpolated fields. So the ones where the local to global doesn't depend on the position from

[Paul Gessinger-Befurt] 21:53:21
And once we're done for the polar coordinate case.

[Paul Gessinger-Befurt] 21:53:25
Or we tolerate the, the extra cost, but I think at the very least, I would want to see what the impact is.

[Paul Gessinger-Befurt] 21:53:32
in a magnetic field workflow. And I think we're shielded from this, because in the Atlas case, for example.

[Paul Gessinger-Befurt] 21:53:40
We're using the, like, a different caching layer further down, where I I don't actually know how it's done, but might be doing the same thing.

[Andreas Stefl] 21:53:54
So, uh, is this already commented on the pull request with the potential?

[Paul Gessinger-Befurt] 21:53:59
I believe so, but I'm not sure

[Andreas Stefl] 21:53:59
Okay, yeah, then let's see what PF says, I guess otherwise we could also try to…

[Andreas Stefl] 21:54:07
To measure this on ODD.

[Andreas Stefl] 21:54:10
And then they can make an informed decision, I guess.

[Andreas Stefl] 21:54:17
Then…

[Andreas Stefl] 21:54:19
Which one is this? Ah, this one is, I think…

[Andreas Stefl] 21:54:22
think from Yankee.

[Andreas Stefl] 21:54:25
is a bigger pull request with many alignment changes.

[Andreas Stefl] 21:54:32
And one of them is breaking where

[Andreas Stefl] 21:54:36
It seems to need the direction for one of the derivatives on the surface.

[Andreas Stefl] 21:54:43
So, I think this was already discussed also in the alignment meeting.

[Andreas Stefl] 21:54:49
meeting, or at least with alignment people.

[Andreas Stefl] 21:54:53
Um, this seems to be on a straight path forward, um, and I don't see Yankee connected, so…

[Andreas Stefl] 21:55:04
Then, I think we can move on to the next one, this one from my side where I tried together with one of the coding agents to clean up the Atlas step by a little bit.

[Andreas Stefl] 21:55:17
Um, because there is a lot of…

[Andreas Stefl] 21:55:19
code duplication and also it doesn't behave correctly in some cases.

[Andreas Stefl] 21:55:28
There was also hard-coded local to global and global to local, which…

[Andreas Stefl] 21:55:34
We can just go through our implementations on the…

[Andreas Stefl] 21:55:39
the surfaces.

[Andreas Stefl] 21:55:42
And this is technically breaking because it changes the state.

[Andreas Stefl] 21:55:47
layout and fields in the stepper.

[Andreas Stefl] 21:55:52
And yeah, also add some documentation to the stepper.

[Andreas Stefl] 21:55:59
So any questions to this one?

[Paul Gessinger-Befurt] 21:56:02
So I think I'm not sure if I commented this, but at least I thought about it, is should we potentially either here or as a follow up, just make the RTMS step a detail as well? Because in principle, we don't want anyone to use this. And in particular, we don't want anyone to couple to

[Paul Gessinger-Befurt] 21:56:19
Any of the API of the type. So I don't know what you think.

[Andreas Stefl] 21:56:22
Yeah, I actually have one item at the very end, so we could come back to this there.

[Paul Gessinger-Befurt] 21:56:28
Okay

[Andreas Stefl] 21:56:30
Okay, then moving on.

[Andreas Stefl] 21:56:33
I think this is also from PF.

[Andreas Stefl] 21:56:37
Um…

[Andreas Stefl] 21:56:38
It seems to be a performance optimization that requires

[Andreas Stefl] 21:56:43
changing the parameters in the linearized track. If I understand it correctly, right now we take the sub matrix somewhere inside the code and then run the inverse.

[Andreas Stefl] 21:56:59
And what he does here is just put it in

[Andreas Stefl] 21:57:02
as an input and don't run the inverse all the time.

[Andreas Stefl] 21:57:07
Yeah, Paul, you I think, had a look briefly.

[Paul Gessinger-Befurt] 21:57:11
Yeah.

[Paul Gessinger-Befurt] 21:57:12
So I have some feedback, I didn't look at this earlier, unfortunately, but it might be still a little bit of time to get this in shape. So I think one concern I have is that we're storing the weight matrix twice now, one time without time. And I think in principle we could either

[Andreas Stefl] 21:57:22
Yeah, .

[Paul Gessinger-Befurt] 21:57:28
over… as you use, essentially, a 6x6 matrix unconditionally, and then introduce a Boolean that steers whether it uses time or not, so we can still determine it at runtime, or we even use a variant to dispatch between 5 and 6 dimensions, and then

[Paul Gessinger-Befurt] 21:57:43
do the correct inversion

[Andreas Stefl] 21:57:45
Yeah, that makes sense to me.

[Paul Gessinger-Befurt] 21:57:47
I commented this. Let's see if what we have things.

[Andreas Stefl] 21:57:50
Okay, yep, it's pretty good.

[Andreas Stefl] 21:57:56
Good done. Moving on to the next one. I think this one is also from Andy.

[Andreas Salzburger] 21:58:02
Yes, that is a clean removal of everything which was related to the volume material so far

[Andreas Salzburger] 21:58:16
And then the… I think this is breaking, but it's not been used by anyone. So so that's breaking. And then the reintroduction, I think, of the of the new volume material with mapping wherever we do it, I think

[Andreas Salzburger] 21:58:31
can then just be addition of new functionality

[Andreas Stefl] 21:58:37
Okay, yeah, sounds good to me. Any questions or comments?

[Andreas Stefl] 21:58:43
Doesn't seem to be the case. Then the next one.

[Andreas Stefl] 21:58:46
Um, I think it's also from you, Andre.

[Andreas Salzburger] 21:58:53
Yeah, this is breaking because it sits on top of the first one, so once we have a new volume material, we also get a new proto volume material, etc. Now, this is the question, once we… we didn't have a protovolume material before, I think it's breaking marked now

[Andreas Salzburger] 21:59:11
Because it sits on top of the of the first removal one. So voila

[Andreas Stefl] 21:59:16
I think the API breaking change here is that in your

[Andreas Stefl] 21:59:21
utility is removed and then this new opening is introduced.

[Andreas Salzburger] 21:59:24
Yes

[Andreas Stefl] 21:59:27
So I don't know how the order would be.

[Andreas Salzburger] 21:59:28
Yes.

[Andreas Salzburger] 21:59:31
Now, the order would be the other one first. What I can do is actually draft these ones, the one which define the new structure. It's probably a better approach, right?

[Andreas Stefl] 21:59:31
.

[Andreas Stefl] 21:59:33
Okay, fair enough.

[Andreas Salzburger] 21:59:43
I'll draft the ones that introduce new

[Andreas Salzburger] 21:59:50
Structure new classes okay

[Paul Gessinger-Befurt] 21:59:52
Yeah, and then just one more comment on, no, sorry, Ani.

[Andreas Stefl] 21:59:52
Yeah, go ahead.

[Andreas Stefl] 21:59:56
With drafting mean you don't need it in 49?

[Andreas Salzburger] 21:59:59
No, because…

[Andreas Stefl] 21:59:59
Okay.

[Andreas Stefl] 22:00:01
Because I think right now, basically all of them are drafted and I collected all of them on the list, but I think you can also retarget it on the milestone, and maybe I remember to not look at it.

[Andreas Salzburger] 22:00:07
Okay.

[Andreas Salzburger] 22:00:12
Okay. Yeah.

[Andreas Salzburger] 22:00:16
Power?

[Paul Gessinger-Befurt] 22:00:16
Yeah, I just want two points. One is with the JSON file format, the new one currently doesn't even support volume material. I removed this because I wanted this to converge

[Paul Gessinger-Befurt] 22:00:31
Before we commit to a new format, but I think if we're adding things to the format, we should now use this version mechanism properly in the JSON thing, so that we kind of correctly roll or correctly specify that version 2, for example, cannot have any kind of proto or other volume material, and then version 3 can.

[Andreas Salzburger] 22:00:38
Understood.

[Andreas Salzburger] 22:00:40
Yeah

[Paul Gessinger-Befurt] 22:00:48
And then the second thing is this, I mean, for the returning functions like this, depending on what the rest of the API is, you can fairly easily do this with deprecation where you convert ahead of time and then

[Andreas Salzburger] 22:01:00
Right, I know, yeah. Okay.

[Paul Gessinger-Befurt] 22:01:01
And then do it that way

[Andreas Salzburger] 22:01:03
But as far as I see it, the really breaking one is the removal of all volume material remnants first, and then everything that comes afterwards will just be new

[Andreas Salzburger] 22:01:21
Seen, in my understanding, new additions

[Andreas Salzburger] 22:01:25
Which are non-breaking by that definition

[Andreas Stefl] 22:01:33
Oh, sorry. Okay.

[Andreas Stefl] 22:01:35
Then moving on to the next one.

[Andreas Stefl] 22:01:38
Um, yeah, this is also a little bit of a bigger one from my side, um, so the idea here is to simplify a little bit our propagator actor setup.

[Andreas Stefl] 22:01:52
implementation right now is, uh…

[Andreas Stefl] 22:01:57
This supports basically multiple actors as, um…

[Andreas Stefl] 22:02:01
As the default. And in practice, we actually only ever use one actor. I think in the rarest cases we use more than one.

[Andreas Stefl] 22:02:11
And I think this is more for historical reasons, but we don't need to get into that right now. So the idea here would be to refactor the actor list to be an actor itself, and then one can use this as a composite.

[Andreas Stefl] 22:02:30
For the cases where multiple actors are used.

[Andreas Stefl] 22:02:32
And the other thing that simplifies is that I would pull out that we return the actor state in the propagate the result, removes a bunch of template parameters from the propagator result.

[Andreas Stefl] 22:02:45
almost becomes a concrete type. Now it's really down to the parameters and the reason we need the parameters here is that we run the single component and the multi-component step through the same kind of mechanism.

[Andreas Stefl] 22:03:00
In the future we could also reconsider…

[Andreas Stefl] 22:03:04
Um… .

[Andreas Stefl] 22:03:05
different abstraction or we say this is the right one. Yeah.

[Andreas Stefl] 22:03:12
That's all from my set. Any questions or comments to this one?

[Paul Gessinger-Befurt] 22:03:16
I didn't look at this yet. Is there still a way to get

[Paul Gessinger-Befurt] 22:03:22
data out of the actor. If it's not in the result, or is that just because… yeah, sorry.

[Andreas Stefl] 22:03:24
Yeah, so…

[Andreas Stefl] 22:03:26
Yeah, this is actually what we… where we usually use this is in the algorithm. So for example, in the Kalman filter or in the CKF. And quite some time ago, we already replaced this by

[Andreas Stefl] 22:03:42
creating this… so there is a different set of functions where you can create the state.

[Andreas Stefl] 22:03:48
And then you propagate on top of the state and then you get the stuff out that you need from the state. And so, yeah.

[Paul Gessinger-Befurt] 22:03:49
Yeah.

[Paul Gessinger-Befurt] 22:03:56
Yeah, I think I remember this makes sense. I think I added this ages ago to support the pre-generated track backend. So yeah, you're right. Okay, makes sense.

[Paul Gessinger-Befurt] 22:04:08
And then, if you detemplate the… okay, but the rest of the propagator stays templated because it still needs to catch the one actor type after this, right?

[Andreas Stefl] 22:04:16
Exactly, yeah. And it stays templated on the stepper and the navigator, so there would be still room to de-template it further, but yeah, one step at a time.

[Paul Gessinger-Befurt] 22:04:17
Okay.

[Paul Gessinger-Befurt] 22:04:28
I think I like it. I think this actor list was over-engineered from day one.

[Andreas Salzburger] 22:04:37
Indeed.

[Andreas Stefl] 22:04:38
Okay, then moving on to the next one. I think this is one from you, Paul.

[Paul Gessinger-Befurt] 22:04:45
Yeah, this would be breaking its draft. It's a proposal I think we will hold this for sure until a couple of more developments are in. I think Jasper wanted to specifically do a proposal or open a draft pull request on the a large radius Gbts. So I think at some point we should move Gbts out of experimental, and at that point we should also

[Paul Gessinger-Befurt] 22:05:05
Ideally, radically reduce the public API surface that we present for GBTS. So this here is a codex generated proposal to essentially remove as much as possible and put it into pointers and essentially hide as much as we can, and then effectively only expose what you really actually need to be able to do as a client, which is the

[Paul Gessinger-Befurt] 22:05:26
the minimum set of functions. And then, of course, this needs to scale. So, for instance, a large radius configuration can still be configured and used. We haven't converged on a final design yet, but I don't think this should go into 4

[Andreas Stefl] 22:05:42
Okay, makes sense. Then, I will also take this one off the list.

[Andreas Stefl] 22:05:47
Then the next one I think is also from you, Paul.

[Paul Gessinger-Befurt] 22:05:51
Yeah, this one I would like to get in if we can. So basically this raises the floor for the C++ standard to 23. I think we're ready. All of the HCG releases have a GCC 15 that is compatible, I need to drop the Clang 19 matrix entry, not because Clang 19 is

[Paul Gessinger-Befurt] 22:06:12
doesn't have support, but because the root installation in HCG 109 Clang 19 was built with GC++20 and we reject this. And then basically this flips the default, makes CMake complain if you configure it with 20

[Paul Gessinger-Befurt] 22:06:27
And then also removes the job that was compiling it with 20. Yeah

[Attila Krasznahorkay] 22:06:36
So what?

[Attila Krasznahorkay] 22:06:37
about GPU languages.

[Paul Gessinger-Befurt] 22:06:40
I mean, everything that can be configured works. So I think it

[Attila Krasznahorkay] 22:06:45
No, it doesn't.

[Paul Gessinger-Befurt] 22:06:46
Not a problem

[Attila Krasznahorkay] 22:06:48
C++23 with CUDA, I know it shouldn't work because in Athena, we had to stay with C++20.

[Attila Krasznahorkay] 22:06:57
Specifically with CUDA, because

[Attila Krasznahorkay] 22:07:01
Otherwise, we are.

[Attila Krasznahorkay] 22:07:03
Sorry.

[Attila Krasznahorkay] 22:07:05
Let me…

[Attila Krasznahorkay] 22:07:06
But let me rephrase this.

[Attila Krasznahorkay] 22:07:10
ARM C++.

[Attila Krasznahorkay] 22:07:11
plus 23 with CUDA doesn't work.

[Attila Krasznahorkay] 22:07:14
Yeah, I forgot it was specific for ARM. So you might want to be careful with.

[Attila Krasznahorkay] 22:07:21
requiring stuff, because…

[Attila Krasznahorkay] 22:07:24
CUDA specifically.

[Attila Krasznahorkay] 22:07:26
dead brakes to build.

[Attila Krasznahorkay] 22:07:29
For the host code, yeah, okay, let's go to 23. But in Athena, we have to still use C++20 with CUDA.

[Paul Gessinger-Befurt] 22:07:42
Okay, I mean, I would hope that we catch this then if it's exposed anywhere where it gets the wrong flags. But yeah, from what I can tell, it's fine

[Attila Krasznahorkay] 22:07:54
Okay, no, but I was expecting that your pull request probably didn't touch CMake CUDA standard or CMake Hib standard.

[Paul Gessinger-Befurt] 22:08:03
Yeah, no, no, it doesn't, it doesn't.

[Attila Krasznahorkay] 22:08:06
Which is fine, I just wanted to make sure that everybody knows about this, that, okay, let's upgrade the C++ standard for the host compiler, but be aware that now we go into…

[Attila Krasznahorkay] 22:08:18
using a different standard for the host and for the device compilation, which again is a pretty standard thing to do.

[Attila Krasznahorkay] 22:08:27
We need to be aware.

[Andreas Stefl] 22:08:37
Okay, then I think this is the last one on the list and I have two items that are not related to a pull request yet.

[Alexander J Pfleger] 22:08:48
Would it be fine for you if we put these two at the end of the meeting and continue now, time-wise, with Carlos' part? Because otherwise we might run out of

[Alexander J Pfleger] 22:09:00
I'm on color spot and we already overtook a bit for this too. Thanks.

[Andreas Stefl] 22:09:03
Sure.

17:30 → 17:50 Hough Transform-based seeder in traccc

Speaker: Carlo Varni (AGH University of Krakow (PL))

HTSeederCUDA.pdf

[Carlo Varni] 22:09:21
I think it's the soup.

[Carlo Varni] 22:09:25
Okay, so this is just a general presentation of the work

[Carlo Varni] 22:09:31
There are a lot of pieces of code that the experts can actually see what I'm doing and comment on how wrong that is. But this is why I wanted to show it here. Obviously, when if you want to go on

[Carlo Varni] 22:09:47
Follow-up presentation, maybe, I guess it's more appropriate to go on the prioritization meetings instead of here.

[Carlo Varni] 22:09:54
But yeah, so I've tried to write to some

[Carlo Varni] 22:09:59
pieces of code that can be used

[Carlo Varni] 22:10:02
On the GPU

[Carlo Varni] 22:10:05
which is a half transform base either. And for this I want to really thank both Hatil and Joanna that really helped me getting started with this, because I've never done anything of Gpu. So this was quite an experience

[Carlo Varni] 22:10:19
But basically the strategy, I'm going very

[Carlo Varni] 22:10:24
custom base because everything is highlighted in this paper. This is the CPU implementation of the CIDER. And

[Carlo Varni] 22:10:32
So we published this paper and the next step would have been to

[Carlo Varni] 22:10:36
To move forward with GPU implementation

[Carlo Varni] 22:10:40
And

[Carlo Varni] 22:10:42
Basically, the strategy is this one. So you take your detector, we use the CTS and VODD where and we basically slice the ITA coverage in different wedges

[Carlo Varni] 22:10:57
The paper is 13, but for this it's better to go with 25

[Carlo Varni] 22:11:02
13 has a negative effect on the

[Carlo Varni] 22:11:06
Efficiency

[Carlo Varni] 22:11:07
So you must be really careful about this.

[Carlo Varni] 22:11:10
Once you slice, then you basically run and perform VEV transform

[Carlo Varni] 22:11:16
Of a space for anything to start feeling the different half planes that you have. You have one half plane for each wedges, which are nothing else than

[Carlo Varni] 22:11:27
Histograms, 2D histograms

[Carlo Varni] 22:11:30
The size of this is 256 times 7,000 bins. That is for Q of Ppt and fee

[Carlo Varni] 22:11:38
Respectively, since we are dividing about 25 edges, you have 25 of this

[Carlo Varni] 22:11:44
Mattresses to fill

[Carlo Varni] 22:11:46
Once you've done that, when you start looking for local maxima in this plane

[Carlo Varni] 22:11:53
And once you find them, you also need to cluster them, because you may have adjacent bins that satisfy the maximum the local maxima requirement

[Carlo Varni] 22:12:04
Because that's not a strict hire when V8 neighbors is higher or equal V8 neighbors

[Carlo Varni] 22:12:11
So if they're adjacent, they basically belong to the same maxima, so you need to run some clustering

[Carlo Varni] 22:12:19
Routine there.

[Carlo Varni] 22:12:21
Once you've done that, then you have a list of maxima and you basically take a look around this

[Carlo Varni] 22:12:28
Locations, and you take images made of 32 times 32 bins.

[Carlo Varni] 22:12:34
They are highlighted here. This is an example on a tt bar sample, for instance.

[Carlo Varni] 22:12:41
Then

[Carlo Varni] 22:12:42
You run some convolutional network on this. Basically, the idea is that the neural network will try to identify what maxima are legit maxima, which leads to a seat

[Carlo Varni] 22:12:57
Just a random combination, which should be basically removed with the idea that this procedure will basically

[Carlo Varni] 22:13:06
target of fake seeds

[Carlo Varni] 22:13:08
Once you've done that, you come up with a list of filters maxima, and for each maxima, you go back to the plane and to the space point and basically you try to figure out what are V

[Carlo Varni] 22:13:21
Heats that contribute to each

[Carlo Varni] 22:13:24
But that's basically

[Carlo Varni] 22:13:27
constructing the seeds because you end up with a list of

[Carlo Varni] 22:13:31
of the space points there

[Carlo Varni] 22:13:34
However, this is not the final step because if you want to provide this to downstream algorithm, you need to make some cleaning procedure, which I will go on a little bit later, but this is to remove outliers because they may not be

[Carlo Varni] 22:13:49
In the same meter region, maybe a little bit

[Carlo Varni] 22:13:52
You know, moved around and by pure chance ended up contributing to the maxima.

[Carlo Varni] 22:13:59
So as far as the GPU implementation goes, I basically have all the pieces in place, except the clustering. I've tried taking a look at the… because I wanted to use the same clustering

[Carlo Varni] 22:14:12
protein that you have and you use for track reconstruction, but I figured it was a little bit too complicated for me to understand what's the actual input required to convert my data into what is required

[Carlo Varni] 22:14:25
So I said, okay, I'll keep this for later

[Carlo Varni] 22:14:31
I'm also missing the filtering because I don't know how to use ONIX there, but that's something that I suppose can be easily implemented. And I have only a partial version of 0.9, so the cleaning, that is because the CPU

[Carlo Varni] 22:14:46
Implementation of these heavily relies on unordered maps and sets and so I have to be a little bit you know be a little bit more careful on how to rewrite that for a GPU

[Carlo Varni] 22:15:02
So basics. So starting point, I simply took a bit throughput MT example and basically

[Carlo Varni] 22:15:13
Starting from where and wrote a simple, you know.

[Carlo Varni] 22:15:19
test for just running the receder.

[Carlo Varni] 22:15:22
I believe at this specific test runs on one single event repeated 100 times, which is highlighted here. But I mean, I just want to to check that I managed to reconstruct seeds. So this is not really

[Carlo Varni] 22:15:38
a real performance evaluation, so I guess this is fine

[Carlo Varni] 22:15:42
But you can see here that it's very

[Carlo Varni] 22:15:47
very not busy event. There is not too much going on. I don't think we even reached 1,000 space points in total. Yes, Satya?

[Attila Krasznahorkay] 22:15:54
Carlo, I'm a bit confused.

[Attila Krasznahorkay] 22:15:57
Didn't you say that you had some special custom input data?

[Attila Krasznahorkay] 22:16:03
Because this is the standard OTT data that we have inject CC. Okay, so your code does run in this.

[Carlo Varni] 22:16:07
Yes.

[Carlo Varni] 22:16:13
I mean, I took this one and I made a new file calling it a different way and just scheduling the full chain with

[Attila Krasznahorkay] 22:16:13
And when they jump okay

[Carlo Varni] 22:16:22
Our Cedar

[Carlo Varni] 22:16:25
That's it.

[Carlo Varni] 22:16:32
So this is the data, and then with some consultation with Attila, this is the helium that

[Carlo Varni] 22:16:42
I made, so this is basically, we have plane collection, which you see is a jack vector

[Carlo Varni] 22:16:50
Plus 2 axis, which are just scalar scholars, and they are basically the edges of the two axis. So these can be configured by the user. In our case, we go from minus 1.1 to 1.1 for the QA

[Carlo Varni] 22:17:07
And minus pi to pi for

[Carlo Varni] 22:17:10
for the axis.

[Carlo Varni] 22:17:17
Assange short

[Carlo Varni] 22:17:19
With these spinnings, which basically

[Carlo Varni] 22:17:22
Takes a total of 85 megabyte for a total of 45 million bins to fill. So that's a lot

[Carlo Varni] 22:17:32
But yeah, I mean, this is the current situation so far.

[Carlo Varni] 22:17:36
So the first thing we do is to define the plane, and this is, I mean, the easiest part

[Carlo Varni] 22:17:41
In this case, we are still defining the axis with

[Carlo Varni] 22:17:47
An equally sized binning in both axis, which is not really the case of what we do in the paper, because this has a negative impact on seed efficiency

[Carlo Varni] 22:17:59
at high PT, because in that case ocular PT, all the events, all the space points are very concentrated in the center, so there you need a much finer binity not to lose

[Carlo Varni] 22:18:11
You know.

[Carlo Varni] 22:18:14
Your efficiency in identifying hits

[Carlo Varni] 22:18:17
But I mean, you can change this function to accommodate whatever kind of binning you want on the two axis

[Carlo Varni] 22:18:28
And then the next thing we do is to pre-compute the sum variables. We do it here because we will basically end up using these variables in different places of our code. So we thought it was

[Carlo Varni] 22:18:41
Smarter to compute it once at the beginning

[Carlo Varni] 22:18:46
I mean, it's only four variables so far

[Carlo Varni] 22:18:50
So VR and fee, it's quite straightforward, but then you do have the detector ID connected to the space point, this is basically an assigned long lung, which is computed from the volume ID of

[Carlo Varni] 22:19:09
of a space point, actually. And then you have a wedges association, which is basically

[Carlo Varni] 22:19:16
a way of understanding what is this base point is contributing to this, this, or that wedge. And you can see here the effect. So for instance.

[Carlo Varni] 22:19:28
You have here of wedge number 14 and wedge number 7, and these are the space points that are contributing to that. So this categorization, let's say, is working, as you can see here, is

[Carlo Varni] 22:19:40
A simple

[Carlo Varni] 22:19:43
you know, unsign long, long, so it's a bit pattern, but basically identifies everything.

[Carlo Varni] 22:19:50
And when we problematic part, which is filling

[Carlo Varni] 22:19:54
Of the histograms

[Carlo Varni] 22:19:56
So what we are doing here is to process the beams in parallel. So for every bin, you run an orbital space pointing to figure out how many of them are contributing to this spin. And then once you've done all this computation, you insert this value into

[Carlo Varni] 22:20:15
into the plane. The computation itself is quite fast, so the problem is

[Carlo Varni] 22:20:20
When you try to

[Carlo Varni] 22:20:22
You know, write something into the half plane that is basically killing the entire time. So basically, if you remove this line and you comment it out, it's like 0.3 milliseconds

[Carlo Varni] 22:20:36
Once you add it, you go to 6 or 7 milliseconds somehow

[Carlo Varni] 22:20:41
So, this is quite

[Carlo Varni] 22:20:45
baffling to me on what I'm doing wrong here

[Carlo Varni] 22:20:48
But I mean, this is the first implementation, so obviously a lot will change for sure.

[Carlo Varni] 22:20:56
And this is basically the bulk of the half transfer. So the transformation is quite a simple one so far. And basically you run in parallel over space points, and what you end up with is a plane like this

[Carlo Varni] 22:21:14
So you can see all the different contribution. This is not very populated event, so you can clearly see the different separated contributions.

[Carlo Varni] 22:21:24
And on this is what basically you run

[Carlo Varni] 22:21:28
To find the maxima. Once again, you process the beans in parallel, and you basically

[Carlo Varni] 22:21:36
Ask yourself, okay, is this been a local maxima, yes or no? And you put that basically

[Carlo Varni] 22:21:41
into eject vector. This process is actually divided in two steps. First thing you do is to count on any maxima you have for each single wedge and then

[Carlo Varni] 22:21:53
To actually do the computation and save it. You see here that

[Carlo Varni] 22:21:57
The code for the two steps is basically the same, the only thing that changes is

[Carlo Varni] 22:22:02
The last lines. In one case, you simply count. In the other case you push back into the reject vector

[Carlo Varni] 22:22:11
And once again, what's taking time is this last step, basically.

[Carlo Varni] 22:22:19
So once you have that and you identify the maxima, then it's well, there is the clustering which is kept. But after that you you create the images

[Carlo Varni] 22:22:30
So quite a simple code here as well

[Carlo Varni] 22:22:37
And basically what you come up with is basically matrices once again

[Carlo Varni] 22:22:46
So, for which veg, you don't know how many

[Carlo Varni] 22:22:51
Which you have, so basically you use the same information of the maxima, because every maxima will produce an image.

[Carlo Varni] 22:22:57
So as a result, this is basically a collection wedge. Oh, what's English

[Carlo Varni] 22:23:05
Eject vector of

[Carlo Varni] 22:23:08
Mattresses in reality. So in this case

[Carlo Varni] 22:23:13
It was used in half plane collection that I discussed before, but there's really no need for this, a simple jack vector of scholars would work

[Carlo Varni] 22:23:25
So indeed I've already switched to that

[Carlo Varni] 22:23:30
Basically, this is what I'm doing. Another thing that we need to store is the

[Carlo Varni] 22:23:34
Basically, the QPT or the PT value correspond to the maxima because this is also what is used by the CNN

[Carlo Varni] 22:23:43
And you can see here it's how it is computed as well.

[Carlo Varni] 22:23:50
Finally, you have the filtering

[Carlo Varni] 22:23:54
This is not there, but

[Carlo Varni] 22:23:57
This is the effect of it. This is from the article. So you see in blue before and in red after the filtering, and you see the effect on the technical efficiency duplicate rate, and most of all the fake rate. So you see that we are trying to to kill as many of fake images as possible

[Carlo Varni] 22:24:16
And,

[Carlo Varni] 22:24:18
So

[Carlo Varni] 22:24:19
This is completely missing because you need to understand how to use ONIX there, but the idea would be to create basically a simple vector of unsigned input there a zero or a one

[Carlo Varni] 22:24:33
neural network passed or not pass the image. I mean

[Carlo Varni] 22:24:38
This was the first idea I had in mind, maybe. There are much better solutions here.

[Carlo Varni] 22:24:46
Once you've done that, then it's time to create the seed, and for doing that, you first need to find the contributing heats to the surviving images

[Carlo Varni] 22:24:57
Once again, you divide the steps in 2. You first count how many hits you have, and then you create the

[Carlo Varni] 22:25:06
The JAK vector for it, and you actually retrieve these kind of things. You can see here the computation itself. So the reason here is that you take a look at where

[Carlo Varni] 22:25:19
Maxima was the bin position and you run a novice basement to understand who is contributing to that by

[Carlo Varni] 22:25:26
You know, recomputing the transform and basically see, okay, do you end up in this bin or not? And this is how you get a seed

[Carlo Varni] 22:25:36
And this basically is what you obtain. So you see here two different images, for instance, and you see here that

[Carlo Varni] 22:25:45
The associated heats are sort of in line, but you end up with also some outliers

[Carlo Varni] 22:25:52
Which, by pure chance are contributing to the heat, but you see

[Carlo Varni] 22:25:57
They have nothing to do with the actual seed. And in order to

[Carlo Varni] 22:26:02
filter these out, you create these matrices which for every single pair of space points you have, you compute the code theta

[Carlo Varni] 22:26:12
We have idea that if the space points are belonging to the same seed, the cotita should be around the same value, and outliers would

[Carlo Varni] 22:26:21
Have a very different value. And you see here indeed that this point would be filtered out in this case, and I guess also 280, which is somewhere here would would fail

[Carlo Varni] 22:26:35
And the same here. And this is how you clean it, because if you if you don't do that, and you are

[Carlo Varni] 22:26:42
I'm lucky enough to use one of these outliers as for the parameter estimation, then you really

[Carlo Varni] 22:26:50
heal your ability to find seeds. This is something we observed

[Carlo Varni] 22:26:55
When we were doing the CPU implementation and

[Carlo Varni] 22:26:59
Indeed.

[Carlo Varni] 22:27:01
The heat filtering was a required step there.

[Carlo Varni] 22:27:05
So this would be the full workflow. The problem now already, even if it is a very simple

[Carlo Varni] 22:27:14
event, I'm afraid that we are already way too slow.

[Carlo Varni] 22:27:19
So, possibly my approach was not a good one, so hopefully you have some suggestions there, but you see that filling the plane and taking the picture, the 2 main contributors. This is 100 events, so this

[Carlo Varni] 22:27:35
6 and 5 milliseconds each

[Carlo Varni] 22:27:40
Find maximum count, maximum are not that dramatic, but still there are a lot of things that obviously I'm sure can be optimized

[Carlo Varni] 22:27:50
So yes, so this was the first skeleton with some incomplete steps around, but I just wanted to already receive some feedback on this

[Carlo Varni] 22:28:00
To understand if I'm going the right direction of I'm totally lost in the desert

[Carlo Varni] 22:28:06
So, as I said, the main concern is the timing, even though it's

[Carlo Varni] 22:28:12
Such a simple event. So I'm very afraid of what's going on, what would happen if you have to process half a million space points like you have in the ITK

[Carlo Varni] 22:28:26
So yes, this is what I wanted to show you. There has been a comment on the merge request because I have everything on

[Carlo Varni] 22:28:33
And the pull request actually about

[Carlo Varni] 22:28:38
You know.

[Carlo Varni] 22:28:39
Extracting what can be also generalized and use those informals. Not really sure what can be used for that purpose here, because this is a very specific implementation. I guess the only generic component would be the

[Carlo Varni] 22:28:55
But, you know, I don't know enough about VEV immune reconstruction there to be able to

[Carlo Varni] 22:29:03
To understand exactly what the muon needs and try to extract that from Michael. But yeah

[Alexander J Pfleger] 22:29:14
Thanks for the presentation, Carl. And I think we have also a lot of points to discuss

[Alexander J Pfleger] 22:29:23
I see also we are at the end of our scheduled meeting time already, so maybe we could use this minute to find a way

[Alexander J Pfleger] 22:29:34
In what setting we could discuss this properly or in the best way

[Alexander J Pfleger] 22:29:40
Would this be an idea

[Alexander J Pfleger] 22:29:42
I see Stephen has also a point, so maybe

[Alexander J Pfleger] 22:29:48
Do you have an idea how you could, like, discuss this together

[Stephen] 22:29:52
Well, this was… so it wasn't my idea to suggest a place to discuss this. However, um, we do have the, uh, the last ever parallelization meeting on Friday, so if we could discuss it there. Now, I won't be there…

[Stephen] 22:30:08
Um, but I would be interested in discussing this with you, could also be in private at some point, because I just want to say that this looks really, I mean, in many ways, this looks very good.

[Carlo Varni] 22:30:16
-H

[Stephen] 22:30:21
I wanted to kind of more than anything complement your work, but yeah, maybe we can discuss in private or in another meeting.

[Carlo Varni] 22:30:33
Yeah, sure.

[Alexander J Pfleger] 22:30:36
Thank you, Attila.

[Attila Krasznahorkay] 22:30:38
Yeah, I was even wondering, yeah, maybe we brainstorm at one point, but indeed the parallelization meeting, very good suggestion, but any other meeting, we should follow up still because I learned a quite

[Attila Krasznahorkay] 22:30:54
a lot from the presentation Carlo. Thanks a lot. But indeed, it will be good to have some.

[Attila Krasznahorkay] 22:31:03
not huge number of people, but some people sit together and brainstorm a little bit.

[Attila Krasznahorkay] 22:31:11
So let's see if we can figure out the best meeting for India.

[Attila Krasznahorkay] 22:31:17
But let's do that afterwards.

[Alexander J Pfleger] 22:31:21
Sounds great. Thanks, Dan. Color, is this time for you?

[Carlo Varni] 22:31:28
Yeah.

[Alexander J Pfleger] 22:31:29
Oh, perfect. Then I would also like to point again to the last two missing slides of Andy's presentation as well. Maybe if you could also have a look onto these and if

[Alexander J Pfleger] 22:31:44
Have some thoughts or feel these affect you from the titles that you maybe also reach out to Andy. Otherwise, we might bring this up also in the next

[Alexander J Pfleger] 22:31:56
Meetings, or Monday meeting next Tuesday meeting and have a word on there

[Alexander J Pfleger] 22:32:03
On that, thanks for coming again to the meeting today for Paul's point on the experimental, I think on the slides, we will have a look on this also next week's meeting. Sorry for taking a bit longer today

17:50 → 18:00 Round table

slides.pdf