ATLAS Offline Software
Loading...
Searching...
No Matches
Public Member Functions | Private Member Functions | Private Attributes | List of all members
ALFA_MDMultiple Class Reference

#include <ALFA_MDMultiple.h>

Inheritance diagram for ALFA_MDMultiple:
Collaboration diagram for ALFA_MDMultiple:

Public Member Functions

 ALFA_MDMultiple ()
 ALFA_MDMultiple (const ALFA_MDMultiple &obj)
ALFA_MDMultiple & operator= (const ALFA_MDMultiple &obj)
 ~ALFA_MDMultiple ()
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)
StatusCode Execute (const std::list< MDHIT > &ListMDHits)
StatusCode Finalize (Float_t(&fRecXPos)[MAXTRACKNUM], Float_t(&fRecYPos)[MAXTRACKNUM])
void GetData (Int_t(&iNumU)[MAXTRACKNUM], Int_t(&iNumV)[MAXTRACKNUM], Float_t(&fOvU)[MAXTRACKNUM], Float_t(&fOvV)[MAXTRACKNUM], Int_t(&iFibSel)[MAXTRACKNUM][ALFALAYERSCNT *ALFAPLATESCNT])
bool msgLvl (const MSG::Level lvl) const
 Test the output level.
MsgStream & msg () const
 The standard message stream.
MsgStream & msg (const MSG::Level lvl) const
 The standard message stream.
void setLevel (MSG::Level lvl)
 Change the current logging level.

Private Member Functions

void Proj_Store (Int_t iFiberSide, Int_t(&iOver)[72000], Float_t fbRef, Int_t iSideFlag)
void Proj_Store (const std::vector< Int_t >(&FiberHit)[ALFAPLATESCNT], Int_t(&iOver)[72000], Float_t fbRef, Int_t iSideFlag)
void Find_Proj (const Int_t iOver[72000], Float_t fbRef, Float_t &fb, Float_t &fOv, Int_t &fNum)
void Finding_Fib (Int_t iFiberSide, Float_t fbRef, Float_t fbRec, Int_t(&iFSel)[ALFAPLATESCNT], Int_t iSideFlag)
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])
void initMessaging () const
 Initialize our message level and MessageSvc.

Private Attributes

Int_t m_iRPot
Int_t m_iUVCut
Int_t m_iMultiplicityCut
Int_t m_iNumLayerCut
Float_t m_fOverlapCut
Float_t m_faMD [RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT]
Float_t m_fbMD [RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT]
Int_t m_iNumHitsLayer [ALFALAYERSCNT *ALFAPLATESCNT]
std::vector< Float_t > * m_fRecXPos
std::vector< Float_t > * m_fRecYPos
std::vector< Float_t > * m_fOvU
std::vector< Float_t > * m_fOvV
std::vector< Int_t > * m_iNU
std::vector< Int_t > * m_iNV
std::vector< Int_t > * m_iFibSel [ALFALAYERSCNT *ALFAPLATESCNT]
std::vector< Int_t > * m_iTrackMatch [2]
std::map< int, FIBERS > m_MapLayers
std::string m_nm
 Message source name.
boost::thread_specific_ptr< MsgStream > m_msg_tls
 MsgStream instance (a std::cout like with print-out levels)
std::atomic< IMessageSvc * > m_imsg { nullptr }
 MessageSvc pointer.
std::atomic< MSG::Level > m_lvl { MSG::NIL }
 Current logging level.
std::atomic_flag m_initialized ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
 Messaging initialized (initMessaging)

Detailed Description

Definition at line 27 of file ALFA_MDMultiple.h.

Constructor & Destructor Documentation

◆ ALFA_MDMultiple() [1/2]

ALFA_MDMultiple::ALFA_MDMultiple ( )

Definition at line 8 of file ALFA_MDMultiple.cxx.

8 :
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}
ALFA_MDMultiple::m_fRecXPos
std::vector< Float_t > * m_fRecXPos
Definition ALFA_MDMultiple.h:59
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_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::m_iNumLayerCut
Int_t m_iNumLayerCut
Definition ALFA_MDMultiple.h:39
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::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()
Default constructor:

◆ ALFA_MDMultiple() [2/2]

ALFA_MDMultiple::ALFA_MDMultiple ( const ALFA_MDMultiple & obj)

Definition at line 45 of file ALFA_MDMultiple.cxx.

45 :
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}
ALFALAYERSCNT
#define ALFALAYERSCNT
Definition ALFA_constants.h:8
ALFAPLATESCNT
#define ALFAPLATESCNT
Definition ALFA_constants.h:9

◆ ~ALFA_MDMultiple()

ALFA_MDMultiple::~ALFA_MDMultiple ( )

Definition at line 123 of file ALFA_MDMultiple.cxx.

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}

Member Function Documentation

◆ Execute()

StatusCode ALFA_MDMultiple::Execute ( const std::list< MDHIT > & ListMDHits)

Definition at line 167 of file ALFA_MDMultiple.cxx.

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}
FIBERS
struct _FIBERS FIBERS
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
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::m_MapLayers
std::map< int, FIBERS > m_MapLayers
Definition ALFA_MDMultiple.h:66
_FIBERS::ListFibers
std::list< int > ListFibers
Definition ALFA_LocRec/ALFA_UserObjects.h:31

◆ Finalize()

StatusCode ALFA_MDMultiple::Finalize ( Float_t(&) fRecXPos[MAXTRACKNUM],
Float_t(&) fRecYPos[MAXTRACKNUM] )

Definition at line 327 of file ALFA_MDMultiple.cxx.

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}
MAXTRACKNUM
#define MAXTRACKNUM
Definition ALFA_MDMultiple.h:25

◆ Find_Proj()

void ALFA_MDMultiple::Find_Proj ( const Int_t iOver[72000],
Float_t fbRef,
Float_t & fb,
Float_t & fOv,
Int_t & fNum )
private

Definition at line 457 of file ALFA_MDMultiple.cxx.

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}

◆ Finding_Fib()

void ALFA_MDMultiple::Finding_Fib ( Int_t iFiberSide,
Float_t fbRef,
Float_t fbRec,
Int_t(&) iFSel[ALFAPLATESCNT],
Int_t iSideFlag )
private

Definition at line 523 of file ALFA_MDMultiple.cxx.

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}
y
#define y
x
#define x
ALFA_MDMultiple::m_fbMD
Float_t m_fbMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT]
Definition ALFA_MDMultiple.h:44
ALFA_MDMultiple::m_faMD
Float_t m_faMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT]
Definition ALFA_MDMultiple.h:43

◆ GetData()

void 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] )

Definition at line 992 of file ALFA_MDMultiple.cxx.

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}

◆ Initialize()

StatusCode 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 )

Definition at line 140 of file ALFA_MDMultiple.cxx.

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}
RPOTSCNT
#define RPOTSCNT
Definition ALFA_CLinkAlg.h:26
ALFAFIBERSCNT
#define ALFAFIBERSCNT
Definition ALFA_constants.h:10

◆ initMessaging()

void AthMessaging::initMessaging ( ) const
privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

40{
41 m_imsg = Athena::getMessageSvc();
42 // If user did not set an explicit level, set a default
43 if (m_lvl == MSG::NIL) {
44 m_lvl = m_imsg ?
45 static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
46 MSG::INFO;
47 }
48}
AthMessaging::m_nm
std::string m_nm
Message source name.
Definition AthMessaging.h:129
AthMessaging::m_imsg
std::atomic< IMessageSvc * > m_imsg
MessageSvc pointer.
Definition AthMessaging.h:135
AthMessaging::m_lvl
std::atomic< MSG::Level > m_lvl
Current logging level.
Definition AthMessaging.h:138
Athena::getMessageSvc
IMessageSvc * getMessageSvc(bool quiet=false)
Definition getMessageSvc.cxx:20

◆ msg() [1/2]

MsgStream & AthMessaging::msg ( ) const
inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 163 of file AthMessaging.h.

164{
165 MsgStream* ms = m_msg_tls.get();
166 if (!ms) {
167 if (!m_initialized.test_and_set()) initMessaging();
168 ms = new MsgStream(m_imsg,m_nm);
169 m_msg_tls.reset( ms );
170 }
171
172 ms->setLevel (m_lvl);
173 return *ms;
174}
AthMessaging::m_msg_tls
boost::thread_specific_ptr< MsgStream > m_msg_tls
MsgStream instance (a std::cout like with print-out levels)
Definition AthMessaging.h:132
AthMessaging::initMessaging
void initMessaging() const
Initialize our message level and MessageSvc.
Definition AthMessaging.cxx:39

◆ msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl) const
inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 178 of file AthMessaging.h.

179{ return msg() << lvl; }
AthMessaging::msg
MsgStream & msg() const
The standard message stream.
Definition AthMessaging.h:163

◆ msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl) const
inlineinherited

Test the output level.

Parameters
lvlThe message level to test against
Returns
boolean Indicating if messages at given level will be printed
Return values
trueMessages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

152{
153 if (m_lvl <= lvl) {
154 msg() << lvl;
155 return true;
156 } else {
157 return false;
158 }
159}

◆ operator=()

ALFA_MDMultiple & ALFA_MDMultiple::operator= ( const ALFA_MDMultiple & obj)

Definition at line 73 of file ALFA_MDMultiple.cxx.

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}

◆ Proj_Store() [1/2]

void ALFA_MDMultiple::Proj_Store ( const std::vector< Int_t >(&) FiberHit[ALFAPLATESCNT],
Int_t(&) iOver[72000],
Float_t fbRef,
Int_t iSideFlag )
private

Definition at line 415 of file ALFA_MDMultiple.cxx.

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}

◆ Proj_Store() [2/2]

void ALFA_MDMultiple::Proj_Store ( Int_t iFiberSide,
Int_t(&) iOver[72000],
Float_t fbRef,
Int_t iSideFlag )
private

Definition at line 350 of file ALFA_MDMultiple.cxx.

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}

◆ Reco_Track()

void ALFA_MDMultiple::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] )
private

Definition at line 641 of file ALFA_MDMultiple.cxx.

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}
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::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::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

◆ setLevel()

void AthMessaging::setLevel ( MSG::Level lvl)
inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

29{
30 m_lvl = lvl;
31}

Member Data Documentation

◆ ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

◆ m_faMD

Float_t ALFA_MDMultiple::m_faMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT]
private

Definition at line 43 of file ALFA_MDMultiple.h.

◆ m_fbMD

Float_t ALFA_MDMultiple::m_fbMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT]
private

Definition at line 44 of file ALFA_MDMultiple.h.

◆ m_fOverlapCut

Float_t ALFA_MDMultiple::m_fOverlapCut
private

Definition at line 40 of file ALFA_MDMultiple.h.

◆ m_fOvU

std::vector<Float_t>* ALFA_MDMultiple::m_fOvU
private

Definition at line 60 of file ALFA_MDMultiple.h.

◆ m_fOvV

std::vector<Float_t> * ALFA_MDMultiple::m_fOvV
private

Definition at line 60 of file ALFA_MDMultiple.h.

◆ m_fRecXPos

std::vector<Float_t>* ALFA_MDMultiple::m_fRecXPos
private

Definition at line 59 of file ALFA_MDMultiple.h.

◆ m_fRecYPos

std::vector<Float_t> * ALFA_MDMultiple::m_fRecYPos
private

Definition at line 59 of file ALFA_MDMultiple.h.

◆ m_iFibSel

std::vector<Int_t>* ALFA_MDMultiple::m_iFibSel[ALFALAYERSCNT *ALFAPLATESCNT]
private

Definition at line 62 of file ALFA_MDMultiple.h.

◆ m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }
mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

135{ nullptr };

◆ m_iMultiplicityCut

Int_t ALFA_MDMultiple::m_iMultiplicityCut
private

Definition at line 38 of file ALFA_MDMultiple.h.

◆ m_iNU

std::vector<Int_t>* ALFA_MDMultiple::m_iNU
private

Definition at line 61 of file ALFA_MDMultiple.h.

◆ m_iNumHitsLayer

Int_t ALFA_MDMultiple::m_iNumHitsLayer[ALFALAYERSCNT *ALFAPLATESCNT]
private

Definition at line 47 of file ALFA_MDMultiple.h.

◆ m_iNumLayerCut

Int_t ALFA_MDMultiple::m_iNumLayerCut
private

Definition at line 39 of file ALFA_MDMultiple.h.

◆ m_iNV

std::vector<Int_t> * ALFA_MDMultiple::m_iNV
private

Definition at line 61 of file ALFA_MDMultiple.h.

◆ m_iRPot

Int_t ALFA_MDMultiple::m_iRPot
private

Definition at line 36 of file ALFA_MDMultiple.h.

◆ m_iTrackMatch

std::vector<Int_t>* ALFA_MDMultiple::m_iTrackMatch[2]
private

Definition at line 63 of file ALFA_MDMultiple.h.

◆ m_iUVCut

Int_t ALFA_MDMultiple::m_iUVCut
private

Definition at line 37 of file ALFA_MDMultiple.h.

◆ m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }
mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

138{ MSG::NIL };

◆ m_MapLayers

std::map<int, FIBERS> ALFA_MDMultiple::m_MapLayers
private

Definition at line 66 of file ALFA_MDMultiple.h.

◆ m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls
mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

◆ m_nm

std::string AthMessaging::m_nm
privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.14.0