ATLAS Offline Software
Loading...
Searching...
No Matches
ALFA_MDMultiple.cxx
Go to the documentation of this file.
1/*
2 Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3*/
4
5#include "ALFA_LocRec/ALFA_MDMultiple.h"
6#include <algorithm> // std::copy
7
8ALFA_MDMultiple::ALFA_MDMultiple() :
9 AthMessaging("ALFA_MDMultiple")
10{
11 memset(&m_iNumHitsLayer, 0.0, sizeof(m_iNumHitsLayer));
12
13 m_fOverlapCut = 0.0;
14 m_iMultiplicityCut = 0;
15 m_iNumLayerCut = 0;
16 m_iRPot = 0;
17 m_iUVCut = 0;
18
19
20 m_fRecXPos = nullptr;
21 m_fRecYPos = nullptr;
22 m_fOvU = nullptr;
23 m_fOvV = nullptr;
24 m_iNU = nullptr;
25 m_iNV = nullptr;
26 m_fRecXPos = new std::vector<Float_t>();
27 m_fRecYPos = new std::vector<Float_t>();
28 m_fOvU = new std::vector<Float_t>();
29 m_fOvV = new std::vector<Float_t>();
30 m_iNU = new std::vector<Int_t>();
31 m_iNV = new std::vector<Int_t>();
32
33 for (auto & iLayer : m_iFibSel)
34 {
35 iLayer = nullptr;
36 iLayer = new std::vector<Int_t>();
37 }
38
39 m_iTrackMatch[0] = nullptr;
40 m_iTrackMatch[1] = nullptr;
41 m_iTrackMatch[0] = new std::vector<Int_t>();
42 m_iTrackMatch[1] = new std::vector<Int_t>();
43}
44
45ALFA_MDMultiple::ALFA_MDMultiple(const ALFA_MDMultiple &obj) :
46 AthMessaging("ALFA_MDMultiple")
47{
48// std::copy(obj.m_iNumHitsLayer, obj.m_iNumHitsLayer + sizeof(obj.m_iNumHitsLayer)/sizeof(Int_t), m_iNumHitsLayer);
49 std::copy(obj.m_iNumHitsLayer, obj.m_iNumHitsLayer + ALFALAYERSCNT*ALFAPLATESCNT, m_iNumHitsLayer);
50
51 m_fOverlapCut = obj.m_fOverlapCut;
52 m_iMultiplicityCut = obj.m_iMultiplicityCut;
53 m_iNumLayerCut = obj.m_iNumLayerCut;
54 m_iRPot = obj.m_iRPot;
55 m_iUVCut = obj.m_iUVCut;
56
57 m_fRecXPos = new std::vector<Float_t>(*obj.m_fRecXPos);
58 m_fRecYPos = new std::vector<Float_t>(*obj.m_fRecYPos);
59 m_fOvU = new std::vector<Float_t>(*obj.m_fOvU);
60 m_fOvV = new std::vector<Float_t>(*obj.m_fOvV);
61 m_iNU = new std::vector<Int_t>(*obj.m_iNU);
62 m_iNV = new std::vector<Int_t>(*obj.m_iNV);
63
64 for (int iLayer=0; iLayer<ALFALAYERSCNT*ALFAPLATESCNT; iLayer++)
65 {
66 m_iFibSel[iLayer] = new std::vector<Int_t>(*obj.m_iFibSel[iLayer]);
67 }
68
69 m_iTrackMatch[0] = new std::vector<Int_t>(*obj.m_iTrackMatch[0]);
70 m_iTrackMatch[1] = new std::vector<Int_t>(*obj.m_iTrackMatch[1]);
71}
72
73ALFA_MDMultiple& ALFA_MDMultiple::operator=(const ALFA_MDMultiple &obj)
74{
75 if (this != &obj)
76 {
77// std::swap(m_iNumHitsLayer, obj.m_iNumHitsLayer);
78 Int_t nLayers = ALFALAYERSCNT*ALFAPLATESCNT;
79
80 for (int i = 0; i < nLayers; i++)
81 m_iNumHitsLayer[i] = obj.m_iNumHitsLayer[i];
82
83 m_fOverlapCut = obj.m_fOverlapCut;
84 m_iMultiplicityCut = obj.m_iMultiplicityCut;
85 m_iNumLayerCut = obj.m_iNumLayerCut;
86 m_iRPot = obj.m_iRPot;
87 m_iUVCut = obj.m_iUVCut;
88
89// std::swap(m_fRecXPos, obj.m_fRecXPos);
90// std::swap(m_fRecYPos, obj.m_fRecYPos);
91// std::swap(m_fOvU , obj.m_fOvU);
92// std::swap(m_fOvV , obj.m_fOvV);
93// std::swap(m_iNU , obj.m_iNU);
94// std::swap(m_iNV , obj.m_iNV);
95// std::swap(m_iFibSel, obj.m_iFibSel);
96// std::swap(m_iTrackMatch, obj.m_iTrackMatch);
97
98 std::copy(m_fRecXPos->begin(), m_fRecXPos->end(), obj.m_fRecXPos->begin());
99 std::copy(m_fRecYPos->begin(), m_fRecYPos->end(), obj.m_fRecYPos->begin());
100 std::copy(m_fOvU->begin(), m_fOvU->end(), obj.m_fOvU->begin());
101 std::copy(m_fOvV->begin(), m_fOvV->end(), obj.m_fOvV->begin());
102 std::copy(m_iNU->begin(), m_iNU->end(), obj.m_iNU->begin());
103 std::copy(m_iNV->begin(), m_iNV->end(), obj.m_iNV->begin());
104
105 for (int iLayer = 0; iLayer < nLayers; iLayer++)
106 {
107 m_iFibSel[iLayer] = nullptr;
108 m_iFibSel[iLayer] = new std::vector<Int_t>();
109 std::copy(m_iFibSel[iLayer]->begin(), m_iFibSel[iLayer]->end(), obj.m_iFibSel[iLayer]->begin());
110 }
111
112 m_iTrackMatch[0] = nullptr;
113 m_iTrackMatch[1] = nullptr;
114 m_iTrackMatch[0] = new std::vector<Int_t>();
115 m_iTrackMatch[1] = new std::vector<Int_t>();
116 std::copy(m_iTrackMatch[0]->begin(), m_iTrackMatch[0]->end(), obj.m_iTrackMatch[0]->begin());
117 std::copy(m_iTrackMatch[1]->begin(), m_iTrackMatch[1]->end(), obj.m_iTrackMatch[1]->begin());
118 }
119
120 return *this;
121}
122
123ALFA_MDMultiple::~ALFA_MDMultiple()
124{
125 if (m_fRecXPos!=nullptr) {delete m_fRecXPos; m_fRecXPos=nullptr;}
126 if (m_fRecYPos!=nullptr) {delete m_fRecYPos; m_fRecYPos=nullptr;}
127 if (m_fOvU!=nullptr) {delete m_fOvU; m_fOvU=nullptr;}
128 if (m_fOvV!=nullptr) {delete m_fOvV; m_fOvV=nullptr;}
129 if (m_iNU!=nullptr) {delete m_iNU; m_iNU=nullptr;}
130 if (m_iNV!=nullptr) {delete m_iNV; m_iNV=nullptr;}
131
132 for (auto & iLayer : m_iFibSel)
133 {
134 if (iLayer!=nullptr) {delete iLayer; iLayer=nullptr;}
135 }
136 if (m_iTrackMatch[0]!=nullptr) {delete m_iTrackMatch[0]; m_iTrackMatch[0]=nullptr;}
137 if (m_iTrackMatch[1]!=nullptr) {delete m_iTrackMatch[1]; m_iTrackMatch[1]=nullptr;}
138}
139
140StatusCode ALFA_MDMultiple::Initialize(Int_t iRPot, Float_t faMD[RPOTSCNT][ALFALAYERSCNT*ALFAPLATESCNT][ALFAFIBERSCNT], Float_t fbMD[RPOTSCNT][ALFALAYERSCNT*ALFAPLATESCNT][ALFAFIBERSCNT], Int_t iMultiplicityCut, Int_t iNumLayerCut, Int_t iUVCut, Float_t fOverlapCut)
141{
142 ATH_MSG_DEBUG("ALFA_MDMultiple::Initialize()");
143
144 m_iRPot = iRPot;
145 m_iUVCut = iUVCut;
146 m_iNumLayerCut = iNumLayerCut;
147 m_iMultiplicityCut = iMultiplicityCut;
148 m_fOverlapCut = fOverlapCut;
149
150 for (Int_t iPot=0; iPot<RPOTSCNT; iPot++)
151 {
152 for (Int_t iLayer=0; iLayer<ALFALAYERSCNT*ALFAPLATESCNT; iLayer++)
153 {
154 for (Int_t iFiber=0; iFiber<ALFAFIBERSCNT; iFiber++)
155 {
156 m_faMD[iPot][iLayer][iFiber] = faMD[iPot][iLayer][iFiber];
157 m_fbMD[iPot][iLayer][iFiber] = fbMD[iPot][iLayer][iFiber];
158 }
159 }
160 }
161
162// std::cout << "m_iMultiplicityCut, m_iUVCut = " << m_iMultiplicityCut << ", " << m_iUVCut << std::endl;
163
164 return StatusCode::SUCCESS;
165}
166
167StatusCode ALFA_MDMultiple::Execute(const std::list<MDHIT> &ListMDHits)
168{
169 ATH_MSG_DEBUG("ALFA_MDMultiple::Execute()");
170
171 FIBERS structFibers;
172 m_MapLayers.clear();
173
174 std::list<MDHIT>::const_iterator iter;
175 for (iter=ListMDHits.begin(); iter!=ListMDHits.end(); ++iter)
176 {
177 if (m_iRPot == (*iter).iRPot)
178 {
179 if(m_MapLayers.find((*iter).iPlate)==m_MapLayers.end())
180 {
181 structFibers.ListFibers.clear();
182 m_MapLayers.insert(std::pair<int, FIBERS>((*iter).iPlate, structFibers));
183 m_MapLayers[(*iter).iPlate].ListFibers.push_back((*iter).iFiber);
184 }
185 else m_MapLayers[(*iter).iPlate].ListFibers.push_back((*iter).iFiber);
186 }
187 }
188
189 // RECONSTRUCTION
190 std::vector<double> b_p, b_n;
191 std::vector<double> Ov_p, Ov_n;
192 std::vector<int> Num_p, Num_n;
193 std::vector<int> FSel_n[ALFAPLATESCNT], FSel_p[ALFAPLATESCNT];
194 std::vector<int> iTrackMatch[2];
195
196
197 //Checking that the multiplicity cut conditions are satisfied
198 //At least more than UV_cut layers have a multiplicity lower than multi_cut
199// Int_t iNumUFiberHits=0, iNumVFiberHits=0;
200// for (Int_t iLayer=0; iLayer<ALFALAYERSCNT*ALFAPLATESCNT; iLayer++)
201// {
202// if ((Int_t)m_MapLayers[iLayer].ListFibers.size()<=m_iMultiplicityCut && (Int_t)m_MapLayers[iLayer].ListFibers.size()>0)
203// {
204// // prohozen U/V?
205// // if (fmod(double(iLayer),double(2)) == 1) iNumUFiberHits++;
206// // else iNumVFiberHits++;
207//
208// if (fmod(double(iLayer),double(2)) == 0) iNumUFiberHits++;
209// else iNumVFiberHits++;
210// }
211// }
212
213// if (iNumUFiberHits>=m_iMultiplicityCut && iNumVFiberHits>=m_iMultiplicityCut)
214 {
215 Reco_Track(b_p, b_n, Ov_p, Ov_n, Num_p, Num_n, FSel_n, FSel_p, iTrackMatch);
216
217 //Now sorting the tracks using NumU+NumV criteria -------------------------------
218 Int_t iCntSort=0;
219 Int_t iMaxSum=0;
220 std::vector<Int_t> MaxTrackID;
221 Int_t iTmpMaxTrackID = -1;
222
223// std::cout << "b_p.size = " << b_p.size() << std::endl;
224 while (iCntSort<(Int_t)b_p.size())
225 {
226 iMaxSum=0;
227 for (Int_t i=0; i<(Int_t)b_p.size(); i++)
228 {
229 //Checking that the maximum was not already used
230 Bool_t MaxUsed=false;
231
232 for (int j : MaxTrackID)
233 {
234 if (i==j) {MaxUsed = true; break;}
235 }
236
237 if (((Num_p[i]+Num_n[i])>iMaxSum) && (!MaxUsed))
238 {
239 iMaxSum = Num_p[i]+Num_n[i];
240 iTmpMaxTrackID=i;
241 }
242 }
243 MaxTrackID.push_back(iTmpMaxTrackID);
244 iCntSort++;
245 }
246
247// std::cout << "MaxTrackID size = " << MaxTrackID.size() << std::endl;
248
249// for (Int_t i=0; i<(Int_t)b_p.size();i++)
250 for (int i : MaxTrackID)
251 {
252// std::cout << " [" << i << "] = " << MaxTrackID[i] << std::endl;
253// if (fabs((b_p[i]+b_n[i])/2.0) < 135.5)
254 {
255 m_fRecXPos->push_back((b_p[i]-b_n[i])/2.0);
256 m_fRecYPos->push_back((b_p[i]+b_n[i])/2.0);
257
258 m_fOvU->push_back(Ov_p[i]);
259 m_fOvV->push_back(Ov_n[i]);
260 m_iNU->push_back(Num_p[i]);
261 m_iNV->push_back(Num_n[i]);
262
263 //the U and V are somehow interchanged, therefore they are here interchanged back.
264// m_fOvU->push_back(Ov_n[MaxTrackID[i]]); //just for test
265// m_fOvV->push_back(Ov_p[MaxTrackID[i]]); //just for test
266// m_iNU->push_back(Num_n[MaxTrackID[i]]); //just for test
267// m_iNV->push_back(Num_p[MaxTrackID[i]]); //just for test
268
269 m_iTrackMatch[0]->push_back(iTrackMatch[0][i]);
270 m_iTrackMatch[1]->push_back(iTrackMatch[1][i]);
271
272// std::cout << "iTrackMatch[0][" << MaxTrackID[i] << "] = " << iTrackMatch[0][MaxTrackID[i]] << std::endl;
273// std::cout << "iTrackMatch[1][" << MaxTrackID[i] << "] = " << iTrackMatch[1][MaxTrackID[i]] << std::endl;
274// std::cout << "x, y = " << (b_p[MaxTrackID[i]]-b_n[MaxTrackID[i]])/2.0 << ", " << (b_p[MaxTrackID[i]]+b_n[MaxTrackID[i]])/2.0 << std::endl;
275
276 for (Int_t iPlate=0; iPlate<ALFAPLATESCNT; iPlate++)
277 {
278 m_iFibSel[2*iPlate]->push_back(FSel_p[iPlate][i]);
279 m_iFibSel[2*iPlate+1]->push_back(FSel_n[iPlate][i]);
280// m_iFibSel[2*iPlate+1]->push_back(FSel_p[iPlate][MaxTrackID[i]]); //just for test
281// m_iFibSel[2*iPlate]->push_back(FSel_n[iPlate][MaxTrackID[i]]); //just for test
282 }
283 }
284 }
285// {
287// {
288// m_fRecXPos->push_back((b_p[i]-b_n[i])/2.0);
289// m_fRecYPos->push_back((b_p[i]+b_n[i])/2.0);
290
295
296// //the U and V are somehow interchanged, therefore they are here interchanged back.
297// m_fOvU->push_back(Ov_n[i]);
298// m_fOvV->push_back(Ov_p[i]);
299// m_iNU->push_back(Num_n[i]);
300// m_iNV->push_back(Num_p[i]);
301
302// m_iTrackMatch[0]->push_back(iTrackMatch[0][i]);
303// m_iTrackMatch[1]->push_back(iTrackMatch[1][i]);
304
305// std::cout << "iTrackMatch[0][" << i << "] = " << iTrackMatch[0][i] << std::endl;
306// std::cout << "iTrackMatch[1][" << i << "] = " << iTrackMatch[1][i] << std::endl;
307// std::cout << "x, y = " << (b_p[i]-b_n[i])/2.0 << ", " << (b_p[i]+b_n[i])/2.0 << std::endl;
308
309// for (Int_t iPlate=0; iPlate<ALFAPLATESCNT; iPlate++)
310// {
313// m_iFibSel[2*iPlate+1]->push_back(FSel_p[iPlate][i]);
314// m_iFibSel[2*iPlate]->push_back(FSel_n[iPlate][i]);
315// }
316// }
317
318// }
319
320// std::cout << "------------------------------------------------------------------" << std::endl;
321 }
322
323
324 return StatusCode::SUCCESS;
325}
326
327StatusCode ALFA_MDMultiple::Finalize(Float_t (&fRecXPos)[MAXTRACKNUM], Float_t (&fRecYPos)[MAXTRACKNUM])
328{
329 ATH_MSG_DEBUG("ALFA_MDMultiple::Finalize()");
330
331 Int_t iTrackNum=0, iSize=0;
332 std::fill_n(&fRecXPos[0], sizeof(fRecXPos)/sizeof(Float_t), -9999.0);
333 std::fill_n(&fRecYPos[0], sizeof(fRecYPos)/sizeof(Float_t), -9999.0);
334
335 iSize = (m_fRecXPos->size() <= m_fRecYPos->size())? m_fRecXPos->size() : m_fRecYPos->size();
336 iTrackNum = (iSize < MAXTRACKNUM)? iSize : MAXTRACKNUM;
337
338 for (Int_t i=0; i<iTrackNum; i++)
339 {
340 fRecXPos[i] = m_fRecXPos->at(i);
341 fRecYPos[i] = m_fRecYPos->at(i);
342 }
343
344 return StatusCode::SUCCESS;
345}
346
347/************************************************/
348/* Making projection and storing in an array */
349/************************************************/
350void ALFA_MDMultiple::Proj_Store(Int_t iFiberSide, Int_t (&iOver)[72000], Float_t fbRef, Int_t iSideFlag)
351{
352 ATH_MSG_DEBUG("ALFA_MDMultiple::Pro_Store()");
353
354 Float_t fSign;
355 Float_t fXInter, fYInter;
356 Float_t FibCen;
357
358 if (m_faMD[m_iRPot][iSideFlag][0]>0) fSign=1.0;
359 else fSign=-1.0;
360
361 for (int & iBin : iOver)
362 {
363 iBin=0;
364 }
365
366 // coverity bug 13955 fixed bellow
367// std::list<int>::iterator intIter;
368// for (Int_t iLayer=0; iLayer<ALFAPLATESCNT; iLayer++)
369// {
370// for (intIter=m_MapLayers[2*iLayer+iFiberSide].ListFibers.begin(); intIter!=m_MapLayers[2*iLayer+iFiberSide].ListFibers.end(); intIter++)
371// {
372// if (*intIter!=9999)
373// {
374// //Depending on layer orientation, computing the projection of the hit fiber
375// fXInter= fSign*(fbRef-m_fbMD[m_iRPot][iLayer*2+iSideFlag][*intIter])/(1+fSign*m_faMD[m_iRPot][iLayer*2+iSideFlag][*intIter]);
376// fYInter= (fSign*m_faMD[m_iRPot][iLayer*2+iSideFlag][*intIter]*fbRef+m_fbMD[m_iRPot][iLayer*2+iSideFlag][*intIter])/(1+fSign*m_faMD[m_iRPot][iLayer*2+iSideFlag][*intIter])-fbRef;
377// FibCen = (fYInter-fSign*fXInter)/sqrt(2.0);
378
379// //Filling the table with the hit fiber
380// for (Int_t iBin=0; iBin<480; iBin++)
381// {
382// iOver[(int)((FibCen-0.24)*1000)+iBin+36000]++;
383// }
384// }
385// }
386// }
387
388 for (UInt_t iLayer=0; iLayer!=ALFAPLATESCNT; ++iLayer)
389 {
390 const unsigned int thisSideLayer = iLayer*2+iSideFlag;
391 const unsigned int thisLayer = 2*iLayer+iFiberSide;
392 const std::list<int> & thisFiberContainer = m_MapLayers[thisLayer].ListFibers;
393 for (const auto & thisFiber:thisFiberContainer)
394 {
395 if (thisFiber!=9999)
396 {
397 //Depending on layer orientation, computing the projection of the hit fiber
398 fXInter= fSign*(fbRef-m_fbMD[m_iRPot][thisSideLayer][thisFiber])/(1+fSign*m_faMD[m_iRPot][thisSideLayer][thisFiber]);
399 fYInter= (fSign*m_faMD[m_iRPot][thisSideLayer][thisFiber]*fbRef+m_fbMD[m_iRPot][thisSideLayer][thisFiber])/(1+fSign*m_faMD[m_iRPot][thisSideLayer][thisFiber])-fbRef;
400 FibCen = (fYInter-fSign*fXInter)/sqrt(2.0);
401
402 //Filling the table with the hit fiber
403 for (Int_t iBin=0; iBin<480; iBin++)
404 {
405 iOver[(int)((FibCen-0.24)*1000)+iBin+36000]++;
406 }
407 }
408 }
409 }
410}
411
412/************************************************/
413/* Making projection and storing in an array */
414/************************************************/
415void ALFA_MDMultiple::Proj_Store(const std::vector<Int_t> (&FiberHit)[ALFAPLATESCNT], Int_t (&iOver)[72000], Float_t fbRef, Int_t iSideFlag)
416{
417 ATH_MSG_DEBUG("ALFA_MDMultiple::Pro_Store()");
418
419 Float_t fSign;
420 Float_t fXInter, fYInter;
421 Float_t FibCen;
422
423 if (m_faMD[m_iRPot][iSideFlag][0]>0) fSign=1.0;
424 else fSign=-1.0;
425
426 for (int & iBin : iOver)
427 {
428 iBin=0;
429 }
430
431 int iHit = 9999;
432 for (Int_t iLayer=0; iLayer<ALFAPLATESCNT; iLayer++)
433 {
434 for (UInt_t j=0; j<FiberHit[iLayer].size(); j++)
435 {
436 iHit = FiberHit[iLayer][j];
437 if (iHit!=9999)
438 {
439 //Depending on layer orientation, computing the projection of the hit fiber
440 fXInter= fSign*(fbRef-m_fbMD[m_iRPot][iLayer*2+iSideFlag][iHit])/(1+fSign*m_faMD[m_iRPot][iLayer*2+iSideFlag][iHit]);
441 fYInter= (fSign*m_faMD[m_iRPot][iLayer*2+iSideFlag][iHit]*fbRef+m_fbMD[m_iRPot][iLayer*2+iSideFlag][iHit])/(1+fSign*m_faMD[m_iRPot][iLayer*2+iSideFlag][iHit])-fbRef;
442 FibCen = (fYInter-fSign*fXInter)/sqrt(2.0);
443
444 //Filling the table with the hit fiber
445 for (Int_t iBin=0; iBin<480; iBin++)
446 {
447 iOver[(int)((FibCen-0.24)*1000)+iBin+36000]++;
448 }
449 }
450 }
451 }
452}
453
454/************************************************/
455/* Identifying plateau in projection array */
456/************************************************/
457void ALFA_MDMultiple::Find_Proj(const Int_t iOver[72000], Float_t fbRef, Float_t &fb, Float_t &fOv, Int_t &iNum)
458{
459 ATH_MSG_DEBUG("ALFA_MDMultiple::Find_Proj()");
460
461 std::vector<int> iSizePlateau;
462 Int_t iNumFib=0;
463 Int_t p_tmp_min;
464// Int_t p_tmp_max;
465 Float_t p_min;
466 Float_t p_max;
467
468 //Determine the maximum number of overlapping fibers in both directions
469 for (Int_t i=0;i<72000;i++)
470 {
471 if (iOver[i]>iNumFib) iNumFib=iOver[i];
472 }
473
474 // Filling array for all values equal to the maximum
475 if (iNumFib>=m_iUVCut)
476 {
477 for (Int_t i=0;i<72000;i++)
478 {
479 if (iOver[i]==iNumFib)
480 {
481 iSizePlateau.push_back(i);
482 }
483 }
484
485// Finding first and last position where the maximum is found
486 p_min = -36.0 + double(iSizePlateau.front())*1e-3;
487 p_tmp_min = iSizePlateau.front();
488
489 p_max = -36.0 + double(iSizePlateau.back())*1e-3;
490// p_tmp_max = iSizePlateau.back();
491
492// Making sure that the plateau belongs to the same track
493 Int_t full_width = iSizePlateau.size();
494
495 for (Int_t i=0; i<full_width; i++)
496 {
497 if (iSizePlateau[full_width-i-1]-p_tmp_min < 500)
498 {
499// p_tmp_max = iSizePlateau[full_width-i-1];
500 p_max = -36.0 + double(iSizePlateau[full_width-i-1])*1e-3;
501
502 break;
503 }
504 }
505
506 if ((p_max-p_min)<m_fOverlapCut)
507 {
508// Storing the coordinate of the maximum
509 fb = fbRef+(p_min+p_max)/sqrt(2.0);
510 fOv = p_max-p_min;
511 }
512 }
513
514 iNum = iNumFib;
515}
516
517/************************************************/
518/************************************************/
519/* Identifying fibers on the track */
520/************************************************/
521/************************************************/
522
523void ALFA_MDMultiple::Finding_Fib(Int_t iFiberSide, Float_t fbRef, Float_t fbRec, Int_t (&iFSel)[10], Int_t iSideFlag)
524{
525 ATH_MSG_DEBUG("ALFA_MDMultiple::Finding_Fib()");
526
527 Float_t b_pos, b_neg;
528 Float_t x, y, x_tmp, y_tmp;
529 Float_t min_dist;
530 Float_t dist_x, dist_y;
531 Float_t dist_full;
532 Float_t fib_dist;
533// Int_t gFib;
534
535 if (iSideFlag==0)
536 {
537 b_neg= fbRef;
538 b_pos= fbRec;
539 }
540 else
541 {
542 b_neg= fbRec;
543 b_pos= fbRef;
544 }
545
546 x= (b_pos-b_neg)/2.0;
547 y= (b_neg+b_pos)/2.0;
548
549 for (int & iLayer : iFSel) iLayer = 9999;
550
551 //For each layer, we determine the hit fiber which is closest to the track
552 std::list<int>::iterator intIter;
553 for (Int_t iLayer = 0; iLayer<ALFAPLATESCNT; iLayer++)
554 {
555 min_dist=0.24;
556// gFib = 9999;
557
558 // coverity bug 13956 fixed
559// for (intIter=m_MapLayers[2*iLayer+iFiberSide].ListFibers.begin(); intIter!=m_MapLayers[2*iLayer+iFiberSide].ListFibers.end(); intIter++)
560// {
561// if (*intIter!=9999)
562// {
563// x_tmp = (y-m_fbMD[m_iRPot][iLayer*2+iSideFlag][*intIter])/m_faMD[m_iRPot][iLayer*2+iSideFlag][*intIter];
564// y_tmp = m_faMD[m_iRPot][iLayer*2+iSideFlag][*intIter]*x+m_fbMD[m_iRPot][iLayer*2+iSideFlag][*intIter];
565
566// dist_x = TMath::Abs(x-x_tmp);
567// dist_y = TMath::Abs(y-y_tmp);
568
569// dist_full = sqrt(dist_x*dist_x+dist_y*dist_y);
570// fib_dist = sqrt(TMath::Power((dist_x+dist_y)/2.0,2)-TMath::Power(dist_full/2.0,2));
571
572// if (fib_dist <= min_dist)
573// {
574// min_dist = fib_dist;
575// gFib = *intIter;
576// iFSel[iLayer] = gFib;
577// }
578// }
579// }
580
581 const unsigned int thisSideLayer = iLayer*2+iSideFlag;
582 const unsigned int thisLayer = 2*iLayer+iFiberSide;
583 const std::list<int> & thisFiberContainer = m_MapLayers[thisLayer].ListFibers;
584 for (const auto & thisFiber:thisFiberContainer)
585 {
586 if (thisFiber != 9999)
587 {
588 x_tmp = (y-m_fbMD[m_iRPot][thisSideLayer][thisFiber])/m_faMD[m_iRPot][thisSideLayer][thisFiber];
589 y_tmp = m_faMD[m_iRPot][thisSideLayer][thisFiber]*x+m_fbMD[m_iRPot][thisSideLayer][thisFiber];
590
591 dist_x = TMath::Abs(x-x_tmp);
592 dist_y = TMath::Abs(y-y_tmp);
593
594 dist_full = sqrt(dist_x*dist_x+dist_y*dist_y);
595 fib_dist = sqrt(TMath::Power((dist_x+dist_y)/2.0,2)-TMath::Power(dist_full/2.0,2));
596
597 if (fib_dist <= min_dist)
598 {
599 min_dist = fib_dist;
600 iFSel[iLayer] = thisFiber;
601 }
602 }
603 }
604
605
606/*
607 std::list<int> listFibersTmp = m_MapLayers[2*iLayer+iFiberSide].ListFibers;
608 std::list<int>::const_iterator itBeg = listFibersTmp.begin();
609 std::list<int>::const_iterator itEnd = listFibersTmp.end();
610 for (; itBeg!=itEnd; ++itBeg)
611 {
612 if (*itBeg!=9999)
613 {
614 x_tmp = (y-m_fbMD[m_iRPot][iLayer*2+iSideFlag][*itBeg])/m_faMD[m_iRPot][iLayer*2+iSideFlag][*itBeg];
615 y_tmp = m_faMD[m_iRPot][iLayer*2+iSideFlag][*itBeg]*x+m_fbMD[m_iRPot][iLayer*2+iSideFlag][*itBeg];
616
617 dist_x = TMath::Abs(x-x_tmp);
618 dist_y = TMath::Abs(y-y_tmp);
619
620 dist_full = sqrt(dist_x*dist_x+dist_y*dist_y);
621 fib_dist = sqrt(TMath::Power((dist_x+dist_y)/2.0,2)-TMath::Power(dist_full/2.0,2));
622
623 if (fib_dist <= min_dist)
624 {
625 min_dist = fib_dist;
626 gFib = *itBeg;
627
628 iFSel[iLayer] = gFib;
629 }
630 }
631 }
632*/
633
634 }
635}
636
637/************************************************/
638/* Finding all tracks */
639/************************************************/
640
641void ALFA_MDMultiple::Reco_Track(std::vector<double> &b_p, std::vector<double> &b_n,
642 std::vector<double> &Ov_p, std::vector<double> &Ov_n,
643 std::vector<int> &Num_p, std::vector<int> &Num_n,
644 std::vector<int> (&FSel_n)[ALFAPLATESCNT], std::vector<int> (&FSel_p)[ALFAPLATESCNT],
645 std::vector<int> (&iTrackMatch)[2])
646{
647 ATH_MSG_DEBUG("ALFA_MDMultiple::Reco_Track()");
648
649// Int_t FSel_pos[ALFAPLATESCNT];
650 Int_t FSel_neg[ALFAPLATESCNT];
651 Int_t FSel_pos_tmp[ALFAPLATESCNT];
652 Int_t Over_p[72000];
653 Int_t Over_n[72000];
654 Int_t cnt_step_U=0;
655 Int_t cnt_step_V=0;
656 Int_t NumU=0;
657 Int_t NumV=0;
658 Float_t b_ref_p;
659 Float_t b_ref_n;
660 Float_t OvU;
661 Float_t OvV;
662 Float_t b_pos;
663 Float_t b_neg;
664
665 std::list<int>::iterator intIter;
666
667
668 //clear
669 for (Int_t i=0; i<ALFAPLATESCNT; i++)
670 {
671 FSel_n[i].clear();
672 FSel_p[i].clear();
673 }
674 b_n.clear();
675 b_p.clear();
676 Ov_n.clear();
677 Ov_p.clear();
678 Num_n.clear();
679 Num_p.clear();
680
681 int iNumUFiberHits = 0;
682 int iNumVFiberHits = 0;
683
684 std::vector<Int_t> Fiber_MB_tmp[ALFAPLATESCNT];
685 std::vector<Int_t> Fiber_MB_n[ALFAPLATESCNT];
686
687 //fix coverity 13959 - following code replaced by next for loop
688// std::list<int>::iterator it;
689// for (UInt_t iLayer=0; iLayer<ALFAPLATESCNT; iLayer++)
690// {
691// Fiber_MB_n[iLayer].clear();
692// for (it=m_MapLayers[2*iLayer+1].ListFibers.begin(); it!=m_MapLayers[2*iLayer+1].ListFibers.end(); it++)
694// {
695// Fiber_MB_n[iLayer].push_back(*it);
696// }
697// }
698
699 for (UInt_t iLayer=0; iLayer!=ALFAPLATESCNT; ++iLayer)
700 {
701 Fiber_MB_n[iLayer].clear();
702 const unsigned int thisLayer=2*iLayer+1;
703 const std::list<int> & thisFiberContainer = m_MapLayers[thisLayer].ListFibers;
704 for (const auto & thisFiber:thisFiberContainer)
705 {
706// std::cout << "thisFiber: " << thisFiber << std::endl;
707 Fiber_MB_n[iLayer].push_back(thisFiber);
708 }
709 }
710 do
711 {
712 b_ref_n=-127.0;
713 b_ref_p=-127.0;
714
715// First projection step on U side
716// -------------------------------
717// filling the array for U side with reference value
718 Proj_Store(0, Over_p, b_ref_n, 0);
719// Proj_Store(1, Over_p, b_ref_n, 0); //just for test
720// Proj_Store(1, Over_p, b_ref_n, 1); //just for test
721
722// Find first maxium
723 Find_Proj(Over_p, b_ref_n, b_pos, OvU, NumU);
724
725 Finding_Fib(0, b_ref_n, b_pos, FSel_pos_tmp, 0);
726// Finding_Fib(1, b_ref_n, b_pos, FSel_pos_tmp, 0); //just for test
727// Finding_Fib(1, b_ref_n, b_pos, FSel_pos_tmp, 1); //just for test
728 for (int i=0; i<ALFAPLATESCNT; i++)
729 {
730 Fiber_MB_tmp[i].clear();
731 Fiber_MB_tmp[i].push_back(FSel_pos_tmp[i]);
732 }
733
734// // added ----------
735// std::cout << "FSel_pos after 1st U proj: ";
736// for (Int_t iLayer=0; iLayer<ALFAPLATESCNT; iLayer++)
737// {
738// std::cout << " " << FSel_pos[iLayer];
739// }
740// std::cout << std::endl;
741
742 //Then reconstruction all tracks possible using the second side
743 for (UInt_t iLayer=0; iLayer<ALFAPLATESCNT; iLayer++)
744 {
745 m_MapLayers[2*iLayer+1].ListFibers.clear();
746// m_MapLayers[2*iLayer].ListFibers.clear(); //just for test
747 for (unsigned int i=0; i<Fiber_MB_n[iLayer].size(); i++)
748 {
749 m_MapLayers[2*iLayer+1].ListFibers.push_back(Fiber_MB_n[iLayer][i]);
750// m_MapLayers[2*iLayer].ListFibers.push_back(Fiber_MB_n[iLayer][i]); //just for test
751 }
752 }
753
754// std::cout << "NumU " << NumU << std::endl;
755
756// Then reconstruct all tracks possible using the second side
757 if (NumU>=m_iUVCut)
758 {
759 cnt_step_V=0;
760 do
761 {
762 // New Part to apply the multiplicity cut at each iteration
763 iNumUFiberHits=0;
764 iNumVFiberHits=0;
765 for (UInt_t iLayer=0;iLayer<ALFAPLATESCNT;iLayer++)
766 {
767 if ((Int_t)m_MapLayers[2*iLayer].ListFibers.size()<=m_iMultiplicityCut && !m_MapLayers[2*iLayer].ListFibers.empty()) iNumUFiberHits++;
768 if ((Int_t)m_MapLayers[2*iLayer+1].ListFibers.size()<=m_iMultiplicityCut && !m_MapLayers[2*iLayer+1].ListFibers.empty()) iNumVFiberHits++;
769// if ((Int_t)m_MapLayers[2*iLayer+1].ListFibers.size()<=m_iMultiplicityCut && m_MapLayers[2*iLayer+1].ListFibers.size()>0) iNumUFiberHits++; //just for test
770// if ((Int_t)m_MapLayers[2*iLayer].ListFibers.size()<=m_iMultiplicityCut && m_MapLayers[2*iLayer].ListFibers.size()>0) iNumVFiberHits++; //just for test
771 }
772
773// std::cout << "2nd multiplicity cut " << iNumUFiberHits << " " << iNumVFiberHits << std::endl;
774
775 if (iNumUFiberHits>=m_iNumLayerCut && iNumVFiberHits>=m_iNumLayerCut)
776 {
777 //First projection on V side
778 //-------------------------------
779 //filling the array for V side with reference value
780 Proj_Store(1, Over_n, b_ref_p, 1);
781// Proj_Store(0, Over_n, b_ref_p, 1); //just for test
782// Proj_Store(0, Over_n, b_ref_p, 0); //just for test
783 Find_Proj(Over_n, b_ref_p, b_neg, OvV, NumV);
784
785// std::cout << "NumV " << NumV << std::endl;
786
787 if (NumV>=m_iUVCut)
788 {
789 //Now make the second projection step
790 //-----------------------------------
791 //U side
792// Proj_Store(0, Over_p, b_neg, 0);
793 // Proj_Store(1, Over_p, b_neg, 0); //just for test
794 Proj_Store(Fiber_MB_tmp, Over_p, b_neg, 0);
795// Proj_Store(Fiber_MB_tmp, Over_p, b_neg, 1); //just for test
796 Find_Proj(Over_p, b_neg, b_pos, OvU, NumU);
797
798 //V side
799 Proj_Store(1, Over_n, b_pos, 1);
800// Proj_Store(0, Over_n, b_pos, 1); //just for test
801// Proj_Store(0, Over_n, b_pos, 0); //just for test
802 Find_Proj(Over_n, b_pos, b_neg, OvV, NumV);
803
804 //Third projection steps
805 //----------------------
806 //U side
807// Proj_Store(0, Over_p, b_neg, 0);
808 // Proj_Store(1, Over_p, b_neg, 0); //just for test
809 Proj_Store(Fiber_MB_tmp, Over_p, b_neg, 0);
810// Proj_Store(Fiber_MB_tmp, Over_p, b_neg, 1); //just for test
811 Find_Proj(Over_p, b_neg, b_pos, OvU, NumU);
812
813 //V side
814 Proj_Store(1, Over_n, b_pos, 1);
815// Proj_Store(0, Over_n, b_pos, 1); //just for test
816// Proj_Store(0, Over_n, b_pos, 0); //just for test
817 Find_Proj(Over_n, b_pos, b_neg, OvV, NumV);
818
819 // //We store the information in the vector
820 b_p.push_back(b_pos);
821 Ov_p.push_back(OvU);
822 Num_p.push_back(NumU);
823
824 b_n.push_back(b_neg);
825 Ov_n.push_back(OvV);
826 Num_n.push_back(NumV);
827
828 iTrackMatch[0].push_back(cnt_step_U);
829 iTrackMatch[1].push_back(cnt_step_V);
830
831 //Once done we want to remove the hit belonging to the first track on side V
832 //We first find the corresponding fibers
833// Finding_Fib(0,b_neg, b_pos, FSel_pos, 0);
834 Finding_Fib(1,b_pos, b_neg, FSel_neg, 1);
835// Finding_Fib(1,b_neg, b_pos, FSel_pos, 0); //just for test
836// Finding_Fib(0,b_pos, b_neg, FSel_neg, 1); //just for test
837// Finding_Fib(1,b_neg, b_pos, FSel_pos, 1); //just for test
838// Finding_Fib(0,b_pos, b_neg, FSel_neg, 0); //just for test
839
840 for (Int_t iLayer=0; iLayer<ALFAPLATESCNT; iLayer++)
841 {
842 FSel_n[iLayer].push_back(FSel_neg[iLayer]);
843// FSel_p[iLayer].push_back(FSel_pos[iLayer]);
844 FSel_p[iLayer].push_back(FSel_pos_tmp[iLayer]);
845 }
846
847 //added -----------------------------------------------------
848// std::cout << "FSel_n ";
849// for (Int_t iLayer=0; iLayer<ALFAPLATESCNT; iLayer++)
850// {
851// std::cout << " " << FSel_neg[iLayer];
852// }
853// std::cout << std::endl;
854// std::cout << "FSel_p ";
855// for (Int_t iLayer=0; iLayer<ALFAPLATESCNT; iLayer++)
856// {
857// std::cout << " " << FSel_pos[iLayer];
858// }
859// std::cout << std::endl;
860
861 //Removing fibers used for the first track for V Side
862 for (Int_t iLayer=0; iLayer<ALFAPLATESCNT; ++iLayer)
863 {
864 // coverity bug 30038 fixed bellow
865// std::list<int>::iterator itBeg = m_MapLayers[2*iLayer+1].ListFibers.begin();
866// std::list<int>::iterator itEnd = m_MapLayers[2*iLayer+1].ListFibers.end();
867// for (; itBeg != itEnd; itBeg++)
868// {
869// if (*itBeg == (int)FSel_neg[iLayer])
870// {
871// m_MapLayers[2*iLayer+1].ListFibers.erase(itBeg);
872// break;
873// }
874// }
875
876 const unsigned int thisLayer=2*iLayer+1;
877 const std::list<int> & thisFiberContainer = m_MapLayers[thisLayer].ListFibers;
878 for (const auto & thisFiber:thisFiberContainer)
879 {
880 if (thisFiber == (int)FSel_neg[iLayer])
881 {
882 auto it = std::find(begin(thisFiberContainer), end(thisFiberContainer), thisFiber);
883 m_MapLayers[2*iLayer+1].ListFibers.erase(it);
884 break;
885 }
886 }
887
888
889// for (intIter=m_MapLayers[2*iLayer+1].ListFibers.begin(); intIter!=m_MapLayers[2*iLayer+1].ListFibers.end(); intIter++)
891// {
893// if (*intIter==(int)FSel_neg[iLayer])
894// {
896// m_MapLayers[2*iLayer+1].ListFibers.erase(intIter);
898// break;
899// }
900// }
901 }
902 cnt_step_V++;
903 }
904 }
905 else NumV = 0;
906 }
907 while (NumV>=m_iUVCut);
908
909// When we cannot find tracks anymore for the V side, and that all combinations with the U side has been done, we start again with the U side
910// But first we remove the fibers belonging to this track
911
912// std::cout << "cnt_step_V " << cnt_step_V << std::endl;
913
914// Int_t iNumErasedFibs=0;
915 if (cnt_step_V>0)
916 {
917 for (Int_t iLayer=0; iLayer<ALFAPLATESCNT; iLayer++)
918 {
919 std::list<int>::iterator itBeg = m_MapLayers[2*iLayer].ListFibers.begin();
920 std::list<int>::iterator itEnd = m_MapLayers[2*iLayer].ListFibers.end();
921 for (; itBeg != itEnd; ++itBeg)
922 {
923 if (*itBeg == (int)FSel_pos_tmp[iLayer])
924 {
925 m_MapLayers[2*iLayer].ListFibers.erase(itBeg);
926 break;
927 }
928 }
929
930
931// for (intIter=m_MapLayers[2*iLayer].ListFibers.begin(); intIter!=m_MapLayers[2*iLayer].ListFibers.end(); intIter++)
933// {
935// if (*intIter==(int)FSel_pos_tmp[iLayer])
936// {
938// m_MapLayers[2*iLayer].ListFibers.erase(intIter);
941// break;
942// }
943
944// }
945 }
946 }
947 else
948 {
949 if (NumV>0)
950 {
951// Finding_Fib(0, b_ref_n, b_pos, FSel_pos, 0);
952// Finding_Fib(1, b_ref_n, b_pos, FSel_pos, 0); //just for test
953
954 for (Int_t iLayer=0; iLayer<ALFAPLATESCNT; iLayer++)
955 {
956 std::list<int>::iterator itBeg = m_MapLayers[2*iLayer].ListFibers.begin();
957 std::list<int>::iterator itEnd = m_MapLayers[2*iLayer].ListFibers.end();
958 for (; itBeg != itEnd; ++itBeg)
959 {
960 if (*itBeg == (int)FSel_pos_tmp[iLayer])
961 {
962 m_MapLayers[2*iLayer].ListFibers.erase(itBeg);
963 break;
964 }
965 }
966
967
968// for (intIter=m_MapLayers[2*iLayer].ListFibers.begin(); intIter!=m_MapLayers[2*iLayer].ListFibers.end(); intIter++)
970// {
972// if (*intIter==(int)FSel_pos_tmp[iLayer])
973// {
974// // *intIter = 9999;
975// m_MapLayers[2*iLayer].ListFibers.erase(intIter);
978// break;
979// }
980// }
981 }
982 }
983 else break;
984 }
985 cnt_step_U++;
986// if (iNumErasedFibs==0) NumU=0;
987 }
988 }
989 while (NumU>=m_iUVCut);
990}
991
992void ALFA_MDMultiple::GetData(Int_t (&iNumU)[MAXTRACKNUM], Int_t (&iNumV)[MAXTRACKNUM], Float_t (&fOvU)[MAXTRACKNUM], Float_t (&fOvV)[MAXTRACKNUM], Int_t (&iFibSel)[MAXTRACKNUM][ALFALAYERSCNT*ALFAPLATESCNT])
993{
994 ATH_MSG_DEBUG("ALFA_MDMultiple::GetData()");
995
996 Int_t iTrackNum;
997 Int_t iSize;
998 std::fill_n(&fOvU[0], sizeof(fOvU)/sizeof(Float_t), -9999.0);
999 std::fill_n(&fOvV[0], sizeof(fOvV)/sizeof(Float_t), -9999.0);
1000 std::fill_n(&iNumU[0], sizeof(iNumU)/sizeof(Int_t), -9999);
1001 std::fill_n(&iNumV[0], sizeof(iNumV)/sizeof(Int_t), -9999);
1002 std::fill_n(&iFibSel[0][0], sizeof(iFibSel)/sizeof(Int_t), -9999);
1003
1004 iTrackNum=0;
1005 iSize=0;
1006 for (auto & iLayer : m_iFibSel)
1007 {
1008 iSize = ((Int_t)iLayer->size() > iSize)? iLayer->size() : iSize;
1009 }
1010 iTrackNum = (iSize < MAXTRACKNUM)? iSize : MAXTRACKNUM;
1011 for (Int_t iTrack=0; iTrack<iTrackNum; iTrack++)
1012 {
1013 for (Int_t iLayer=0; iLayer<ALFALAYERSCNT*ALFAPLATESCNT; iLayer++)
1014 {
1015 iFibSel[iTrack][iLayer] = m_iFibSel[iLayer]->at(iTrack);
1016 }
1017 }
1018
1019 iTrackNum=0;
1020 iSize=0;
1021 iSize = (m_fOvU->size() <= m_fOvV->size())? m_fOvU->size() : m_fOvV->size();
1022 iTrackNum = (iSize < MAXTRACKNUM)? iSize : MAXTRACKNUM;
1023 for (Int_t iTrack=0; iTrack<iTrackNum; iTrack++)
1024 {
1025 fOvU[iTrack] = m_fOvU->at(iTrack);
1026 fOvV[iTrack] = m_fOvV->at(iTrack);
1027 }
1028
1029 iTrackNum=0;
1030 iSize=0;
1031 iSize = (m_iNU->size() <= m_iNV->size())? m_iNU->size() : m_iNV->size();
1032 iTrackNum = (iSize < MAXTRACKNUM)? iSize : MAXTRACKNUM;
1033 for (Int_t iTrack=0; iTrack<iTrackNum; iTrack++)
1034 {
1035 iNumU[iTrack] = m_iNU->at(iTrack);
1036 iNumV[iTrack] = m_iNV->at(iTrack);
1037 }
1038}
RPOTSCNT
#define RPOTSCNT
Definition ALFA_CLinkAlg.h:26
FIBERS
struct _FIBERS FIBERS
ALFA_MDMultiple.h
MAXTRACKNUM
#define MAXTRACKNUM
Definition ALFA_MDMultiple.h:25
ALFALAYERSCNT
#define ALFALAYERSCNT
Definition ALFA_constants.h:8
ALFAPLATESCNT
#define ALFAPLATESCNT
Definition ALFA_constants.h:9
ALFAFIBERSCNT
#define ALFAFIBERSCNT
Definition ALFA_constants.h:10
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
y
#define y
x
#define x
ALFA_MDMultiple::Initialize
StatusCode Initialize(Int_t iRPot, Float_t faMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT], Float_t fbMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT], Int_t iMultiplicityCut, Int_t iNumLayerCut, Int_t iUVCut, Float_t fOverlapCut)
Definition ALFA_MDMultiple.cxx:140
ALFA_MDMultiple::m_fbMD
Float_t m_fbMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT]
Definition ALFA_MDMultiple.h:44
ALFA_MDMultiple::Proj_Store
void Proj_Store(Int_t iFiberSide, Int_t(&iOver)[72000], Float_t fbRef, Int_t iSideFlag)
Definition ALFA_MDMultiple.cxx:350
ALFA_MDMultiple::Execute
StatusCode Execute(const std::list< MDHIT > &ListMDHits)
Definition ALFA_MDMultiple.cxx:167
ALFA_MDMultiple::ALFA_MDMultiple
ALFA_MDMultiple()
Definition ALFA_MDMultiple.cxx:8
ALFA_MDMultiple::Reco_Track
void Reco_Track(std::vector< double > &b_p, std::vector< double > &b_n, std::vector< double > &Ov_p, std::vector< double > &Ov_n, std::vector< int > &Num_p, std::vector< int > &Num_n, std::vector< int >(&FSel_n)[ALFAPLATESCNT], std::vector< int >(&FSel_p)[ALFAPLATESCNT], std::vector< int >(&Track_match)[2])
Definition ALFA_MDMultiple.cxx:641
ALFA_MDMultiple::Find_Proj
void Find_Proj(const Int_t iOver[72000], Float_t fbRef, Float_t &fb, Float_t &fOv, Int_t &fNum)
Definition ALFA_MDMultiple.cxx:457
ALFA_MDMultiple::m_fRecXPos
std::vector< Float_t > * m_fRecXPos
Definition ALFA_MDMultiple.h:59
ALFA_MDMultiple::Finding_Fib
void Finding_Fib(Int_t iFiberSide, Float_t fbRef, Float_t fbRec, Int_t(&iFSel)[ALFAPLATESCNT], Int_t iSideFlag)
Definition ALFA_MDMultiple.cxx:523
ALFA_MDMultiple::m_iNU
std::vector< Int_t > * m_iNU
Definition ALFA_MDMultiple.h:61
ALFA_MDMultiple::m_fOvU
std::vector< Float_t > * m_fOvU
Definition ALFA_MDMultiple.h:60
ALFA_MDMultiple::m_MapLayers
std::map< int, FIBERS > m_MapLayers
Definition ALFA_MDMultiple.h:66
ALFA_MDMultiple::m_iMultiplicityCut
Int_t m_iMultiplicityCut
Definition ALFA_MDMultiple.h:38
ALFA_MDMultiple::m_iRPot
Int_t m_iRPot
Definition ALFA_MDMultiple.h:36
ALFA_MDMultiple::operator=
ALFA_MDMultiple & operator=(const ALFA_MDMultiple &obj)
Definition ALFA_MDMultiple.cxx:73
ALFA_MDMultiple::~ALFA_MDMultiple
~ALFA_MDMultiple()
Definition ALFA_MDMultiple.cxx:123
ALFA_MDMultiple::m_faMD
Float_t m_faMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT]
Definition ALFA_MDMultiple.h:43
ALFA_MDMultiple::m_iNumLayerCut
Int_t m_iNumLayerCut
Definition ALFA_MDMultiple.h:39
ALFA_MDMultiple::Finalize
StatusCode Finalize(Float_t(&fRecXPos)[MAXTRACKNUM], Float_t(&fRecYPos)[MAXTRACKNUM])
Definition ALFA_MDMultiple.cxx:327
ALFA_MDMultiple::m_iTrackMatch
std::vector< Int_t > * m_iTrackMatch[2]
Definition ALFA_MDMultiple.h:63
ALFA_MDMultiple::m_iNV
std::vector< Int_t > * m_iNV
Definition ALFA_MDMultiple.h:61
ALFA_MDMultiple::m_iFibSel
std::vector< Int_t > * m_iFibSel[ALFALAYERSCNT *ALFAPLATESCNT]
Definition ALFA_MDMultiple.h:62
ALFA_MDMultiple::m_fRecYPos
std::vector< Float_t > * m_fRecYPos
Definition ALFA_MDMultiple.h:59
ALFA_MDMultiple::GetData
void GetData(Int_t(&iNumU)[MAXTRACKNUM], Int_t(&iNumV)[MAXTRACKNUM], Float_t(&fOvU)[MAXTRACKNUM], Float_t(&fOvV)[MAXTRACKNUM], Int_t(&iFibSel)[MAXTRACKNUM][ALFALAYERSCNT *ALFAPLATESCNT])
Definition ALFA_MDMultiple.cxx:992
ALFA_MDMultiple::m_iUVCut
Int_t m_iUVCut
Definition ALFA_MDMultiple.h:37
ALFA_MDMultiple::m_fOvV
std::vector< Float_t > * m_fOvV
Definition ALFA_MDMultiple.h:60
ALFA_MDMultiple::m_fOverlapCut
Float_t m_fOverlapCut
Definition ALFA_MDMultiple.h:40
ALFA_MDMultiple::m_iNumHitsLayer
Int_t m_iNumHitsLayer[ALFALAYERSCNT *ALFAPLATESCNT]
Definition ALFA_MDMultiple.h:47
AthMessaging::AthMessaging
AthMessaging(IMessageSvc *msgSvc, const std::string &name)
Constructor.
Definition AthMessaging.cxx:13
_FIBERS::ListFibers
std::list< int > ListFibers
Definition ALFA_LocRec/ALFA_UserObjects.h:31
Generated on for ATLAS Offline Software by doxygen 1.14.0