In future.
Garth Huber: Okay. recording has started.
Richard Trotta: Okay, let me.
Richard Trotta: okay. So
Richard Trotta: currently.
Richard Trotta: this is just for like you need, and anyone else will look to this. So
Richard Trotta: under my github there's the Lt analysis, and this is just under my test. Now I kind of push everything to the fall, and master get a repository. Obviously, we talk about get get stuff over at our next meeting next week. But that's right. Yeah, that'll be a broader discussion. Yeah.
Richard Trotta: Okay? So the main script that runs is all I'm just gonna go do kind of intro.
Richard Trotta: because there's a lot of different scripts. But
Richard Trotta: pretty much. There's this run production analysis basket, which has. Let's see how long it is. It's like, I think.
Richard Trotta: yeah. So those 2,000 lines. But most of it is just like calling different scripts. This runs everything.
Richard Trotta: pretty much. There's
Richard Trotta: this is the main thing. Yeah, I see. Yeah, you you like doing things this way. I have to admit
I had a different script for every
Garth Huber: kinematic. They were just cut and pasted from the same. But just you have to make so many modifications. But anyways, yeah, fine.
Richard Trotta: Yes, I mean, the main way did. This is just I put wherever I things are hard coded. I hard code them in here. So this is, you can just see, like, for instance, the T range. And like, Yeah, indeed, you have T ranges you have. How many super Hms, angles are available. Now, in your case you only have 2 Epsilons, but, like Vj has 3 and Lt.
Richard Trotta: well, actually, vj, might even have up to 4. I don't remember. Yeah. So I mean, no.
Richard Trotta: so pretty much. You run this the first time, which is like the 0 iteration, and then you run after you run it. After that you use this. I flag when you run it.
Richard Trotta: and that'll run. It was pretty much the 0 Federation. I that's kind of a misnomer. It's more. It runs everything and gets all the root files kind of prepared for the actual iteration, and then you run it with the ice, and it runs a different version of the main script so
Garth Huber: pretty much. You said you like doing these master scripts, whereas I just prefer smaller dedicated scripts. Which are these big Python scripts, which is kind of go through.
Richard Trotta: This is the main, and then there's a main iter, which is the one is for just the like. I said, 0 iteration. And this is for, like iterative ones.
Richard Trotta: but pretty much they go through, and I that they send the comments. But for the most part you have each step of the analysis with that comments and which scripts
Richard Trotta: you're using the kind where they're located.
Richard Trotta: I mean, there's a lot here. But you can. People can go through something around. So the main thing is, when I run this whole main script it'll call
Richard Trotta: the 2 main, the 2 scripts that we care about for now. So the on the zeroth iteration
Richard Trotta: and subsequent ones. It'll always run this
Richard Trotta: Lt twod fit right? And this is the unseparated cross section fitting script which is pretty much, is completely based off of Bill's version of it, every iteration. So it's a little confused about your comment about only the Zeroth iteration.
Richard Trotta: Well, so it this will run.
Richard Trotta: And so
Richard Trotta: but see this one. So when I run through.
Richard Trotta: actually, you know what this might be easier.
Garth Huber: I mean, you have 2 fits. I mean, I'm not sure which one you're referring to. Yeah. Okay. Here, yeah, yeah. You have my slides here. And then for those who aren't aware.
Garth Huber: for getting ready for Lt separations. Yeah, I have 2 sets of slides. They're on the on Red mine.
Richard Trotta: So before. So when I'm talking about the Zeroth iteration here. So before you do this, you would already have ran Simsi
Richard Trotta: and that simcity will have been have been updated with the physics. Physics, iterate script that's in here.
Richard Trotta: And so this in here.
Richard Trotta: You know, we have what our model in here which
Richard Trotta: what I did was. There's a directory in the source file, which is models pretty much a point anytime a model being called. It's going to be in here, and then these
Richard Trotta: on on each iteration. It creates a new directory in bash, which is
Richard Trotta: dated you know, whenever the iteration was ran, and then just saved these in here for each time. So you can kind of just easily check through and see where. Yeah, yeah, indeed, you definitely want that every iteration is stored in a separate parallel sub directory so that you can
Richard Trotta: cross check results. And sometimes you find something funny. And you have to go back to 3 iterations. Yeah, exactly. And so pretty much that, like, I've working on this iterate the 0 iteration, which is just.
vijay: Vijay, if you have a question, go ahead. What changes
Garth Huber: from iteration to iteration is only the things don't change unless you change the code. Right?
Garth Huber: That's right. This was what we are used. Yeah, notice, there's already a difference. So if you look at this T average here, there's these parameters in here this like point 0 7 3 5.
Richard Trotta: I wouldn't call them parameters. But yeah, yeah, I wouldn't. I wanted to use the word parameter for the thing. Iteration modify. Let's just simply call them numbers in here for T average. And so if I look at, for instance, what I have in here, that's already different. I put a little comment here. But yeah, and and to be honest. Vj, if you keep the old ones it it
Garth Huber: probably okay, too. All we care in the end is that you have ratios close to one with no
Garth Huber: God.
vijay: oscillations and things.
Garth Huber: but yeah, I mean, for sure, Richard has very different kinematics and etc., and he sort of do, starting over from scratch with kaons. But yeah. So indeed. So that equation was again, just to give you approximately the average t for every q squared now again like Richard, you have more than don't you have 2 Q squared? W.
Richard Trotta: So that means this, T average equation gave you the same T for those 2 sets. No
Richard Trotta: so the T averages that I use for ones that fit for the for all of the q squared. So this is just the general average for all those. Okay. But but again, just so that you know again, this was simply from what
Garth Huber: I was doing an Fy 2,
and I didn't have a W. Dependence to worry about. So I only had this equation in terms of Q squared.
Garth Huber: In your case, if you want to add a W. Term to this, so that you end up with different T averages for those
Garth Huber: 2 Q squareds which are different, which are the same Q squared, but different. W,
Garth Huber: that's fine, or you simply have an if statement, if the W is this, use T average one equation, and if W is that use T average 2? It doesn't really matter.
Garth Huber: But this number even you probably have to change it. Q squared to Q squared. Right? So I'm a little surprised.
Garth Huber: You have just one equation which works for all. But if it does, that's fine. But again, don't feel that that has to be one equation again, cause I had custom codes, and I would have a different version of this code for every setting, and that means that those 2 numbers would actually change if if I needed to.
Richard Trotta: Craig, I mean, this is just our starting point. I still have to kind of go through right? Okay? But but again, feel, you know, that you have your 6 settings. You could just do if setting one. This equation. If setting 2 use that equation and on and on.
Richard Trotta: Correct. So then the only other thing I changed from
Richard Trotta: vg, again, if you have a question on this just just shout.
Richard Trotta: yeah. So the only thing I had to change from what also is in here. If you look at this, there's
Richard Trotta: well you can't see here, but there's it just defines up to 12 parameters, and that's it. I increase this to 16. Now.
Garth Huber: the caveat with this is that. Yes, it's increased to 16 parameters, but almost all of them are 0 right now. Are you fitting them, or you just you're gonna have in them minuet that they are constrained to 0. Initially, they're they're currently constrained to 0. Make it more easily applicable to what Bill already had in this code. So yeah. But again, Bill's parameterization was for you. Channel
Garth Huber: that's why I was pointing to the parametrization I used for the
Garth Huber: pi minus pi plus analysis, because at least it's T channel. So I'm I'm using these. I'll go through all of the. And and of course, the more parameters. You are the poor constrained they are. So as long as the Iu have sort of fix them to 0 in the fitting algorithm.
Garth Huber: That's that's fine. But I wouldn't wanna start off with too many parameters initially, even 12 parameters. Again, it can go through. You have to play some tricks.
Richard Trotta: has high statistics data. But Richard does not. So it means Vj can get away with things that Richard cannot probably so I mean, you probably wanna start initially.
how many parameters are these for Lt and Tt.
Richard Trotta: currently, there's currently there's 12. These are all just set to 0. No, no, no. But how many of these? 16 like, I don't know how many of these are? L, how many? Or t, how many? L, 2.
Richard Trotta: So yeah, let me just pull. Every single parameter has
vijay: 4 4 so initially, and the 3 Sigma, Lt. And one for this and last Tp, which is which is what these functions have in here. Now, the way I have it set up this is again to make it compatible with Bill script, and this is something we could talk about when it gets to that part. But
Richard Trotta: the reason there's 16 is because for Lt. Lt. And Tc. There's 4 parameters for each, but for all the interference terms are all set to 0 right now. So okay, good you probably want to start off particularly Richard again. Vj, because he's doing pi ends, and he can he's already. What
Garth Huber: did an initial look where he just reused my old parameters, and it already worked reasonably good, so VJ, can probably just start with what he was already using. Which would be fine. All we care is that the ratios are close to one.
Garth Huber: but yeah, in case of Richard.
Garth Huber: yeah. So you indeed, probably want, to set indeed, parameters 9 and on all
Garth Huber: to 0 initially.
hmm.
Garth Huber: and
only start
Garth Huber: turning them
Garth Huber: on to allow them to vary in the fitting algorithm after we get their parameters to work, and even then you probably are gonna have to. Also.
Garth Huber: I could go back and look at my notes. Sometimes we turned on. We had the odd numbered parameters.
Garth Huber: So again, what the parameters. 2, 4, 6, and 8 there are is. Again, this is the event by event. Q. Squared, not the central Q squared. Right?
vijay: So what? What this is meant to
Garth Huber: handle. Here is the Q squared dependence within the diamond.
Garth Huber: right? So the the p. One, p. 3, p. 5, and p. 7 are sort of, let's say correspond to say, the middle of the diamond, just to give an example, and then 2, 4, 6, and 8 then correspond to the Q squared variation
Garth Huber: across the diamond, and you could scroll down just so that the others can follow. There's a W. Dependence which is added in later, the W. Factor which is now giving you the W. Dependence across the diamond.
Garth Huber: And again, all your goal is to get ratios reasonably close to one across the diamond.
Garth Huber: But again, I'm just trying to explain sort of the logic here. So if you're if you're doing this initially, you can, in fact, set the odd numbered the even number parameters, and there was sort of a logic, and how this was set, so that, like you say, the odd number parameters are to more important.
Garth Huber: and then the even upper parameters are like a higher sort of correction.
Garth Huber: But but yeah, I would start off with just the odd parameters in your case. Richard, and then, just do one or 2 iterations on that, so that the odd numbered ones are reasonably close.
Garth Huber: and then set P. The even number parameters to some number really close to 0, and then again allow the iteration to find some optimal value, and again the
Garth Huber: the first bracketed term p. One and p. 2, is sort of your general. Q. Square dependence, and then you're the 3 4 term in line 58 is. Now. You have an additional t dependence added to the Q squared dependence.
Garth Huber: and then you also have this ft. Average factor.
Garth Huber: That you were had earlier. Where again, that is a factor that is intentionally was was intended at least to be 0 again at the middle, at some near the middle of the diamond, let's say.
Garth Huber: and then would give you a
Garth Huber: mall correction. Let me see, you can think of. This is sort of like Taylor expansion. Right? You have leading term. And then you have terms which are sort of proportional derivatives. And that's sort of what the the idea is here
Richard Trotta: going through this. There's gonna be 1 point that this is gonna be evidence to make perfect sense. For me. At least, I think once only after you've done it. That's why I'm trying to explain. And then, of course, for the Lte in the Tt. You have this extra, theta center of mass sign of Theta star dependence.
Garth Huber: and yeah, you have to be sure that that's the correct, variable. That again, the interference terms are required to go to 0 in parallel kinematics that's required by physics. And so that is added here in this way to be a hundred percent sure that the parameterization you're using actually does go to 0 in parallel kinematics.
Alright
Richard Trotta: cool. Thank you. Yeah. That's actually a very good intro for the rest of the stuff, too. Okay, good. Good. And then, of course, your 6, 2, 1, 9 in line 70 is then where you're putting this all together, you should recognize that as the Rosenberg equation.
Richard Trotta: Okay? So then the next. So let me just the first script in here. So actually, let me go back to Paris. I can go through this just to. So everyone kind of see where we're at.
Richard Trotta: So the script goes through and you already have your simcity that ran. And then either you know each of these steps, calculate your yield, calculate your ratios, and then from pretty much step 3 to step 4.
Richard Trotta: This part is all done with the for transcription here. So if I go into
okay.
Richard Trotta: back to the source here, you'll see there's these 2 4 transcripts. But there's the average kinematics, right? Which is calculating the average kinematics. Some of your your errors.
Richard Trotta: And then you have this calculate cross section one. and pretty much. This one goes through
Richard Trotta: for the bins and then looks at, you know, grabs the model, and from there is gonna calculate your unseparated cross sections, then
Richard Trotta: and so that's kind of these steps right here you get to the ratios, and then you get to
Richard Trotta: So at this part here, we're next, you know. Next you're getting wait ready to do the unsafe cross section.
Richard Trotta: and that's where this next script comes in. So now you have the set the unseparated cross sections in there.
Richard Trotta: And they're all on these just text files. For bin, and these get read into this script. I should go go over first, then
Richard Trotta: which is going to be this under source. There's I'm probably gonna move this, but for now it's just in here which is d fit And so there's there's a lot in here, but it's a lot of like just repeating the same sort of things.
Richard Trotta: So let me start from word. I guess the question that I quickly have
Garth Huber: is, of course, you have one section, which is the code that does the work. but then we always had
Richard Trotta: that after every single step you had a plotting script so you could get a series of intermediate plots to inspect whether the iteration is progressing correctly. And of course my slides showed large numbers of examples of those. Plus do you have? Did you make similar sets of plots. Correct? Yeah. So if you go in here and the source there's plotting. And so, printers 3 steps
Richard Trotta: throughout this. So there is the first one is kind of just data versus SIM C. Plots, you know, which is your basic ones are used to seeing.
Richard Trotta: And then there's the bin plots as well, which have just your data per ben, which is, gonna have your yields and ratios and everything like that, and also all the stuff is
Richard Trotta: saved as histograms and put into a big root file at the end of each iteration as well. Okay, that's fine. Yeah. We had the post script files for everything. But yeah, that'd be fine. It's it's actually all saved in 2 different forms. So it's saved in. Well, I guess technically different forms, depending on what we're talking. There's the root files, there's a Json file, and there's the Pdf. Themselves. So they're all kind saving there and then the final ones just the
Garth Huber: plotting the cross section which will have the separated and unseparated kind of plots you inspect the your plots, say, in your Pdf. File.
Garth Huber: after running every script
Richard Trotta: even if it's if it's only you. Look at it for a couple of minutes. But,
Garth Huber: You can easily waste lots of time on your iterations, if you you know if if something's going wrong.
Richard Trotta: And so the whole point of spending some time to look at the Pdfs after every single script is is actually in the end, it actually saves your time. Yeah. So I have in here, just because if sometimes you don't want to look them all. I have this flag, which is this debug flag, which is just kind of hard code to false in here. So if you just set that to true. You can see
Richard Trotta: what this function is called show pdf, with the events. So that's really what it does. It just splashes the Pd, the Pdf on screen, which is fine. Yeah, something that you look at. And indeed, if it pops up automatically, sort of just in a similar fashion to the 50 K replay in an experiment, then that forces you to look at it. So that would be a good habit. Yeah, yeah. So that that's on there and splashes right now. Turned off because I've been
Garth Huber: Yeah, you're debugging you, but you'll want it on when you're running good. And the other thing I would recommend, because I found that until I got used to this, I was
Garth Huber: by mistake skipping steps in iteration, and then I have to go back and and redo work is. So I actually have. like an actual list, like a little flow chart
Garth Huber: pointing out, you need to run this script. Then you look at this plot, then you run this script. Then you look at that plot, you know, and and actually made a little flow chart for me to follow
Garth Huber: when doing an iteration to guarantee that I either don't skip any steps, or that I do the skips in the correct order.
Garth Huber: because there's a lot of
Richard Trotta: things to keep track of, and it's just the more brainless you make it. So that's why I said these main scripts, because then you can literally follow down. And so, for instance, you could say, Step one, and then this is just running the analysis cuts, which is done kind of before this. So just in telling you which script it runs from.
and step 2 is the diamond cut. So then here's the diamond script.
Richard Trotta: and your different parameters. And then you have in.
Richard Trotta: Yeah, this is all the time cuts, and then you have step 3. And so this is applying RAM subtraction to the data and dummy, and then it runs through this script, and you can just go to each one of these scripts and see which state is going on. But you have, like one master script, which is running all of these sequentially. And let's say, I move not exactly thrilled with that
Garth Huber: I would rather that you run each script manually inspect the output coming from the diagnostic plots and then go to the next script.
Richard Trotta: Well, I mean in essence. That's how it'll work, except, I mean, it is just one script. So when you get to this for each one of these steps, that's when the plot show up, then will it do a pause until you hit something on the terminal or something like a return?
Richard Trotta: I mean, I could make it more dynamic like that pretty much. I just, I just do a control C on it and just cancel the script. And then, yeah, you you couldn't ask for like a terminal prompt
Garth Huber: before it, moving on to the next step. Yeah.
Garth Huber: Vijay, feel free to ask questions.
vijay: or if you'd rather, you can share your screen after and ask your own set of questions. Either way, it's fine.
Richard Trotta: Alright and then one other thing I should note, actually, I didn't say before cause this is gonna be important for Pyon and Fijian. We have already time brought this up is the way that the bash script is set up, is, it'll run this main script first for low epsilon.
Richard Trotta: then it'll run it for high epsilon. and so depending on which epsilon is certain scripts will run
Richard Trotta: So, for instance. Okay, yes. Let me explain that a little more. So, for instance.
Richard Trotta: the this script right here, right the lte fit script could only run when you have run both high and low, epsilon. So when I when it runs through the main script.
Richard Trotta: it's and if it's since it's low epsilon first, which I run low, epsilon that are on high epsilon since low epsilon, first, it won't run the script, but then on the second, the second loop, which is the high
Richard Trotta: which is the high epsilon. It'll run it because you need both the low and high epsilon unseparated cross section. Data to run the on the separated cross section scripts.
Garth Huber: Well, here, I mean.
Garth Huber: okay, a little confused as your answer there. So I mean. First, of course, you compute your yields, and for that, indeed, you need to do high epsilon and lipson separately
Richard Trotta: correct. and then you need to combine everything. So then, you need to combine your different super Hms settings together at each epsilon.
Garth Huber: Right? That's the next step.
Richard Trotta: Yeah. And that was in this old average ratiosf, which I guess is now somewhere in this script, somehow. Yeah, so that one gets run. So first I run the yield and ratio. Let me show you. There's actually another
Richard Trotta: script inside of these scripts. Script section. So there's
Richard Trotta: in this main script. Sorry I calculate for high and low epsilon, the yield ratio and average kinematics for each bin, as you can see.
Richard Trotta: And so these all get saved in dictionaries in Python, which is just a really nice way to organize all all the information. and these all get output it to eventually. Json file and root files like I was saying.
Richard Trotta: then it saves the root files for each one, and then if I scroll down here, you'll see just so after. So it knows it's high upline, and it ran those stages for the so now you have the high and low yields, and everything
Richard Trotta: run this right here, which is another bash script which is in here, and this script itself is another, another bash script, and this one, what it does is it'll actually run the 4 transcripts. But it in here. Hard code. It is the high and low epsilon values. And where did you get these epsilon values from?
Richard Trotta: These ones, I believe? And is there consistent with what I have in previous? I'm pretty sure these are all just from the
Richard Trotta: the run plans.
Garth Huber: I think. At least, yeah.
Richard Trotta: Okay, so these are based on the central kinematics. Correct.
Richard Trotta: But I mean, this is just just for mostly for organization sake. But so this isn't the values that were actually used. I guess it says, Well, no, no, they probably are. When you when you apply the Rosenbluth formula, those probably.
Richard Trotta: Yeah. The reason I say that is because so this runs all the 4 transcripts. But, for instance, there is a model calculated
Richard Trotta: epsilon here as well.
Richard Trotta: or it might be one of these. I think it might be in this cross section that calculated
Richard Trotta: which is, which is the one that saved cause. That's just how it is. I mean in principle, I mean, I doubt if it makes much difference to be honest. But in principle you want to use the corrected beam energy.
Richard Trotta: Correct? Yeah, correct? Which is, yeah, which is not the number in the run plan number in the run plan doesn't even use energy measurement. It was using.
Richard Trotta: I'm just gonna go into the output real quick. Which is, hey? This looks familiar
Richard Trotta: here. Okay, so here's the output. This is this just for reference when I'm talking about these 2 scripts here, right? This unseparated cross section scripts.
Richard Trotta: These are the outputs that I generate from this for Transcript. And there's the real Cross section here, the Model Cross section, and then there's the Epsilon model in here as well data model. And then your Phi. T. Team and W. And keywords
Garth Huber: need to include things like the statistical uncertainty in the beam current. It beam charge
Garth Huber: the uncertainty in the tracking
Garth Huber: right. It's not just the statistics coming from the number of events and data. And Monte Carlo we had some discussion with Vijay, I think, was just barely before Christmas that you that he needs that, and he did after made the modification that you can't ignore the statistics in the Simc.
In all of these ratios you have to propagate not only the statistical uncertainty in the data.
Garth Huber: you also have to propagate the statistical uncertainty in Simc. And if that Simc statistical uncertainty is
Garth Huber: more than oh, let's say a third of the size of the experimental data. You simply need to run more, Simc, because you don't want that your statistical uncertainties are coming from Simc.
Garth Huber: You just run it longer.
Garth Huber: but you can't ignore the Simc uncertainties, because there are. But you also cannot ignore the fact that, say you have a certain number of PCM. Counts.
Garth Huber: and that means there's a statistical uncertainty in that separate from the systematic uncertainty.
Garth Huber: And similarly, in your drift chamber. As an example, you have a certain number of
Garth Huber: events that was used to calculate that, and that hopefully, is being propagated from the report files or wherever it's coming from, but that gets included
Garth Huber: separately from the systematic uncertainty in the tracking. And again, similarly,
Garth Huber: if I recall, Vj. Is simply applying a standard 2% uncertainty to Edm.
Garth Huber: which probably what we'll have to do for K. And Lt, but otherwise in Pi and Lt, you want to use the actual number of Edt Edm events
Garth Huber: to again propagate the statistical uncertainty in oh, I understand what you did. We just have. To be sure, it is clear in both your thesis and the eventual paper.
Garth Huber: but in Pi and Lt. We shouldn't have this issue. So there we should do it properly.
Ali Usman: Can can I ask a quick question? So just to clarify when you say let's say you talked about briefly about tracking. So you said, statistical from the tracking and systematic from the tracking.
Ali Usman: Could you? Could you elaborate what does? Because right? So when you calculate a yield
Garth Huber: right again, you have the formula number of counts divided by, you know your efficiencies. You have to do a full statistical propagation on that formula.
Ali Usman: Everything in that formula has uncertainties. Yes, but I mean that uncertainty itself, like the the uncertainty on the tracking efficiency itself, is from the statistics right? No. There is, in addition, a systematic uncertainty which will have to be applied separately. There'll have to be like a table. Both VJ. And Richard, I think, are aware that they will need to have these tables, and and will have to evaluate.
Garth Huber: And indeed it will be a good point, for no, but but the systematic would be. For example, one of the systematic that that I understand. And sorry if I'm not getting this accurately is is, let's say, a uncertainty from like a cut dependence. Right? For example, if we briefly change the coin, time cut, the accounts would slightly change, and we do it well, that's a cut to spend. That's a cut dependent, systematic uncertainty. But we also have.
Okay, let's say in the BCM. Right? You have, indeed your statistical uncertainty. But there's also the uncertainty in the calibration
Ali Usman: which gives rise to a systematic uncertainty independent of the statistics. So when you say this, so that means that all the detectors will have systematic uncertainties, and that would come from the calibration
Garth Huber: are well for the BCM. For sure
vijay: we can understand how much systematic we can.
vijay: No, but no, but the tracking is done run by run. So all set of runs, right data that we analyze, separate, separate, and from Tedplar, we can understand if you see my, I don't know. I posted the track. I put that tracking plot
vijay: for this whole both queue squared data. So we had slightly some fluctuation. Right? So from that, we can understand, okay, this 1% or 2% of half percent, we can apply Christine.
Richard Trotta: Okay? So, Richard, since you're, I think you're the one at the pen. So can you underneath. Now expand the equation for Qe. Yes. Hi.
Richard Trotta: yeah. So so the point II. So if you can do that, I think then I we can better answer Elise. Question.
Richard Trotta: yeah,
Garth Huber: so will be Q now divided by the
efficiencies.
Richard Trotta: So we have the uncertainty of this, which includes, just for first of all, just write the equation for Qe, just go a little further down. We have lots of room there.
Richard Trotta: and I just they're racing on a there it is.
Richard Trotta: I know what happened to the eraser. There it is. Don't worry about
Richard Trotta: alright. This. Yeah. Q. Alright.
Richard Trotta: right. The effect of this is so. This is Q.
Ali Usman: No. Qe stands for.
Garth Huber: So put an E there and then on the right side now. But it'd be better if you have that
Garth Huber: one by one. But, anyways, that's fine. Yeah. So the thing is what you do, Allee, is that you calculate Qe separately for each run.
Garth Huber: using the efficiency for that run. You also calculate now the uncertainty in the Qe. For that run, and then you as when you sum up to get the total statistics for that setting, you similarly sum up
Ali Usman: the Qe. For that setting, and you propagate in quadrature the uncertainty in Qe. For that setting where you were doing were your first step was to calculate, run by run with the queue effective and the uncertainty in the queue effective. So does that answer your question? No, it does not, because I mean that is what is being done. So when you say No, no, but separately.
Garth Huber: okay. But so far you're now assuming the calibration is perfect.
Ali Usman: In addition, Dave Mac has, say, evaluated, say, a 1% uncertainty in the Bcm calibration. To give an example that is now a systematic, independent of the statistics that's now added in the systematic uncertainty table.
Garth Huber: Right? So the systematic uncertainties. There will be a long table, you know. You can look at various theses like bills or Tanya's or whatever, and and you'll have this big table of all your systematic uncertainties, and how they propagate into the final results.
Ali Usman: Sure. But okay, that I understand. But what I'm not understanding is is, how do you get systematic for tracking?
It'll be small.
Ali Usman: But and yeah, you probably are going to use a
Garth Huber: cuts to. Probably in the case of tracking. Yeah, you will use a cut dependence to determine that. But let's say it's a half a percent that we evaluate.
Ali Usman: Yeah, okay, no, that I understand. Okay, okay, that's that's what I started with. Okay, Ali, I'm gonna say this, I think we had half this conversation. We still have to have the second half of this conversation at some point.
Richard Trotta: talk about pretty much just this part of the equation, which is all the sis statistical
Ali Usman: uncertainties. There are any efficiencies right which then just hit multiply into the charge. Statistics are properly propagated. You will be handled completely separately.
Garth Huber: Cause. There we have to be more careful. This statistical ones are at least are uncorrelated. So you just know, you add in quadrature. But systematics are not necessarily uncorrelated. And so you have to figure out
Garth Huber: how they're correlated, and and and then from there, how do you apply them to the data.
Richard Trotta: Yes, just to bring up so a little context for this script as well.
Richard Trotta: Actually, I think they're under.
Garth Huber: So we have some systematic uncertainties which don't depend on Epsilon, for example, they just move everything up and down.
Garth Huber: We have other ones which actually are different at high epsilon compared to epsilon. So that actually change now changes the slope in the rose and blues formula, and so that gives rise to a different kind of propagation. So we have to.
Richard Trotta: Even cart dependents will have different effects from different Epsilons.
Garth Huber: Well, hopefully, not. Hopefully. We'll find we'll hopefully, you'll find that sufficiently similar that we can just apply a blanket scale. But we have to evaluate that and figure out. Yes, yes, it's currently the way I have it set up is, you have your total efficiency here.
Richard Trotta: Which is calculated. and then you have your total your air efficiency in here. Yeah.
Richard Trotta: I guess the next step was applying this uncertainty which I was assuming. It was through propagation, by addition.
Garth Huber: no propagation of what, by addition it should be by multiplication. Well, propagation of what?
Richard Trotta: Of the air?
Garth Huber: No, no, no. Are these random errors?
Garth Huber: Yeah. Well, that means there random errors. So if you just add them, you will have a vast overestimate of the error. Yeah, you need a I mean random errors quadrature, right? Because you can have a random means that say, one will be slightly high, the next error slightly low. So some partial cancellation hopefully. And so you add in quadrature to hopefully encapsulate this random partial cancellation.
Garth Huber: whereas adding means that they go coherently and the ones that are higher, all high. So you have to add them. Okay. But just wanted on the nice equations that you had written by hand there, just wanna make sure it's clear, cause it's not explicit.
Garth Huber: No, you. So you have to double check that
Richard Trotta: because he is where I'm doing that. So that's currently all the the efficiencies.
Richard Trotta: So the statistical uncertainties on those I'm doing my multiplication.
Garth Huber: But then, when I implement them, for instance, for the heap. I'm doing it through. Yeah, here through. Oh, no, no, okay. So you have to think carefully about this in the way. And and I would like to encourage you to the correct terminology, because that actually will will actually change a little bit how you think about it. You need to think about error, the errors correlated or uncorrelated.
vijay: But yeah, you're correct. VJ. But again, you think about is that statistical errors are random.
Garth Huber: They're uncorrelated. That means you get partial cancellation.
Garth Huber: And so that's why we use addition and quadrature because they're random errors.
Garth Huber: But the reason why I want you to think about it carefully is because if you sort of train your mind to think about it correctly for the statistical errors that'll help you. Then, when you come to the systematic errors which are not guaranteed to be random.
Garth Huber: and then you have to think much more carefully. How do I propagate this error?
Garth Huber: Because if you assume it's random when it's not, you underestimate your error. And that's the tricky part, the statistical. At least, it's okay. Guaranteed to be random. Yeah, okay, that makes that makes a lot of sense. But coming back to your blue equation here. So it's not explicit in your Qe.
Garth Huber: so can you just squeeze in between the equal sign and the queue. A a sum, a capital. Sigma.
vijay: yeah.
Richard Trotta: yeah. Sorry. Where's my independent?
vijay: Yeah. And you're you're summing over the runs. Yeah.
Richard Trotta: And you do this course separately for high and low, even run by run. Because again, the error in one run is not correlated with the statistical error in another run. Yes, correct. Okay.
Garth Huber: Okay. Nasser has his hand up, which is great, just. But you just shout out, Don't be so formal.
Nacer: Oh, yes, I have a very nice discussion er
Nacer: so just from my experience before. So for the I mean for the systematic, of course, you have statistical and systematic statistical. You just basically, you just propagate simple. Yeah, you can then add them square root
Nacer: But for the uncertainties, I mean systematic ones. Again, like.
Nacer: I think. Ali also mentioned is that you vary your usually your cards, or there's variation in the calibration, or whatever systematic, from some detector model, or whatever the the gas model or something. There's always efficiencies that come from different kind of things. And then
Nacer: then the the thing is that it depends actually on the experiments. Actually, some experiments. They add them quite rich in quadrature, like they do for statistical. I mean, they are usually also there are some correlations.
Nacer: So what they do, usually they also, there's another way that you take just the maximum one or you take, for example, the like when you, one is dominating. And you just basically take that one. Or you take the average. They can take the
Nacer: you take, you sum them, and you just divide. And you take every experiment actually deals with them different. So there's like, no way no, no, there's no yeah. There's no fixed formula, because it's experiment specific. Because if they are correlated, how is then you can do them? I mean, there's no no, no, no, okay.
Garth Huber: understand what you say. Very good. Can you go to the Rosen? I was just gonna ask you to go to the slides. Can you go to the Rosen Blue from there we go. Okay. So the thing, master, right is, we're doing this rose and blue separation, as you see written in the red box
on the
Garth Huber: top there, right? And so what we're doing
Garth Huber: is that this? Okay, so not giving the full a sort of method here. But you have, of course, the data at High Epsilon, which, of course, is shown here in the Blue Points, and you have the data in low epsilon shown in the black points. Right? So you have 2 sets of data.
Garth Huber: and each of which has, of course, their separate system, statistical uncertainties, and they have systematic uncertainties. But now what we need to do is we need to separate out this longitudinal and transverse part. Let's just ignore the interference terms for now.
Garth Huber: and just concentrate on the L and the t, and the thing is that
Garth Huber: The transverse part is common to both the high and the low epsilon, whereas the longitudinal depends on the difference between them.
Garth Huber: And so the thing is what you need to do when you evaluate them. So first of all, you evaluate your systematics
Garth Huber: separately, at high and low epsilon. And then so you can then look and see. Was the systematics almost the same number for both Epsilons?
Garth Huber: Or was it bigger for one epsilon compared to the other.
Garth Huber: and if it's more or less the same for both, then it's just a scale factor which applies. But if it's different from one epsilon compared to the other, then it affects
Garth Huber: the difference between them differently. And so that means you propagate differently.
Garth Huber: The systematic of that applies more to the L term
Garth Huber: compared to the T term.
Garth Huber: So anyways, we can get more into that later. But my point is is simply, it's because in our experiment, we're specifically doing this rose and blue separation, and where the longitudinal depends on the difference of some cross sections.
Garth Huber: whereas the transverse is sort of just like the what the cross section at Epsilon equals 0 was.
Garth Huber: And and so we're sensitive to how they propagate in that slope.
Nacer: And so at the end. How do you then get the total error like that was error bars? Do they include statistical S squared plus the systematic square, the total square root, or how do you? No, no, because again, it depended on whether the systematic so the systematics which were random.
Garth Huber: where, like you said.
Garth Huber: you just use this standard quadrature. They get added in quadrature to the statistical errors and just included in the error bars the other ones which don't follow that there's an error bat
Garth Huber: that is calculated and shown separately.
Richard Trotta: There's also a good table in here. Oh, yeah, yeah, yeah. Good. Yeah. He's going to show you.
Garth Huber: Yes, projected uncertainties. We did only projected. We have to see what they actually are in the experiment. But yeah, so these are all the st systematic uncertainties, and the question is at the first line, point to point
Garth Huber: that row. Those are the ones that indeed are random, and they can be added in quadrature to the statistical uncertainties.
Garth Huber: Then we have those that depend from one T bin to another. and that's the next line, the T correlated.
Garth Huber: And then we have the ones that now everything. It's not added in quadrature, but rather it's a scale factor that is applied uniformly to everything
Garth Huber: and simply the earlier means for our earlier experiments and later means. For you know, when we understand the data detectors
Garth Huber: better
Garth Huber: that we would expect that contribution to. And so and so my question is that then, for T. Correlated, do you take the maximum value there? No, you'll see. We added them in quadrature. So this bottom line is total.
Nacer: But the point is that we keep track of them separately. So we still just
Garth Huber: added them in quadrature separately.
Garth Huber: But that is just. We're not adding them to the point to point.
Garth Huber: So the point to point, which was point 6%. That was added then
Garth Huber: separately to all of the statistical uncertainties, and then these other ones are instead included in error bands. Hey, Garth, you actually really helped me understand a lot to why these are so much bigger than this one. Just thinking about the propagation by addition versus multiplication. Honestly like.
Garth Huber: okay. But indeed, if you, this is really good, I'm glad you brought that up, because again, this the equation. For if you just to point that so this just again nasty, this just goes through, shows you how the longitudinal cross section really depends on the difference of these 2 cross sections at Epsilon, one compared to Epsilon 2.
Garth Huber: And so just wanna pointing out that we're. We're very sensitive to how accurately we can measure this difference. And that depends not only on statistical uncertainties, but whether sorry the systematic uncertainty
Garth Huber: sorry. In. In Sigma one is the same as in Sigma 2, or is bigger or smaller, because then that also affects that difference in equation 4.
Richard Trotta: Yeah, it tells you up here, too. That's a reason why the if the po polarize, you know the epsilon here, the reason they pick 2 high, you know, very different values, for that is because it's gonna minimize that kind of point to. And that's what equation 5 is. That's the
Garth Huber: fractional uncertainty in Sigma. L,
Garth Huber: yeah, which is kind of what we're talking about with the statistical errors there. Yeah. So that would be this, both the statistical and the point to point systematic. All random errors propagate that way, whereas the scale uncertainties do not. They do not get magnified
Garth Huber: because they're in common at both epsilons, and so it does not get magnified.
Garth Huber: So it's not necessarily that it's bigger or smaller. It's just that you have to propagate it appropriately.
Garth Huber: But thank you for being up this table. I'm not. Hopefully, I didn't scare everyone. So anyways, how we determine those in case you're wondering is is we simply are. Gonna look at, how does the systematic uncertainty
Garth Huber: bury with T. Bin? And then we'll just C, okay, is it correlated with T, or is it independent of T, and then then just goes in the appropriate row. And you see, in some cases that actually it divides up
Garth Huber: right? So you have some of the uncertainty. It depends on T. Some of it is just a scale factor.
Garth Huber: Some of it was some random. And so, like the tracking efficiency you have, you have contributions in all of the roles. It's one study. They're not separate studies, one study. But you're just looking. How does the
Garth Huber: systematic uncertainty in the tracking efficiency vary, because, like you, you're saying Ali, with the say, cut dependence. And now you're just seeing how does the cut dependence vary bin to bin and it. If it's the same for all bins, then it goes in the scale column. You find that maybe there's a little bit of random variation inhibition to that so that could go in the point to point. And then you also find that okay, it depends slightly on the TB. So then it goes a little bit in that other one, too. But you can see in in this case. Here, you're expecting to be mostly just a scale factor.
Garth Huber: Okay.
Garth Huber: in this case, apparently one and a half per cent. So you see, it's one of our largest uncertainties. The Kaon decay is also a pretty large uncertainty, too, apparently.
Garth Huber: and the radiative corrections again, that's just gonna
Garth Huber: yeah. I'm not sure how we're going to evaluate that yet. Given the issues we have with this radiative tail on the pion, for example. So we'll have to figure that out. And the Monte Carlo model. Now this is going to be. This is coming from this. These iterations.
Garth Huber: basically.
Garth Huber: sort of how close to ratios of one do we get?
Garth Huber: So you can see there that it was dominantly dependent on which T. Bin we were in, so the T correlated was the larger contribution.
Garth Huber: But again, this is sort of evaluated. The very last step you're just simply looking. How do? How do these things vary?
Is? It
Garth Huber: did very randomly. So it would just point to point. Do. Is everything affected the same. So it's a scale, or does it correlated in some way with either T or Epsilon or something? Yeah.
Richard Trotta: okay, hopefully, I was helpful hopefully, didn't scare away people, either. But let let me know. If you have questions on that
Richard Trotta: like I, said Ali, and I thought to go through and kind of discuss this these sort of things, anyway. So we're never gonna have another meeting on this. No, not in in this topic. Bio question. Other thing on this? Ltc.
vijay: forget this last part iterating
vijay: So, yeah, is this before?
vijay: Yeah, here. So
vijay: yeah, so let's say, after this doing or yield ray. So and then we have cross section. Right?
Garth Huber: Okay? So let's yeah. Okay. So let me try to explain. And hopefully, I just made your question, if not? Yes. So let's just go back. One slide again, Richard.
Garth Huber: Okay. So again, from the yield ratios. And can you bring up that equation from the block paper. It's just probably one slide earlier.
Richard Trotta: Yeah.
Garth Huber: there you go. Okay. So here we have this big equation, right? So you have your yield ratio, which is the ratio, the 2. Y's if you can just highlight that, Richard.
Richard Trotta: Now. yeah.
Garth Huber: there you go. That's the. There's your yield ratio which we want to be close to one, but it will vary bin by bin, and we take that in account. Then you evaluate the
Garth Huber: the Mont, the Simsi model
Garth Huber: using those parameters. But now you evaluate this, and I assume, Richard, do you have a separate standalone code to do that?
Richard Trotta: Sorry. Do you repeat that last part.
Okay, the Sigma Mc. So now, what you're going to do
Garth Huber: right is that you have a separate code where you're gonna use exactly the same formula that you have in SIM C.
Garth Huber: And you have your parameters.
Richard Trotta: And but now you evaluate it specifically. At these kinematics listed in the argument. W. Bar, Q. Squared bar. T. Phi, Theta Bar and Epsilon Bar.
Richard Trotta: Correct? Yeah, that's part of the part of the binning script before the yields are calculated.
Garth Huber: Okay?
Or
Garth Huber: yeah, it's fine wherever you calculate it. But the point is, you actually are only calculating this at a point you're not
Garth Huber: aggregating over the bin.
Garth Huber: This is not an average over the bin. This is calculating at one coins in the bin.
Garth Huber: Okay? So what we're doing here is this accomplishes our bin centering.
Garth Huber: So you account. You calculate the Sigma Mc. At 1 point the yields, because, you see, with the
Garth Huber: brackets around them, those are evaluated over the whole bin. But then, what this gives you is the unseparated cross section not averaged over the bin. But at that
Garth Huber: point.
Garth Huber: okay, is that is that clear to everyone? It's an important little subtlety here that that the yields, indeed, are averaged over the bin. But the Sigma Mc. Is not averaged over the bin.
Garth Huber: That would be a different cross section, because we quote our cross sections for specific kinematics, and how we do that is by evaluating Sigma Mc. At the Cross, at the kinematics we will quote.
Garth Huber: and then that gives us the experimental error. Sorry, not not error. The experimental cross section at that point. Now.
Richard Trotta: you know, I have to think.
Garth Huber: And
Richard Trotta: yeah, this is something I might have to check.
Garth Huber: You do need to check. This is an important point. This is, this was done as a separate standalone code in the earlier scripts. So be sure you haven't introduced an error here. This is not bin. This is calculated at that
Garth Huber: point.
Garth Huber: and so in Calc. Xf, dot, F,
Garth Huber: I believe, is where this was done.
Richard Trotta: Okay, yeah. If as long as it's in the 4 transcripts, because that's why I thought previously, I'm just double checking that. Yeah, you should double check both of you. To be sure, you want to follow this formula.
Garth Huber: this formula, I take it from the block there, because this is actually the only place, unfortunately, where we actually clearly indicate what we're doing. It's kind of buried in this formula, but it is explicit.
Garth Huber: Then, if you can go on to the next slide.
I will eventually get to Vijay's question. But I want to explain this step by step. So what? The blue and black points are now calculated from that formula.
Garth Huber: So now all of the blue and black points are at that exact t that is listed in each plot.
Garth Huber: Right? Because these points are not average. These these are cross sections at those specific points
Garth Huber: where we have a cross section for each Phi bin. But T and Q squared are now fixed.
Richard Trotta: Sorry? Yeah, I just wanted to bring this up. So so people know that part of the code that was here is in this.
Richard Trotta: Yeah, you see, call X model
Richard Trotta: call X model. Yeah. So this is it right here?
Garth Huber: Yeah. But just go up to call Xmodal online 1 70. That is where that model Cross section Sigma Mc. In that formula should be called exactly. And so calculating again using the formula, it must be absolutely the same formulas in SIM C. Otherwise everything's wrong. You must be using the correct
Richard Trotta: pretty much
Richard Trotta: by another script here. Which is in models. It it's called it when you run it. It's called model underscore active.
Richard Trotta: Now, the way that this is
Richard Trotta: cause I like to. I don't like the hard code things, so it's called X model on it for active and so depending. If you're running what your models are in here and your polarity. That's what this is going to be based off of. So, for instance, for for me, right, it's going to be kon plus right. And then there's also this is was already in here. But this is the pi and minus. If anyone's curious to see that one.
Richard Trotta: So if I go here now? Now, it'll have the exact code that we just were looking at earlier. And this is what is in Simc as well. But yeah, to make sure this, this matches what's in simcity, right? But instead of Max model K on what you need to have is if KX model K on plus is, you need to have X model K on lambda and X model K on Sigma.
Richard Trotta: That's true. Yeah, that would. Yeah. You do need to modify. This is just like for for pipe analysis. Yeah, we have pi plus and pi minus for all the hydrogen pie. And it's you only have one. That's that's actually a a broader thing. I need to eventually implement because I know Lee's going to need this as well.
Richard Trotta: Currently, just this is just across the board the way I have it set up. And this is something
Richard Trotta: again. This is one of those things that it'll make everyone's lives easier. But I just need to actually implement this yeah, but you instead of KK, plus you want K on L and K on s, so again, in that bash script that I showed earlier.
Richard Trotta: This production analysis one in here you define, like I said, this particle type. Now, the way I'm going to do this in the future. It's not currently set up like this. Just because I'm only use looking at one channel is when I say particle type, I'm probably gonna change the name for this just as more clear. But it'll be, you know, pretty much pro like Particle channel. And in this case I'll probably put K. Lambda.
Garth Huber: Yeah, you yeah. K, on L and Kns, or something like that. And and just so that you are forewarned, as you know, your your Sigma statistics are, gonna be bad, which means your parameterization for K. Sigma is gonna have to be
Garth Huber: simpler.
Richard Trotta: Exactly. Yeah, then, kay launder.
Richard Trotta: But yeah, the reason I bring that up just because across the board now we, instead of it being count, it'll be K. Lambda. And so, for instance.
Garth Huber: this part, this, you know, these names of this where it says, K, plus will be calendar plus. It's just something I haven't done yet, because I'm only yeah, you don't need plus cause you always have plus just make calendar and then case channels in there. So okay, now, let's go back to the slides and and finish dealing with. No, no, no, that was all relevant.
Garth Huber: Okay. So again, I just wanted to. That's why I wanted to go back to that previous slide, though things sound like there was helpful. So again, these blue and black points
Garth Huber: were calculated from that previous step. So these are now the unseparated cross-sections.
Garth Huber: and so on. This equation at the top. What we've done is we've determined from the experiment. The left hand side.
Garth Huber: right. So don't have this equation inverted in your head. What we've determined is the left hand side.
Garth Huber: Now, what this next step is. You're gonna fit that equation, and you're gonna fit the the right hand side of the equation to the data which were the left hand side of the equation. Okay?
Garth Huber: And so, indeed, the difference between the high and low Epsilon gives you primarily Sigma L.
Garth Huber: The the offset in the equation gives you Sigma T, and the variation with Phi the Wiggles gives you the interference terms.
Garth Huber: So you have for each plot a separate 4 parameter fit. Right? You have in this case 32 data points, 16 high Epsilon, 16 low epsilon.
Garth Huber: and you do a 4 parameter fit. Those 4 parameters gives you LTLT. And TT.
Garth Huber: Okay. And then the red curves are simply what the jaant is not. Jan minewud gives you, as that was the best fit.
Where? What is varying is
Garth Huber: simply these 4 terms in that equation.
Richard Trotta: Okay, it's actually no. Okay, that's clear. Now, we'll finally go on to the next
Garth Huber: page where Vijay had his question. So now, what is shown in green
Garth Huber: is now again, you fit each T bin separately right? There were 6. Just go back for a second. There should been 6 T. B's. Yes, 6 plots, 6 TB. 6 l's 6, t's 6 lts. And 6 tts. Right
Garth Huber: now we go to the next page.
Garth Huber: Now you're plotting those. Those are the green points where you have the 6, the 6 ls. In upper left, the 6 t's and upper right, 6 lts. And t t's. Now, what you do is now you fit
Garth Huber: your parameterization to this to get best fit parameters in your parameterization. Okay?
Garth Huber: And that results in the red curve
Garth Huber: you see, far from a perfect fit. That's why this is not the last iteration.
Garth Huber: and those. And then that gives you the new parameters which are given in the black box, and then you start the whole process all over again. And once you get, you know, some iterations. This thing becomes reasonably self consistent, and the red lines and the green dots. Well, they'll never perfectly agree will get closer.
vijay: So just to yeah, just to clear this explanation. So we started from Simcity.
Garth Huber: that's right. That was what was fit at that step is, these equations are fit, and the and then the the gives you these fit parameters.
Richard Trotta: Okay, so actually, this is a pretty good segue. So
Richard Trotta: just so everyone knows. Cause I was going through these scripts. So this part of the script right here, this one where you're doing this fitting and kind of getting the separation for each component here that is in scripts. This
Richard Trotta: Lt twod fit one that's here, which we will go over right? Because it takes in, as Garth said. Here, right the unseparated cross sections here, which was this side of the equation right?
Richard Trotta: And then. So this reading these in from the previous calculations that that that the script did.
Richard Trotta: And then from here. It's gonna read these in and then go. It's we'll go through this because it's pretty intense, but it will go through all the fitting parameters of this and then the second part of this right. So then, this script right, and this part is to get the better fitting parameters, that is part of the script here.
Richard Trotta: which is in the models. There's this X underscore x fit in t fit in T. Yes, that's exactly what it was called before just now. It's python, yeah. And so and we'll go through this as well, because this one I have the most questions about this one is
Richard Trotta: some of the equations. I'm not 100%, sure enough, sure on. But that's that's pretty much so everyone knows. Kind of like this slide, you know. Step 6. Here. Slide 11 corresponds to this.
Richard Trotta: this script. Lt. 2D. Fit, and then
Garth Huber: this step, step 7. Slide 12 corresponds to X, right? Right? So again. So there's 2 separate fits on the previous slide.
vijay: Here, you're fitting. Yeah, we'll let you ask questions in a second. But so let me clarify this for everyone. So in this step you're fitting the rose and blues equation.
Garth Huber: Okay, this is one
Garth Huber: set of fits. Then in the next slide.
Garth Huber: Go move to next slide. Yeah. Now you. You have done the rows and blue fit. That's the green points. And now you're fitting indeed, that parameterization that'll depend on what parametrization you have in Simc and like for you. Channel, of course, will be a completely independent parameterization compared to T. Channel. Yes. Now. VJ.
vijay: So if we have this? No, no, no, no, you do. No, no, but that's a much earlier step. Go back again to the formula from the block equation.
Garth Huber: This is this is where the yield equation is used. Go to next slide 11
Garth Huber: where the blue and black points were were determined using those yield equations and the evaluation of the model at the center at the center of the bin. Okay? Does.
vijay: That's the only place where you use. Yield ratio.
Garth Huber: You don't use the yield ratio for these steps. You've already used it.
Richard Trotta: Uhhuh. But for the next you will need to reevaluate the yield ratio, because the model will change. Yeah. So just to kind of clarify this. Right? You have your initial parameter file, which looks like this
Richard Trotta: right? And that'll go. That's what's fed into back here, the simcity right that you run.
Richard Trotta: and then you can run through all this and your yield ratio might not be one yet.
Garth Huber: Ratio.
Garth Huber: Right? Okay. So the yield ratio. I guarantee you will never.
Garth Huber: It's going to vary bin by bin
vijay: it will never be one everywhere for every iteration the Y exp will not change.
Garth Huber: but the Y. SIM will.
Garth Huber: because you're changing the parameters in the model.
Garth Huber: And so then you have to reevaluate the Y SIM.
Richard Trotta: we'll get to. Now this question a second. Just can you go back one previous slide?
Garth Huber: Ok, or maybe even one more slide. So these are now again diagnostic plots where you're inspecting the yield ratios, and you can see that these yield ratios.
Very
Garth Huber: this is, we have high epsilon on the right and low epsilon at the left. We have our 60 bins, but separately, for low and high epsilon, and again, we only have full Phi coverage at one epsilon.
Garth Huber: That's why, in the very most upper left plot you see some bins which are missing. That's fine. We're only required to have full fi coverage
Richard Trotta: at one epsilon. It's preferable to have full fly coverage at both. But that's not always possible. Yeah, let me. Actually, I have a big plot for this. So, for instance, here is from some of my data, from 2.2 squared 2. So you can see here, right. You can see the same sort of trend here, but you can see, because I haven't iterated through this
Richard Trotta: yet. You'll have some. Yeah, I still have some bins right there, you know.
Garth Huber: and then that's an exceptionally large plotting scale. If you go back to my plot you'll see that now this ratio range is quite a bit smaller, and this is the difference, you know this is iteration 11 versus, you know. But yes. But now Vijay's question is to just go back to that plot, I think what Vijay's question is, okay, when do you stop?
vijay: So again, we we don't require the ratio to be one everywhere that will be
Garth Huber: that is too demanding. We do not demand that. On the other hand, what you see is like where I have that red arrow, you can see that there is a dip there. Right? So that is so. What we're looking at is, are the ratios randomly fluctuating around one? Or are there systematic trends.
Garth Huber: So in this case, just to give an example, you can see that if we simply look at the high epsilon data.
Garth Huber: the lowest t bin, which is the upper left one on the right.
Garth Huber: Maybe. Richard, if you can just put your arrow there one up above that. Yeah. So in that one you can see it's reasonably flat.
Garth Huber: and it's reasonably close to one. Now, if we go to the one underneath that that's T bin number 3. Now you can see that we have a larger fluctuation. It's still reasonably close to one, but there's a fluctuation there which is indicating that the interference term
vijay: is being
Garth Huber: underestimated, or at least it's
Garth Huber: wrong in the model compared to the data. If they were the same in both model the data, then the ratio would be flat.
Garth Huber: And so the fact that the ratio itself has a bi-dependens is telling you that the interference term is wrong. But on average, it's looking
Garth Huber: fairly good. But now, if you go down to the plot beneath this, you can see that indeed, that not only is there fluctuation, but the mean is below one.
Garth Huber: So that means, indeed, you can see there's a systematic dependence that
Garth Huber: the model does not have the same t dependence as the data. The ratio changes with T. So what you want again, we don't require R to be one everywhere. That's that's
Garth Huber: too hard of a demand. But you do want that the ratios are reasonably close to one with reasonably few variations. Again, I'm only using the word reasonably. It will not be possible to get rid of all the fluctuations and all of the trends. But that's why. Now, if you go back to the form in the block paper, there's some text there.
Richard Trotta: Yep, sorry
Garth Huber: there. Okay, and that's bottom sentence, which was cut off. The fitting procedure was iterated until Sigma experiment changed by less than a prescribed amount, typically a percent. But that will depend on your statistical errors. So that will be more demanding. VJ. Probably one Richard.
Garth Huber: probably larger. But once the right left hand side is not varying very much iteration to iteration. You can stop.
Garth Huber: Does that answer your question? Vijay. Okay.
Garth Huber: so yes. Preliminary cross sections would be. Maybe that things are haven't fully settled down. So you would have us as a larger uncertainty, you'd have to quote. But then the final cross sections would we publish would be, you know, a few more iterations or or
Garth Huber: and and what you you find sometimes, if you go back to those ratio plots
Garth Huber: is that sometimes what you find is okay. So maybe the equation I have in the Simc isn't quite right. I should. Maybe I need to put a quadratic dependence on T instead of a linear dependence on T, or whatever the data demand. And so that means, of course, you have to modify all of the corresponding sections of the code.
Garth Huber: not only in SIM C, but in the Python script, so that the code is all self consistent. you know, save with a different version, number everything.
Garth Huber: and and then reiterate again, you don't have to rerun Simc, but you do have to reiterate, and and sometimes you have to do that to get your final cross section. But preliminary cross-sections you know, will have a
Garth Huber: a larger criterion on there! Then, file
Garth Huber: did add, answer your questions, Vijay. Okay. Now Nasser did have his hand up, but then he lowered it, so I assume I answered it. But feel free. Nasser, you probably wanna ask a supplemental question.
Nacer: Yes, I mean, you are discussing something also very interesting here is that you're saying that
Nacer: usually here. You, for example, in this slide, you got to the iteration number 11 was also worried that it may be that you're forcing, and you're fitting so much that you're overfitting. Then you forcing basically to fit
Nacer: to produce something closer to one.
Garth Huber: But that's all. Okay. But the re, okay, you ask a good question. So go back to again the equation in the block paper. Okay? So the thing is again, we evaluate the cross section at a point
Garth Huber: whereas these yields are evaluated over the whole bin. This process only works. If the Monte Carlo
Garth Huber: is reproducing the data. And so I guess I would say.
Garth Huber: yeah, we. We have to force the ratios to be close to one again. It's not like it's not that we're publishing the model.
Garth Huber: right? We we we don't publish the Sigma Mc. On the right hand side. We still correct it by whatever is the residual ratio?
Garth Huber: Right? So if you have a ratio that okay, it's a 1 point all 5 instead of one.
Garth Huber: Then that means we correct the Monte Carlo Cross section by that 1 point O 5 in this formula to give the Sigma experiment. And then that is what is used to generate the Rosenblith equation.
Nacer: Yeah, it's still kind of puzzle in how I guess of someone coming you to this. Cm. Dot sigma, you're trying to find Sigma XP. Equals Sigma Mc, which is yeah.
Garth Huber: Well, but that's well. But well, no, but we will not have them equal. But we do want that. The Monte Carlo properly describes the variation of the cross section across the acceptance
Garth Huber: right, because, after all, the Y's
Garth Huber: are varying across the acceptance of a bin, it's not the full acceptance of the detector, even though we already have compared to your experience. Small acceptance detectors. But again, we subdivide that acceptance in T and Phi.
Garth Huber: and and and of course that's a complicated binning, because those are not the experimental variables. These are Lorentz and variant quantities that we've been in.
Richard Trotta: Kind of. What said about the point is actually why you said at some point, too. Right? So each one of these values
Richard Trotta: is the average per bin. Right? You're averaging that. So you're kind of smoothing it out right? So any kind of that noise of what we're fitting is kind of just taken to account by the averages. And then you're looking at the one single point. So you don't really worry about it then.
Garth Huber: Yes.
Garth Huber: So each T. Bin will have a slightly different Q squared and W. And that will be published in the published data. Where we actually tabulate.
Garth Huber: let's say, for essential kinematics of Q squared equals this and W equals that.
Garth Huber: We then show our actual t values
Garth Huber: where for each of those W. And Q squared varies slightly, and although theorists tend to ignore that, to compare
Richard Trotta: Reggie model or Gpd. Model to our cross-sections in the model is supposed to be evaluated at those exact W's and Q squared.
Richard Trotta: The point of this kind of Monte Carlo is, is you you want the functional form and the parameterization to be such
Richard Trotta: that the cross section is described. Robust enough, that robust enough in a sense that you can, you know. Fiddle with it a little bit, and it shouldn't, you know, go off into crazy directions at that point you can. You can save, even if you're overfitting right? As long as the Cross section model is properly describing the data.
Richard Trotta: You, you have the conference to say alright, even if I'm overfitting. I know at least that the cross section is correct, cause it's not gonna go off as some crazy direction, if I but that's why it's so critical again. Just go back to the previous 2 slides, and we can maybe look at both of them. This is why it's so important for every iteration to
Garth Huber: look at these plots.
Garth Huber: these plots, of course the the iteration code will happily go and do the next step without looking these plots. But it's really critical to look at these plots for every iteration to understand. Okay?
Garth Huber: And compare, say, to the previous iteration or 2 iterations, go. Are the ratios getting better, or are they getting worse?
vijay: If they're getting worse, then you have to stop and think and check. If there's a bug in the code, or what's going on? Yes, exactly. If if we have good parameterization, it should improve. Also, if you have no bugs in your code, it should improve absolutely.
Garth Huber: And it's more or less guaranteed, it'll improve, although sometimes progress is frustratingly slow, and and sometimes the progress is fast. And and sometimes you have to do some iterations, find things didn't
Garth Huber: this wiggle that I want to get rid of is still there. So then you have to think on on changing something.
Garth Huber: But if there's a bug in the code. And and II really have to to emphasize that if there's so many steps here where
Garth Huber: inconsistencies can crop up, and then things do not converge. But if the code is bug free
Garth Huber: then yeah, things should converge.
Garth Huber: Now, just good. Go to the next plot, so we would show we would look at this plot every iteration. But then we had a more complicated script. I don't know if you've done this Richard, or or vj, so now, what we have done here just to so, you know, is each
Garth Huber: roll is actually a separate T bin
Garth Huber: at one epsilon. This whole page of plots of where we have 8 times 6, we have 48 plots here. This is
Garth Huber: one Epsilon. where now what we have done is, in addition to just binning in T and Phi. We have separately binned also in theta.
Garth Huber: And so you have here the the bins at theta equals 1, 3, 5, 7,
Garth Huber: 9, 1113, and 15.
Garth Huber: And we're just looking for in this case.
Garth Huber: We only did this periodically, where we were running that the iteration wasn't say converging the way we would want. And so then we need to look things in more detail
in this case specifically for the interference terms right? Because the interference terms depend on theta whether
Garth Huber: you know
Garth Huber: what to do. But we did not do this every time. In fact, we didn't even do this initially, we had gone through some iterations. And then Hanks basically said, Okay, Garth, can you write some code where you subdivide everything. And it was a lot of work, because you have to basically take all of Richard's scripts, say. And now add another dimension of binning on everything
Garth Huber: and rebin all of the data in this extra dimension. And of course the Monte Carlo 2 so you probably don't have these plots. But just pointing out that
Garth Huber: sometimes we needed to do this, too.
Richard Trotta: Yeah, I mean, it would get. I would. I probably couldn't want it. There'd be
Richard Trotta: easy enough to implement currently, I would actually say, but it would be the bidding scheme to get all messed up. It's straightforward but tedious cause. Yeah. Third dimension to all of your binning. So you have extra loops and and things. But again it was only in a diagnostic. It did not change any of the fitting steps, which is simply you wanted to bin the data and the Monte Carlo more finally.
Garth Huber: so you could look so again. The the red fits here are not actually used in any way, but they're they're used to guide the eye. Right?
Richard Trotta: Yeah, I can show this. Everyone has to. There is
Richard Trotta: in the scripts as well. There's the Bending Directory here, and this is where
Richard Trotta: all the bins are kind of calculated in the ratios. So you can look for these to check the loops and whatnot.
Richard Trotta: this one, for instance, this pretty much finds good initial T. B's based off of, you know, to make it equal statistics across each t bin
Richard Trotta: So if you want to look at these, this is just nice for, you know, for good initial point, and then, obviously, your teams might change, depending on what you say later on. But
Richard Trotta: hey? Any other questions?
vijay: No, no, not from me.
Garth Huber: Anyone else. Now, sir.
Nacer: yeah, this is a really good introduction to the to the mess. Let's say, Oh, yeah, everyone's always like a little bit fearful of the Lt separations. It's a necessary
Garth Huber: step. Hopefully, that better explained
Garth Huber: things as, but it's maybe Alicia just
should ask so again, because for the Bsa
Garth Huber: right, we don't use this formula. But again, because we've been in T, so in principle, that means, of course, the data are different. The W. And Q squared are slightly different for every T bin
Garth Huber: and that means when we compare to say partons, or whatever the date data compared to the model, we should evaluate the model at the same W. Bar. Q. Squared bar
Garth Huber: as the data separately for each T. So are you tabulating yet
w bar and Q squared bar for each t bin. You don't have a diamond cut, so they will vary.
Alicia: Yes, I am tabulating it. When I sent you the kinematics to make the plot for the Q squared scan. Yeah, that's right. It'll it'll all change after the offsets, though, so it should change only subtly. But of course it's good to double check that there isn't an unexplained big big change. But yeah.
Garth Huber: but yeah, II have been doing that, and I have a a script that does that that's ready to go. Very good. Okay. But yeah, for the cross-sections, it's it's absolutely critical. But again, in any comparison between model and data. It's also important. Say, theorists.
Garth Huber: I don't know why fears are able to read numbers in a table, but the almost with rare exceptions, they they ignore this. And just to plot versus the central kinematics, and then usually have to write them, say, well, actually, for a better comparison. Here, let me plot it for you using the actual W. And Q squared, which vary every bin.
Nacer: So just one last thing, Garth was, yes, please. So you had fits where you say you're obstructing from Verizon blue
Nacer: formula that you're obstructing Sigma T. Sigma, l sigma Lt. And stuff. Yeah, in the here this exposure showing so you fit the same equation that this equation on the top of your fitting on the left
Nacer: independently for each plot. Yes, and you fit it for each pot, and each pot extracts a different parameter. How is that?
Garth Huber: Well, because, L, because all these cross sections have t dependence?
Garth Huber: Yes, I. And I see that I understand. But how do you extract for each pot? Here you say you extract a different quantity extract? Sigma? Right? Yeah. You have 6 independent fits, right?
Nacer: But he had fared the same function, exactly the same function.
Garth Huber: Well, the the function is dictated by physics, so the function has to be the same. What will vary is LTLT. And TT.
Nacer: Yes, there are free parameters that you extract. Actually you extract all the parameters for so all these block 6 plots, you would extract 6 times these parameters. You do not take any average. No, no, no, you don't take any average.
Garth Huber: because that's your T dependence, which is important physics. So you do not average in any way. You now have your t dependence. So now in the next slide. You have 6 ls.
Nacer: so if you go, yes. So if you go back, so let's say the first plot on the top left.
Nacer: you extract there, what?
Garth Huber: LTLT, and TT. Exactly so. And the second one, you extract all again, the 6 as well. But at that T.
Garth Huber: Yes, yes. Then, okay, I got it. I got it. Okay, okay? And you can actually see sort of how it works in here.
Richard Trotta: it's like I said, this one's a lot. But okay, so you read in these files, and then you pull this function here
Richard Trotta: alright, and we're just gonna go through this function. But then this is recorded. It's worth just going through, because there's just a lot here.
Richard Trotta: okay, I'm trying to make a good way to go through this alright first. I'll just go over to these ones since they're up here. Because they'll get called later on.
Richard Trotta: So. And it's actually one thing I did kind of confuse me so maybe you could have some clarification on this card pretty much. He defines 4 equations, which are just, you know, like, we said, it's this equation, right? And so. But he defines the Rosales equation. And this is just for I think. Just make it clear for high and low, which is fine, but then he also has high and low on set.
Richard Trotta: But the only difference between these 2 is that one is in radians, and one is in degrees
Richard Trotta: no idea why you would do it that way. Very confused. Why, he's doing that as well
Garth Huber: as long as it's being. Yeah, that's not needed. I would just comment out one of the sets.
Richard Trotta: okay, yeah. Well, let me go through it. And then we can. I just want to bring that to your attention first. Well, before we go through this. But okay, so first, you're just defining
Richard Trotta: you're grabbing from the you're grabbing from these 2 files behind low Epsilon files which has the unseparate cross-section. You're grabbing your cross section, your error, your model cross section, your epsilon, theta by you know everything I showed you before. I just print these out so you can check them if you and then
Richard Trotta: pretty much down here, then you're creating these lists which save the you know, the bins that are in here because each one of these cross section values is gonna have a corresponding Q squared WT. Theta.
Richard Trotta: and then from here you're just looping over all your T. B's right, and then
Richard Trotta: this part is just applying a cut, but the cut itself is just making sure you're in the proper bin. So you know, if you're at, I equals 0. The first lesson, you know, whatever your first tin is.
Richard Trotta: Okay. So then, this is where the code starts getting into
Richard Trotta: a lot of stuff. So the first thing and this is right
Richard Trotta: is he has here.
Richard Trotta: He defines both the the this function here, right? This is the t this is a fit, this. So he's fitting it. And this has 4 inputs in the 4 inputs for this are just your Lc, in your interference terms, it goes from 360. Right. So this is the degrees, and this is the one that's in Radians.
Richard Trotta: And up here he just grabbing the the pretty much the value from this from this
Richard Trotta: function, or he's grabbing the values from the input file above.
Richard Trotta: Yeah, I think the reason why has it, both? Because, indeed, the code he inherited from me. I had everything in degrees. I'm I.
Ali Usman: Peter has written for simcity
Ali Usman: as a a different like 5 definitions. And so it it. It is very, very important to
Ali Usman: properly convert everything. Why would Peter wants to have a different 5? Definition should be standard definition of fine. So I think, Alicia can confirm, but I think, like some of the Monte Carlo, are not like. There's a difference between like I think the Newton Monte Carlo. And to see this Monte Carlo. Okay, either way, I would claim the correct. The correct answer is, you must calculate it identically how it is calculated in hc, Anna.
Alicia: so that's the big issue. I don't remember if neutron and SIM cetus are different. But
Alicia: data and Simc have different ranges for Phi.
Alicia: So I had to convert to do the the delta
Alicia: comparison. For the shape study, because one of them goes from 0 to 2 pi, and one of them goes from negative pi to pi.
vijay: But if you run, Richard Simcity, Richard, is every con that convert this?
Alicia: yes, yes, I am. I am using the recon script. Maybe it's in older version, somehow. I can. I can chat with Richard about that. But I am. I am using some version of the recon script, and even after that they're still different.
Richard Trotta: Be completely consistent. After the recovery building, just from your initial momentum energy. And then just the data. Yeah, I'll send you a message later. And we can see what's up with that. Yeah.
Richard Trotta: okay, so yeah, pretty much just like, I said, just going through. And this is grabbing your cross section values
Richard Trotta: and then also your error for the cross-sections and the models setting in there. And does this.
Richard Trotta: So then it creates this graph errors. It's kind of honest. It's a little hard to follow. So it grabs this T graph, which is called temp, one which is just grabbing. Looks like it really needs some comments in here. I know Bill didn't give you either. But
Richard Trotta: yeah, that's what my goal is. That's kind of this meeting. So I can kind of get a better understanding of what's going on. Happy to have more meetings. My first question is, he creates these, he's grabbing these T Grapp errs which come from
Richard Trotta: this end low. Let me jump in back and forth, but
Richard Trotta: right? So the first vectors of these
Richard Trotta: are your
Richard Trotta: Q squared? And W,
Richard Trotta: okay, so the can Max to the top of the file or something. Yeah, I think he's push. I it might be in my thinking he'd be grabbing these 3 values. Cause I think this would be your.
Richard Trotta: This would be your v. 2, and then your v. 3 would be this. because your model doesn't have an error on it.
Garth Huber: No, your model. Well, your SIM C. Has an error on it. Absolutely.
Richard Trotta: Yeah. See? That's okay. So like in in this code, though, he only has the error for this. V. 3, which is the error in the data.
Richard Trotta: So uncorp the the data unseparated cross-section.
Richard Trotta: But the Monte Carlo. But the unseparated cross section already should have in it.
Richard Trotta: That's why I thought I just was, yeah, I think that's that's because this is based off the the 4 transcripts which I think already has that in here. That's why this is 0. Because, yeah, because the on separate cross section should already again, in that block formula
Garth Huber: you have 3 quantities, the 2 yields which? Well, yeah, the the Model Cross section in that does not have an uncertainty. It's just calculated at that point.
Richard Trotta: and there's no uncertainty associated with at all, it's an exact calculation using those parameters.
Richard Trotta: Yeah, that makes sense. But the but the 2 yields both have uncertainties, and you propagate that according. Okay, so then pretty much. This is just. He causes the tempo, but he's just using this to more clearly define your x and y,
Richard Trotta: which your x and y is a
Richard Trotta: again using t graph error here, and the error in y which is kind of redefining what you wrote up here. I think he just said that C, with pointers sometimes can get messed up
Richard Trotta: and then he defines the average Sig sigma for low and high using the room means square in there, or the mean, and the room means worth there.
Richard Trotta: And then.
Richard Trotta: at this point
Richard Trotta: he's taking this, which is another key graph error. So he's setting the more points right now, which is just the number of events in in
Richard Trotta: You know of your data. then for each t bin
Richard Trotta: putting, you know, just plotting in your average signal out, which is defined right here.
Garth Huber: Just keep taking a table, I think of your
Garth Huber: on separated cross-sections at low epsilon yup, and then you just repeat this for high as well. Yeah. So now you have a table, and then now you're gonna fit the rows and blue formulas
Richard Trotta: to that table. Umhm. Alright! And this is where my, my next, my big questions come in. I don't know what this is.
Richard Trotta: what what is what. So I assume this is him calculating the errors. But I don't really know, like he has a point to point systematic error.
Richard Trotta: something he calculated outside of this, which he sets at 2.9.
Garth Huber: Yeah. And and for that, we're going to have to evaluate that. Okay.
Richard Trotta: So I guess I'm just trying to get an idea of what is going on at the time. So he's calculating which errors
Richard Trotta: well what it looks like, what he's adding here in quadrature is like we're talking about earlier. You have your statistical uncertainties, which is presuming the first term, and you have your random systematic uncertainties, which is the second term. Okay, yeah, that makes sense for what we're talking about here. So then, this is just
Richard Trotta: I don't understand what this term is. Then
Garth Huber: a well, he's incrementing this variable
Richard Trotta: in quadrature. Yeah.
Richard Trotta: Okay? Oh, I see. Okay, that makes sense. He's just putting all the all the values for every event in there. Okay, yeah, that makes sense.
Richard Trotta: Okay? So yeah, that pretty much that he does that for high and low epsilon.
Garth Huber: And then, okay, so then, this is the the next one. So now he has this equation here equation. except it looks like it's being evaluated at some
Garth Huber: angle.
Richard Trotta: I have no idea what this equation is, I think this is actually, for this particular script is where my biggest this has been the hardest thing to kind of look for, because II know context of what this equation is.
Garth Huber: Well, the Y is epsilon. Right?
Richard Trotta: Yes. Is it? This looks like the rose. This looks
Garth Huber: very similar to the Rosenblith formula, but what? Oh,
Garth Huber: okay. But but this is again coming from.
Garth Huber: Yeah, there was some. You can probably remove that. There was some correction we had to apply to the data. It should be documented in like Jogan's thesis or somewhere.
Garth Huber: That this should just go away.
Garth Huber: Okay, let's see, the problem, though, is, then this is used to to set all the rest of the parameters. Yeah, but but you should remove that formula or comment it out is, and then you should not need that.
Richard Trotta: So which I guess my question is, what for me, try to use the normal equation for this.
Richard Trotta: So this is how he's setting the parameters right.
Richard Trotta: All the parameters off of this. And the promise, too, is what is this? What is this variable name.
vijay: Is it just Fansan Fansan of this? Yeah. But why are these values of theta in there?
Richard Trotta: Yeah, II really don't know. And it's I. This has been the the point that I haven't after converting this t-time. I
vijay: there's the.
vijay: This is phi right phi in in our case, and we are. Phi right? Cause? Phi.
Garth Huber: so you need to. I mean, yeah, I think vj, is correct. This is the reason this formula. But you should probably put a
Garth Huber: see out statement or something here just to confirm. So y is presumably epsilon, and X is presumably the 5 PIN number.
Garth Huber: And so, of course, then you have to convert your 5 bin number into Phi, whether it's degrees or radians by multiplying by the appropriate binwits.
Richard Trotta: Okay?
Garth Huber: And one is fine. The other is 2, 5. That's why one is twice as wide as the other. Right?
Richard Trotta: That makes sense. Modified your version for the appropriate 5 in width.
vijay: I, yeah, yeah.
Garth Huber: yeah. But you should add some comment here, II mean, it's kind of bad that Bill hasn't commented. Where this O 1, 7, 4, 5, 3 comes from. So if you could add a comment here when you modify this so that
Garth Huber: you remember, but looks like Phi is in degrees, cause. It goes from 0 to 3 60. That's the 2 parameters after the equation.
vijay: and I don't want the point. One and point 6 are, that must be that would be range in range. Yeah. Range in Ti guess.
Nacer: Did it need to be a 2 dimensional fit? There was no way to do a simple one. No, because it's versus Epsilon. And Phi, right? There's 2 parameters in the resume of the formula, right? Both Epsilon and Phi.
Nacer: And yeah, I guess you need to fit them together. You have to fit them together. Do not fix one and fit. No, because they are.
Garth Huber: No, you you have to.
Nacer: No, you have to avoid the complexity. The the idea was, go into. That's just to avoid the 2 dimensional. There's no way to get the interference terms
Garth Huber: without.
Garth Huber: Yeah. you should have high enough quality data that you have no problem doing that, though.
Richard Trotta: Okay, well, that at least clarifies
Richard Trotta: these random numbers. I have to try scratch my head over. Okay at this point there's the first fit, right? So you're just saying that fitting parameters which is going to be.
Richard Trotta: The parameters themselves are persist, prefer Lt. And interference terms, then
Richard Trotta: the Zeroth one, the first one, and then the third one third one.
Richard Trotta: and then pretty much from here. It is pretty straightforward, just, you know, setting the points for each one of these and then doing the fits which I don't think there's really anything in here just except for the parameter limits, I assume. Well, but again. And so I think this gets to NASA's question. So so the way you sort of reduce that complexity
Garth Huber: is so, first of all, because you can see that this some parameters are fixed and others are released. So I think you start off
Garth Huber: by fitting only L. And T. Whereas Lt. And Tt. Are held fixed. Right? That's what says there, right? Is that print statement in line 2, 83,
Garth Huber: fit L. And T. While Lt. And Ttr. Are fixed. So that gives you a good guess at Lnt. And now you once you've done that, then you do a second fit. Where now you
Garth Huber: it's to only know the TT,
Richard Trotta: which is the next figure one, and then finally, you fit all 4. So you do it in steps. Yeah. So yeah. So here you can see it's fix fit Lt, while other fixed and fit lnt again. You're doing this, and then you do. Tt, while fixing all these, and then you have your final Lt. Back and forth between those 2 sets of parameters. Yeah. And the idea again is just to you're doing it this way to a
Garth Huber: avoid the fitting function doing something crazy. L and T
Garth Huber: are bigger than the interference terms, so they should dominate the fit. So you fit them first
Richard Trotta: and you fix them, and then yeah, and then you try to fit only the wiggles.
Garth Huber: and yeah, and and you and Tt. Is bigger than Lt. So you first fit the TT. Wiggle.
Garth Huber: and then you fit the LT. Wiggle.
Richard Trotta: Yeah. And then the rest of the script is pretty much just at this point, just fixing the parameters. Now you have
Richard Trotta: in essence, you should have. Your final kind of everything is now fit together. But you've
Garth Huber: you've obtained your initial parameters. Yeah.
Garth Huber: And of course, if you had really super high quality data and very fine binning. You would need to do this. But with the real binning and real errors.
Richard Trotta: yeah, you sort of go through this process, and then this is kind of gives you just your fit status, and then there's different plots that come out fitting these. And then this all gets outputted, then to this new file right, which has just your separated cross sections, and it gives you your Sig Tl. And interference terms with the errors, and then it also gives you your chi-squared value for that particular bin of T and return your T team in W and D squared. Then. So
Garth Huber: okay, so hopefully, I'd address your comment, which was a good one, naser. So you deal first with only the epsilon dependence
Garth Huber: by fitting only L. And T ignoring the Phi dependence. And then you start, including the Phi dependence.
Garth Huber: the larger term first.
Richard Trotta: after having the overall epsilon dependence. Yeah. And that was, that's this step right here. Just okay. So that's that script. I think that was my biggest question was pretty much what these errors were in this. I don't know if there's anyone else from glancing over. This has any more questions. But indeed there is in there. That's an important point is that these random systematic concerns is hardwired in there, and you will have to.
Garth Huber: you can do some initial fitting. But for the final fitting we have to include the real, the actual number coming from the experiment.
Garth Huber: In line 2 46. So you should make a comment there, it's important, wherever this is that that's a hard wired quantity in this code, and that'll have to be updated.
Richard Trotta: Yeah, I agree with that. Okay.
Garth Huber: so for some initial studies and being Gary going, you can just use whatever was, was already there. But in re, for final results, we have, yeah, yeah.
Richard Trotta: alright. So then, the next script corresponding now to this
Richard Trotta: this part here, which is the generating the new parameters file as I said. Now, this one is
Richard Trotta: this, one confuses me just because of the labeling
Richard Trotta: so this one might take a little more looking at so pretty much.
Richard Trotta: We have you reading this exit, which you just take it for me particle type. This is just your clarity. And then I put closest date that pretty much just means, whatever the previous iteration was. It's just it goes off a date. I thought it was more specific that way.
Richard Trotta: And then here he defines. And this, this is my first. This is where you're determining the the
Richard Trotta: the parameters for the next iteration. So my first question is, he calls these functions for safety L. And interference terms. But there's a bunch of different functions in here. These are the ones that weren't commented out. So is this just using these equations because it's a good kind of initial
Richard Trotta: starting point, or
Garth Huber: I don't know why this is quoted this way. I mean, it should be quoted.
Richard Trotta: it should be like. So that was my, that was my thing to what you have. Right?
Richard Trotta: Yes. But again he, Bill's version was, you channel right? Everything's completely different.
Richard Trotta: It gets very complicated. Let me. Let me hold off on that, because here's I thought that would be the case. But then, in the code itself, right? So if I go to like Sig t
Richard Trotta: I guess. Let me start through. Go through this first. So first, it just reads in what we just generate right? That separated cross section.
Richard Trotta: So reads this in it also just reads in the previous iterations, parameters, parameterization that we had.
Richard Trotta: And so that's what pretty much all this is doing is just defining vectors and whatnot. So then I look at Sig Sigt, which is the first one he has. So here's the fit for Sig T.
Richard Trotta: And then this is where things get very confusing. So he has. He loops over
Richard Trotta: all the events that are in here
Richard Trotta: again. It's not events. It's not events, you're not feeding events. You're fitting your tea bins. I don't know why he does it over. W. Vector but I mean the same size.
Richard Trotta: So what I'm confused on is he has a Q squared term. It then has a Q squared dependent term.
Richard Trotta: I. I'm not really sure what he means by Q. Squared term versus a Q squared dependent term.
Garth Huber: I don't, either, but I don't think you really care.
Richard Trotta: So yeah, that was my my thinking. Is that what I could do.
Richard Trotta: I mean, this this part of script is is, I just don't understand what's going on. Well, sure. But all you want is that it corresponds to I mean, I can send you again my Fortran version of this.
Richard Trotta: It was just hard to match up, because pretty much
Richard Trotta: just going through this right.
vijay: If we have exact same occasion in the in the previous or earlier, then we don't need this. Q. Scott. Here, right is, it will added this queue queue score dependent. And if we have already in our then I don't think we need this again. That's that's right. I mean, he has a completely different parameterization than what you're starting with. So
Richard Trotta: don't mix parametrizations. This has to correspond exactly to what is in Simc. Otherwise you'll have problems, I think, indeed, if I vaguely recall, he had a factorized model where he indeed had a separate factor. Q. Squared depends. That's what you're seeing here so pretty much the way, cause I mean, he calls us fit function right? Which is like I showed you up here. This is just the function that's you know, for T, right for sick. T. Is this function right here?
Richard Trotta: Just wasting your time?
Garth Huber: Yes, it. I mean, if you want to understand what he does, you actually have to pull up his thesis
Richard Trotta: and see his actual. But if you're curious and what he had, and certainly probably wanna save this for Alicia.
Richard Trotta: Yeah, this, hopefully, this should correspond to what is in his thesis. But that's a completely different parameterization suggesting, you guys fit with. Because this is you channel, and this is completely different.
Richard Trotta: Cool, alright. So I can kind of just go the rest of code for everyone else. Then so pretty much it's the same steps, or it repeats the same steps, is what's going on with Sixte, except obviously pramstation is gonna be slightly different for each each component, but pretty much just like before you're grabbing from the values, from the
Richard Trotta: grabbing the values from the
Richard Trotta: You have your table 6 or whatever key bits I would assume. So yeah, cause that's your only dependence. Right? These should only depend on T. It's d sigma T. You remove the epsilon dependence. You remove the Phi dependence.
Garth Huber: There is no other dependence.
Garth Huber: Well, I mean, there's a Q squared and W. Dependence. I guess that has to be.
Garth Huber: Yeah. Umhm.
Richard Trotta: so and pretty much. It goes through here then, and you're just defining sort of like your models for the fit just to fit it properly, which is pretty much oops.
Richard Trotta: what we see right here.
Richard Trotta: Then it it does that. It pretty much plots 2 things, plus you know your cross section here, and then it kind of plots it again with your fit status and everything. Is. Yeah, yeah. I mean, he's unfortunately. Yeah, he, I see he's combined everything to one script. We had it separately, that the fit was one script, and then the plot was a completely separate script. But okay, which is how I normally like to set them up. So I'm probably gonna tear these apart at some point in future. But for now I just have them. How how he had them.
Richard Trotta: Okay.
Richard Trotta: how have you set yours up? Is it? One script or 2 scripts?
Richard Trotta: Currently, everything's one script just just for these 2 scripts. No, I understand. I was asking. I was asking. I was actually asking, Vijay, okay, yeah.
vijay: I have such a separate. Actually, I'm not like, including all thing together. Yeah, which actually prefer. So when you say, Richard, it sounds like you should just take a look at what Vijay
Richard Trotta: normally. So, the rest of my script should say, guys, II put it pretty much anything that's a plotting script. I'll put it in plotting I'm probably gonna put these in a new directory label properly. Yeah. Actually, I didn't do that for the plotting script simply because I wanted everything that you use together in iteration in one spot.
Garth Huber: But the plots
Garth Huber: were then written into a default plotting directory, but all of the scripts that were needed to do an iteration, including the plots, were in one spot. Yeah, II kind of jump around just because in python it's pretty easy to kind of point where certain things are so in that sense is, you can kind of just
Garth Huber: down here at the bottom
Garth Huber: a new web R dot file, which is then read in for the next iteration. Yup, and you'll have to move a pointer or something, because this is read out in a
Richard Trotta: put out in a directory. I see the curly brackets after the source, which is separate every time
Richard Trotta: you want to run through this, too. There, so there's I mean, just so. People know pretty much like you have this, the whole main script which runs. And then, after step 8, it's just like
Richard Trotta: 300 lines of code of just saving files. So it like copies. The simcity. You're literally your simcity root file. And it's his file to the cache, and that cache is based off the date. So it's pretty easily labeled. And then everything else like I said, all the Pdfs, the Json files root files, his files.
Richard Trotta: anything you possibly think of, or I'll save in there. So you should have pretty much every piece of information you could possibly want in there. Okay, and I would claim it's really important. Ii know I'm old fashioned, but I would claim having actually a paper logbook
Garth Huber: for keeping track of what you're doing when you start doing these iterations? Really?
Richard Trotta: Employee? Yeah, that's good point.
Richard Trotta: Alright.
Garth Huber: I think that's it. From the scripts. I think that clarified the questions ahead of these. Well again. But I would suggest that you start by because he's already dealt with a lot of this issues, and there's no point. I mean, it's also good for more people to look at codes. So that you, you know, if you find a bug that helps the other person.
Garth Huber: Yeah, good
vijay: any other questions. Vijay, do you have questions?
Garth Huber: No, no. Okay. Does anyone else?
Garth Huber: Okay, very good. So Are we done the meeting? Then should I stop the recording.
vijay: I think, but I don't know. Rich. I still want to do meeting with this or you clear with this error propagation.
Richard Trotta: Oh, for about the heap and luminosity. Yeah, but because in the heap I just saw you. And so that you are just summing up live. But you need to this. Yeah. But I do this in all analysis.