Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
Public Member Functions | Private Member Functions | Private Attributes | List of all members
ALFA_MDGap Class Reference

#include <ALFA_MDGap.h>

Inheritance diagram for ALFA_MDGap:
Collaboration diagram for ALFA_MDGap:

Public Member Functions

 ALFA_MDGap ()
 
 ~ALFA_MDGap ()
 
StatusCode Initialize (Int_t iRPot, Float_t faMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT], Float_t fbMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT], 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)[ALFALAYERSCNT *ALFAPLATESCNT])
 
bool msgLvl (const MSG::Level lvl) const
 Test the output level. More...
 
MsgStream & msg () const
 The standard message stream. More...
 
MsgStream & msg (const MSG::Level lvl) const
 The standard message stream. More...
 
void setLevel (MSG::Level lvl)
 Change the current logging level. More...
 

Private Member Functions

void Proj_Store (Int_t iFiberSide, 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) const
 
void Finding_Fib (Int_t iFiberSide, Float_t fbRef, Float_t fbRec, Int_t(&iFSel)[ALFAPLATESCNT], Int_t iSideFlag)
 
void Reco_Track (std::vector< Float_t > &b_p, std::vector< Float_t > &b_n, std::vector< Float_t > &Ov_p, std::vector< Float_t > &Ov_n, std::vector< int > &Num_p, std::vector< int > &Num_n, Int_t(&FSel_n)[ALFAPLATESCNT], Int_t(&FSel_p)[ALFAPLATESCNT], Int_t(&Gaps)[2][2], std::vector< Int_t > &GapsID, Bool_t(&FGaps_p)[ALFAPLATESCNT], Bool_t(&FGaps_n)[ALFAPLATESCNT], Int_t(&Gap_Fib_p)[ALFAPLATESCNT][2], Int_t(&Gap_Fib_n)[ALFAPLATESCNT][2])
 
Int_t Silent_Gap (Int_t(&Over)[72000], Float_t b_ref, Float_t b_rec, const Int_t FSel[ALFAPLATESCNT], Bool_t(&FGap)[ALFAPLATESCNT], Int_t(&Gap_Fib)[ALFAPLATESCNT][2], Float_t OverLap, Int_t iSideFlag)
 
Int_t Active_Gap (Int_t iFiberSide, Int_t(&Over)[72000], Float_t b_ref, Float_t b_rec, const Int_t FSel[ALFAPLATESCNT], Float_t OverLap, Int_t iSideFlag)
 
void initMessaging () const
 Initialize our message level and MessageSvc. More...
 

Private Attributes

Int_t m_iRPot
 
Int_t m_iUVCut
 
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]
 
Int_t m_iNU [MAXTRACKNUM]
 
Int_t m_iNV [MAXTRACKNUM]
 
Int_t m_iFibSel [ALFALAYERSCNT *ALFAPLATESCNT]
 
Float_t m_fRecXPos [MAXTRACKNUM]
 
Float_t m_fRecYPos [MAXTRACKNUM]
 
Float_t m_fOvU [MAXTRACKNUM]
 
Float_t m_fOvV [MAXTRACKNUM]
 
std::map< Int_t, FIBERS > m_MapLayers
 
std::string m_nm
 Message source name. More...
 
boost::thread_specific_ptr< MsgStream > m_msg_tls
 MsgStream instance (a std::cout like with print-out levels) More...
 
std::atomic< IMessageSvc * > m_imsg { nullptr }
 MessageSvc pointer. More...
 
std::atomic< MSG::Level > m_lvl { MSG::NIL }
 Current logging level. More...
 
std::atomic_flag m_initialized ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
 Messaging initialized (initMessaging) More...
 

Detailed Description

Definition at line 27 of file ALFA_MDGap.h.

Constructor & Destructor Documentation

◆ ALFA_MDGap()

ALFA_MDGap::ALFA_MDGap ( )

Definition at line 7 of file ALFA_MDGap.cxx.

7  :
8  AthMessaging("ALFA_MDGap")
9 {
10  memset(&m_faMD, 0, sizeof(m_faMD));
11  memset(&m_fbMD, 0, sizeof(m_fbMD));
12  memset(&m_fRecXPos, 0, sizeof(m_fRecXPos));
13  memset(&m_fRecYPos, 0, sizeof(m_fRecYPos));
14  memset(&m_fOvU, 0, sizeof(m_fOvU));
15  memset(&m_fOvV, 0, sizeof(m_fOvV));
16  memset(&m_iNU, 0, sizeof(m_iNU));
17  memset(&m_iNV, 0, sizeof(m_iNV));
18  memset(&m_iFibSel, 0, sizeof(m_iFibSel));
19  memset(&m_iNumHitsLayer, 0, sizeof(m_iNumHitsLayer));
20 
21  m_fOverlapCut = 0.0;
22  m_iRPot = 0;
23  m_iUVCut = 0;
24 }

◆ ~ALFA_MDGap()

ALFA_MDGap::~ALFA_MDGap ( )

Definition at line 26 of file ALFA_MDGap.cxx.

27 {
28 }

Member Function Documentation

◆ Active_Gap()

Int_t ALFA_MDGap::Active_Gap ( Int_t  iFiberSide,
Int_t(&)  Over[72000],
Float_t  b_ref,
Float_t  b_rec,
const Int_t  FSel[ALFAPLATESCNT],
Float_t  OverLap,
Int_t  iSideFlag 
)
private

Definition at line 597 of file ALFA_MDGap.cxx.

598 {
599  Float_t fSign;
600  Float_t fXInter, fYInter;
601  Float_t fFibCen, fFibCen0, fFibCen1;
602 
603  Float_t b_center, gap_size;
604  Int_t Gap_Width;
605 
606  Int_t Found_Gap=0;
607 
608  if (m_faMD[m_iRPot][iSideFlag][0]>0) fSign=1.0;
609  else fSign=-1.0;
610 
611  Bool_t bHit[2];
612  Int_t shift;
613 
614  std::list<int>::iterator iHit;
615  int iIndex = 0;
616  for(UInt_t iLayer=0; iLayer<ALFAPLATESCNT; iLayer++)
617  {
618  iIndex = 2*iLayer+iFiberSide;
619  if (FSel[iLayer]!=9999)
620  {
621  bHit[0]=false;
622  bHit[1]=false;
623 
624  for (iHit=m_MapLayers[iIndex].ListFibers.begin(); iHit!=m_MapLayers[iIndex].ListFibers.end(); ++iHit)
625  {
626  if (*iHit==FSel[iLayer]+1) bHit[0]=true;
627  if (*iHit==FSel[iLayer]-1) bHit[1]=true;
628  }
629 
630  for (UInt_t j=0;j<2;j++)
631  {
632  if (j==0) shift=1;
633  else shift=-1;
634 
635  if(bHit[j])
636  {
637  fXInter= fSign*(b_ref-m_fbMD[m_iRPot][iLayer*2+iSideFlag][FSel[iLayer]])/(1+fSign*m_faMD[m_iRPot][iLayer*2+iSideFlag][FSel[iLayer]]);
638  fYInter= (fSign*m_faMD[m_iRPot][iLayer*2+iSideFlag][FSel[iLayer]]*b_ref+m_fbMD[m_iRPot][iLayer*2+iSideFlag][FSel[iLayer]])/(1+fSign*m_faMD[m_iRPot][iLayer*2+iSideFlag][FSel[iLayer]])-b_ref;
639  fFibCen0 = (fYInter-fSign*fXInter)/sqrt(2.);
640 
641  fXInter= fSign*(b_ref-m_fbMD[m_iRPot][iLayer*2+iSideFlag][FSel[iLayer]+shift])/(1+fSign*m_faMD[m_iRPot][iLayer*2+iSideFlag][FSel[iLayer]+shift]);
642  fYInter= (fSign*m_faMD[m_iRPot][iLayer*2+iSideFlag][FSel[iLayer]+shift]*b_ref+m_fbMD[m_iRPot][iLayer*2+iSideFlag][FSel[iLayer]+shift])/(1+fSign*m_faMD[m_iRPot][iLayer*2+iSideFlag][FSel[iLayer]+shift])-b_ref;
643  fFibCen1 = (fYInter-fSign*fXInter)/sqrt(2.);
644 
645  b_center = (fFibCen1+fFibCen0)/2.;
646 
647  fXInter= fSign*(b_ref-b_rec)/2.;
648  fYInter= (b_ref+b_rec)/2.-b_ref;
649  fFibCen = (fYInter-fSign*fXInter)/sqrt(2.);
650 
651  gap_size = TMath::Abs(fFibCen1-fFibCen0)-0.480;
652  Gap_Width = int(gap_size*1000.);
653 
654  if (((b_center+gap_size/2.)<fFibCen+OverLap/2. && (b_center+gap_size/2.)> fFibCen-OverLap/2.) || ((b_center-gap_size/2.)>fFibCen-OverLap/2. && (b_center-gap_size/2.)<fFibCen+OverLap/2.))
655  {
656  Found_Gap++;
657 
658  for (Int_t bin=0;bin<Gap_Width;bin++)
659  {
660  Over[(Int_t)((b_center-gap_size/2.)*1000)+bin+36000]++;
661  }
662  }
663  }
664  }
665  }
666  }
667 
668  return Found_Gap;
669 }

◆ Execute()

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

Definition at line 64 of file ALFA_MDGap.cxx.

65 {
66  ATH_MSG_DEBUG("ALFA_MDGap::Execute()");
67 
68  FIBERS structFibers;
69  m_MapLayers.clear();
70 
71  std::list<MDHIT>::const_iterator iter;
72  for (iter=ListMDHits.begin(); iter!=ListMDHits.end(); ++iter)
73  {
74  if (m_iRPot == (*iter).iRPot)
75  {
76  if(m_MapLayers.find((*iter).iPlate)==m_MapLayers.end())
77  {
78  structFibers.ListFibers.clear();
79  m_MapLayers.insert(std::pair<int, FIBERS>((*iter).iPlate, structFibers));
80  m_MapLayers[(*iter).iPlate].ListFibers.push_back((*iter).iFiber);
81  }
82  else m_MapLayers[(*iter).iPlate].ListFibers.push_back((*iter).iFiber);
83  }
84  }
85 
86  // RECONSTRUCTION
87  std::vector<Float_t> b_p, b_n;
88  std::vector<Float_t> Ov_p, Ov_n;
89  std::vector<int> Num_p, Num_n;
90  Int_t FSel_n[ALFAPLATESCNT], FSel_p[ALFAPLATESCNT];
91  Bool_t FGaps_n[ALFAPLATESCNT], FGaps_p[ALFAPLATESCNT];
92  Int_t Gap_Fib_p[ALFAPLATESCNT][2], Gap_Fib_n[ALFAPLATESCNT][2];
93  std::vector<Int_t> GapsID;
94 
95  Int_t Gaps[2][2];
96 // Int_t Gaps_ID[MAXTRACKNUM];
97 // Bool_t FGaps[20];
98 // Int_t GapFib[20][2];
99 
100  Reco_Track(b_p, b_n, Ov_p, Ov_n, Num_p, Num_n, FSel_n, FSel_p, Gaps, GapsID, FGaps_p, FGaps_n, Gap_Fib_p, Gap_Fib_n);
101 
102  Int_t cnt_tr=0;
103  for (UInt_t i=0;i< b_p.size();i++)
104  {
105  m_fRecXPos[cnt_tr]=(b_p[i]-b_n[i])/2.;
106  m_fRecYPos[cnt_tr]=(b_n[i]+b_p[i])/2.;
107 
108  m_fOvU[cnt_tr]= Ov_p[i];
109  m_fOvV[cnt_tr]= Ov_n[i];
110 
111  m_iNU[cnt_tr]= Num_p[i];
112  m_iNV[cnt_tr]= Num_n[i];
113 
114 // Gaps_ID[cnt_tr]=GapsID[i];
115 
116  if(cnt_tr==0)
117  {
118  for (Int_t j=0; j<ALFAPLATESCNT; j++)
119  {
120  m_iFibSel[j*2] = FSel_p[j];
121  m_iFibSel[j*2+1] = FSel_n[j];
122  }
123  }
124 
125 // if (GapsID[i]==1)
126 // {
127 // for (Int_t j=0; j<ALFAPLATESCNT; j++)
128 // {
129 // FGaps[j*2]=FGaps_p[j];
130 // FGaps[j*2+1]=FGaps_n[j];
131 
132 // GapFib[j*2][0]=Gap_Fib_p[j][0];
133 // GapFib[j*2][1]=Gap_Fib_p[j][1];
134 // GapFib[j*2+1][0]=Gap_Fib_n[j][0];
135 // GapFib[j*2+1][1]=Gap_Fib_n[j][1];
136 // }
137 // }
138  cnt_tr++;
139  }
140 
141  return StatusCode::SUCCESS;
142 }

◆ Finalize()

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

Definition at line 144 of file ALFA_MDGap.cxx.

145 {
146  for (Int_t i=0; i<MAXTRACKNUM; i++)
147  {
148  fRecXPos[i] = m_fRecXPos[i];
149  fRecYPos[i] = m_fRecYPos[i];
150  }
151 
152  return StatusCode::SUCCESS;
153 }

◆ Find_Proj()

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

Definition at line 199 of file ALFA_MDGap.cxx.

200 {
201  std::vector<int> iSizePlateau;
202  Int_t iNumFib=0;
203  Int_t p_tmp_min;
204 // Int_t p_tmp_max;
205  Float_t p_min;
206  Float_t p_max;
207 
208  //Determine the maximum number of overlapping fibers in both directions
209  for (Int_t i=0;i<72000;i++)
210  {
211  if (iOver[i]>iNumFib) iNumFib=iOver[i];
212  }
213 
214  // Filling array for all values equal to the maximum
215  if (iNumFib>=m_iUVCut)
216  {
217  for (Int_t i=0;i<72000;i++)
218  {
219  if (iOver[i]==iNumFib)
220  {
221  iSizePlateau.push_back(i);
222  }
223  }
224 
225 // Finding first and last position where the maximum is found
226  p_min = -36.0 + Float_t(iSizePlateau.front())*1e-3;
227  p_tmp_min = iSizePlateau.front();
228 
229  p_max = -36.0 + Float_t(iSizePlateau.back())*1e-3;
230 // p_tmp_max = iSizePlateau.back();
231 
232 // Making sure that the plateau belongs to the same track
233  Int_t full_width = iSizePlateau.size();
234 
235  for (Int_t i=0; i<full_width; i++)
236  {
237  if (iSizePlateau[full_width-i-1]-p_tmp_min < 500)
238  {
239 // p_tmp_max = iSizePlateau[full_width-i-1];
240  p_max = -36.0 + Float_t(iSizePlateau[full_width-i-1])*1e-3;
241  break;
242  }
243  }
244 
245  if ((p_max-p_min)<m_fOverlapCut)
246  {
247 // Storing the coordinate of the maximum
248  fb = fbRef+(p_min+p_max)/sqrt(2.0);
249  fOv = p_max-p_min;
250 // iNum = iNumFib;
251  }
252  }
253 
254  iNum = iNumFib;
255 }

◆ Finding_Fib()

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

Definition at line 263 of file ALFA_MDGap.cxx.

264 {
265  Float_t b_pos, b_neg;
266  Float_t x, y, x_tmp, y_tmp;
267  Float_t min_dist;
268  Float_t dist_x, dist_y;
269  Float_t dist_full;
270  Float_t fib_dist;
271  Int_t gFib;
272 
273  if (iSideFlag==0)
274  {
275  b_neg= fbRef;
276  b_pos= fbRec;
277  }
278  else
279  {
280  b_neg= fbRec;
281  b_pos= fbRef;
282  }
283 
284  x= (b_pos-b_neg)/2.0;
285  y= (b_neg+b_pos)/2.0;
286 
287  for (int & iLayer : iFSel) iLayer = 9999;
288 
289  //For each layer, we determine the hit fiber which is closest to the track
290  std::list<int>::iterator intIter;
291  int iIndex = 0;
292  for (Int_t iLayer = 0; iLayer<ALFAPLATESCNT; iLayer++)
293  {
294  min_dist=0.24;
295  gFib = 9999;
296 
297  iIndex = 2*iLayer+iFiberSide;
298  for (intIter=m_MapLayers[iIndex].ListFibers.begin(); intIter!=m_MapLayers[iIndex].ListFibers.end(); ++intIter)
299  {
300  if (*intIter!=9999)
301  {
302  x_tmp = (y-m_fbMD[m_iRPot][iLayer*2+iSideFlag][*intIter])/m_faMD[m_iRPot][iLayer*2+iSideFlag][*intIter];
303  y_tmp = m_faMD[m_iRPot][iLayer*2+iSideFlag][*intIter]*x+m_fbMD[m_iRPot][iLayer*2+iSideFlag][*intIter];
304 
305  dist_x = TMath::Abs(x-x_tmp);
306  dist_y = TMath::Abs(y-y_tmp);
307 
308  dist_full = sqrt(dist_x*dist_x+dist_y*dist_y);
309  fib_dist = sqrt(TMath::Power((dist_x+dist_y)/2.0,2)-TMath::Power(dist_full/2.0,2));
310 
311  if (fib_dist <= min_dist)
312  {
313  min_dist = fib_dist;
314  gFib = *intIter;
315 
316  iFSel[iLayer] = gFib;
317  }
318  }
319  }
320  }
321 }

◆ GetData()

void ALFA_MDGap::GetData ( Int_t(&)  iNumU[MAXTRACKNUM],
Int_t(&)  iNumV[MAXTRACKNUM],
Float_t(&)  fOvU[MAXTRACKNUM],
Float_t(&)  fOvV[MAXTRACKNUM],
Int_t(&)  iFibSel[ALFALAYERSCNT *ALFAPLATESCNT] 
)

Definition at line 520 of file ALFA_MDGap.cxx.

521 {
522  for (Int_t iTrack=0; iTrack<MAXTRACKNUM; iTrack++)
523  {
524  iNumU[iTrack] = m_iNU[iTrack];
525  iNumV[iTrack] = m_iNV[iTrack];
526  fOvU[iTrack] = m_fOvU[iTrack];
527  fOvV[iTrack] = m_fOvV[iTrack];
528 
529  for (Int_t iLayer=0; iLayer<ALFALAYERSCNT*ALFAPLATESCNT; iLayer++)
530  {
531  iFibSel[iLayer] = m_iFibSel[iLayer];
532  }
533  }
534 }

◆ Initialize()

StatusCode ALFA_MDGap::Initialize ( Int_t  iRPot,
Float_t  faMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT],
Float_t  fbMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT],
Int_t  iUVCut,
Float_t  fOverlapCut 
)

Definition at line 30 of file ALFA_MDGap.cxx.

31 {
32  m_iRPot = iRPot;
33  m_iUVCut = iUVCut;
34  m_fOverlapCut = fOverlapCut;
35 
36  for (Int_t iPot=0; iPot<RPOTSCNT; iPot++)
37  {
38  for (Int_t iLayer=0; iLayer<ALFALAYERSCNT*ALFAPLATESCNT; iLayer++)
39  {
40  for (Int_t iFiber=0; iFiber<ALFAFIBERSCNT; iFiber++)
41  {
42  m_faMD[iPot][iLayer][iFiber] = faMD[iPot][iLayer][iFiber];
43  m_fbMD[iPot][iLayer][iFiber] = fbMD[iPot][iLayer][iFiber];
44  }
45  }
46  }
47 
48  memset(&m_fRecXPos, 0, sizeof(m_fRecXPos));
49  memset(&m_fRecYPos, 0, sizeof(m_fRecYPos));
50  memset(&m_fOvU, 0, sizeof(m_fOvU));
51  memset(&m_fOvV, 0, sizeof(m_fOvV));
52  memset(&m_iNU, 0, sizeof(m_iNU));
53  memset(&m_iNV, 0, sizeof(m_iNV));
54  memset(&m_iFibSel, 0, sizeof(m_iFibSel));
55  std::fill_n(&m_fRecXPos[0], sizeof(m_fRecXPos)/sizeof(Float_t), -9999.0);
56  std::fill_n(&m_fRecYPos[0], sizeof(m_fRecYPos)/sizeof(Float_t), -9999.0);
57  std::fill_n(&m_fOvU[0], sizeof(m_fOvU)/sizeof(Float_t), -9999.0);
58  std::fill_n(&m_fOvV[0], sizeof(m_fOvV)/sizeof(Float_t), -9999.0);
59  std::fill_n(&m_iFibSel[0], sizeof(m_iFibSel)/sizeof(Int_t), 9999);
60 
61  return StatusCode::SUCCESS;
62 }

◆ 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  m_lvl = m_imsg ?
43  static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
44  MSG::INFO;
45 }

◆ 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 164 of file AthMessaging.h.

165 {
166  MsgStream* ms = m_msg_tls.get();
167  if (!ms) {
168  if (!m_initialized.test_and_set()) initMessaging();
169  ms = new MsgStream(m_imsg,m_nm);
170  m_msg_tls.reset( ms );
171  }
172 
173  ms->setLevel (m_lvl);
174  return *ms;
175 }

◆ 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 179 of file AthMessaging.h.

180 { return msg() << lvl; }

◆ 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_initialized.test_and_set()) initMessaging();
154  if (m_lvl <= lvl) {
155  msg() << lvl;
156  return true;
157  } else {
158  return false;
159  }
160 }

◆ Proj_Store()

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

Definition at line 158 of file ALFA_MDGap.cxx.

159 {
160  Float_t fSign;
161  Float_t fXInter, fYInter;
162  Float_t fFibCen;
163 
164  if (m_faMD[m_iRPot][iSideFlag][0]>0) fSign=1.0;
165  else fSign=-1.0;
166 
167  for (int & iBin : iOver)
168  {
169  iBin=0;
170  }
171 
172  std::list<int>::iterator intIter;
173  int iIndex = 0;
174  for (Int_t iLayer=0; iLayer<ALFAPLATESCNT; iLayer++)
175  {
176  iIndex = 2*iLayer+iFiberSide;
177  for (intIter=m_MapLayers[iIndex].ListFibers.begin(); intIter!=m_MapLayers[iIndex].ListFibers.end(); ++intIter)
178  {
179  if (*intIter!=9999)
180  {
181  //Depending on layer orientation, computing the projection of the hit fiber
182  fXInter= fSign*(fbRef-m_fbMD[m_iRPot][iLayer*2+iSideFlag][*intIter])/(1+fSign*m_faMD[m_iRPot][iLayer*2+iSideFlag][*intIter]);
183  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;
184  fFibCen = (fYInter-fSign*fXInter)/sqrt(2.0);
185 
186  //Filling the table with the hit fiber
187  for (Int_t iBin=0; iBin<480; iBin++)
188  {
189  iOver[(int)((fFibCen-0.24)*1000)+iBin+36000]++;
190  }
191  }
192  }
193  }
194 }

◆ Reco_Track()

void ALFA_MDGap::Reco_Track ( std::vector< Float_t > &  b_p,
std::vector< Float_t > &  b_n,
std::vector< Float_t > &  Ov_p,
std::vector< Float_t > &  Ov_n,
std::vector< int > &  Num_p,
std::vector< int > &  Num_n,
Int_t(&)  FSel_n[ALFAPLATESCNT],
Int_t(&)  FSel_p[ALFAPLATESCNT],
Int_t(&)  Gaps[2][2],
std::vector< Int_t > &  GapsID,
Bool_t(&)  FGaps_p[ALFAPLATESCNT],
Bool_t(&)  FGaps_n[ALFAPLATESCNT],
Int_t(&)  Gap_Fib_p[ALFAPLATESCNT][2],
Int_t(&)  Gap_Fib_n[ALFAPLATESCNT][2] 
)
private

Definition at line 327 of file ALFA_MDGap.cxx.

333 {
334  Int_t Over_p[72000];
335  Int_t Over_n[72000];
336  Int_t Over_copy[72000];
337  Int_t NumU=5;
338  Int_t NumV=5;
339  Float_t b_ref_p = -127.0;
340  Float_t b_ref_n = -127.0;
341  Float_t OvU;
342  Float_t OvV;
343  Float_t b_pos;
344  Float_t b_neg;
345  Bool_t FG_p[ALFAPLATESCNT]; //asi k nicemu - vstup do silentgap
346  Bool_t FG_n[ALFAPLATESCNT]; //asi k nicemu - vstup do silentgap
347  Int_t G_F_p[ALFAPLATESCNT][2]; //asi k nicemu - vstup do silentgap
348  Int_t G_F_n[ALFAPLATESCNT][2]; //asi k nicemu - vstup do silentgap
349  Float_t b_pos_silent;
350  Float_t b_neg_silent;
351  Float_t b_pos_active;
352  Float_t b_neg_active;
353 
354  //clear
355  memset(&FSel_n, 0, sizeof(Int_t));
356  memset(&FSel_p, 0, sizeof(Int_t));
357  memset(&FGaps_n, false, sizeof(Bool_t));
358  memset(&FGaps_p, false, sizeof(Bool_t));
359  memset(&Gap_Fib_n, 0, sizeof(Int_t));
360  memset(&Gap_Fib_p, 0, sizeof(Int_t));
361  std::fill_n(&Gap_Fib_n[0][0], sizeof(Gap_Fib_n)/sizeof(Int_t), 9999);
362  std::fill_n(&Gap_Fib_p[0][0], sizeof(Gap_Fib_p)/sizeof(Int_t), 9999);
363 
364  b_n.clear();
365  b_p.clear();
366  Ov_n.clear();
367  Ov_p.clear();
368  Num_n.clear();
369  Num_p.clear();
370 
371  b_ref_n=-127.0;
372  b_ref_p=-127.0;
373 
374 // First projection step on U side
375 // -------------------------------
376 // filling the array for U side with reference value
377  Proj_Store(0, Over_p, b_ref_n, 0);
378 
379 // Find first maxium
380  Find_Proj(Over_p, b_ref_n, b_pos, OvU, NumU);
381 
382 // Then reconstruction all tracks possible using the second side
383  if (NumU>=m_iUVCut)
384  {
385  //First projection on V side
386  //-------------------------------
387  //filling the array for V side with reference value
388  Proj_Store(1, Over_n, b_ref_p, 1);
389  Find_Proj(Over_n, b_ref_p, b_neg, OvV, NumV);
390 
391  if (NumV>=m_iUVCut)
392  {
393  //Now make the second projection step
394  //-----------------------------------
395  //U side
396  Proj_Store(0, Over_p, b_neg, 0);
397  Find_Proj(Over_p, b_neg, b_pos, OvU, NumU);
398 
399  //V side
400  Proj_Store(1, Over_n, b_pos, 1);
401  Find_Proj(Over_n, b_pos, b_neg, OvV, NumV);
402 
403  //Third projection steps
404  //----------------------
405  //U side
406  Proj_Store(0, Over_p, b_neg, 0);
407  Find_Proj(Over_p, b_neg, b_pos, OvU, NumU);
408 
409  //V side
410  Proj_Store(1, Over_n, b_pos, 1);
411  Find_Proj(Over_n, b_pos, b_neg, OvV, NumV);
412 
413  //We store the information in the vector
414  b_p.push_back(b_pos);
415  Ov_p.push_back(OvU);
416  Num_p.push_back(NumU);
417 
418  b_n.push_back(b_neg);
419  Ov_n.push_back(OvV);
420  Num_n.push_back(NumV);
421 
422  GapsID.push_back(0);
423 
424  //Once done we want to remove the hit belonging to the first track on side V
425  //We first find the corresponding fibers
426  Finding_Fib(0,b_neg, b_pos, FSel_p, 0);
427  Finding_Fib(1,b_pos, b_neg, FSel_n, 1);
428 
429  //Then looking for silent gaps in the plateau
430  //Filling the array with the gap information
431 
432  for (Int_t bin=0;bin<72000;bin++)
433  {
434  Over_copy[bin]=Over_p[bin];
435  }
436  Gaps[0][0] = Silent_Gap(Over_copy, b_neg, b_pos, FSel_p, FGaps_p, Gap_Fib_p, OvU, (Int_t)0);
437  Find_Proj(Over_copy, b_neg, b_pos_silent, OvU, NumU);
438 
439  for (Int_t bin=0;bin<72000;bin++)
440  {
441  Over_copy[bin]=Over_n[bin];
442  }
443  Gaps[1][0] = Silent_Gap(Over_copy, b_pos, b_neg, FSel_n, FGaps_n, Gap_Fib_n, OvV, 1);
444  Find_Proj(Over_copy, b_pos, b_neg_silent, OvV, NumV);
445 
446  if (Gaps[0][0]>0 || Gaps[1][0]>0)
447  {
448  b_p.push_back(b_pos_silent);
449  Ov_p.push_back(OvU);
450  Num_p.push_back(NumU);
451 
452  b_n.push_back(b_neg_silent);
453  Ov_n.push_back(OvV);
454  Num_n.push_back(NumV);
455 
456  GapsID.push_back(1);
457  }
458 
459  //then looking for active gaps in the plateau
460  for (Int_t bin=0;bin<72000;bin++)
461  {
462  Over_copy[bin]=Over_p[bin];
463  }
464  Gaps[0][1] = Active_Gap(0,Over_copy, b_neg, b_pos, FSel_p, OvU, 0);
465  Find_Proj(Over_copy, b_neg, b_pos_active, OvU, NumU);
466 
467  for (Int_t bin=0;bin<72000;bin++)
468  {
469  Over_copy[bin]=Over_n[bin];
470  }
471  Gaps[1][1] = Active_Gap(1,Over_copy, b_pos, b_neg, FSel_n, OvV, 1);
472  Find_Proj(Over_copy, b_pos, b_neg_active, OvV, NumV);
473 
474  if (Gaps[0][1]>0 || Gaps[1][1]>0)
475  {
476  b_p.push_back(b_pos_active);
477  Ov_p.push_back(OvU);
478  Num_p.push_back(NumU);
479 
480  b_n.push_back(b_neg_active);
481  Ov_n.push_back(OvV);
482  Num_n.push_back(NumV);
483 
484  GapsID.push_back(2);
485  }
486 
487  //Then looking for both gaps in the plateau
488  if ((Gaps[0][0]>0 || Gaps[1][0]>0) && (Gaps[0][1]>0 || Gaps[1][1]>0))
489  {
490  for (Int_t bin=0;bin<72000;bin++)
491  {
492  Over_copy[bin]=Over_p[bin];
493  }
494  Silent_Gap(Over_copy, b_neg, b_pos, FSel_p, FG_p, G_F_p, OvU, 0);
495  Active_Gap(0,Over_copy, b_neg, b_pos, FSel_p, OvU, 0);
496  Find_Proj(Over_copy, b_neg, b_pos_active, OvU, NumU);
497 
498  for (Int_t bin=0;bin<72000;bin++)
499  {
500  Over_copy[bin]=Over_n[bin];
501  }
502  Silent_Gap(Over_copy, b_pos, b_neg, FSel_n, FG_n, G_F_n, OvV, 1);
503  Active_Gap(1,Over_copy, b_pos, b_neg, FSel_n, OvV, 1);
504  Find_Proj(Over_copy, b_pos, b_neg_active, OvV, NumV);
505 
506  b_p.push_back(b_pos_active);
507  Ov_p.push_back(OvU);
508  Num_p.push_back(NumU);
509 
510  b_n.push_back(b_neg_active);
511  Ov_n.push_back(OvV);
512  Num_n.push_back(NumV);
513 
514  GapsID.push_back(3);
515  }
516  }
517  }
518 }

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

◆ Silent_Gap()

Int_t ALFA_MDGap::Silent_Gap ( Int_t(&)  Over[72000],
Float_t  b_ref,
Float_t  b_rec,
const Int_t  FSel[ALFAPLATESCNT],
Bool_t(&)  FGap[ALFAPLATESCNT],
Int_t(&)  Gap_Fib[ALFAPLATESCNT][2],
Float_t  OverLap,
Int_t  iSideFlag 
)
private

Definition at line 537 of file ALFA_MDGap.cxx.

538 {
539  Float_t fSign;
540  Float_t fXInter, fYInter;
541  Float_t fFibCen, fFibCen0, fFibCen1;
542 
543  Float_t b_center, gap_size;
544  Int_t Gap_Width;
545 
546  Int_t Found_Gap=0;
547 
548  if (m_faMD[m_iRPot][iSideFlag][0]>0) fSign=1.0;
549  else fSign=-1.0;
550 
551  for(UInt_t iLayer=0; iLayer<ALFAPLATESCNT; iLayer++)
552  {
553  if (FSel[iLayer]==9999)
554  {
555  if (iSideFlag==0 || (iSideFlag==1 && iLayer!=4))
556  {
557  for (Int_t iFiber=0; iFiber<ALFAFIBERSCNT-1; iFiber++)
558  {
559  fXInter= fSign*(b_ref-m_fbMD[m_iRPot][iLayer*2+iSideFlag][iFiber])/(1+fSign*m_faMD[m_iRPot][iLayer*2+iSideFlag][iFiber]);
560  fYInter= (fSign*m_faMD[m_iRPot][iLayer*2+iSideFlag][iFiber]*b_ref+m_fbMD[m_iRPot][iLayer*2+iSideFlag][iFiber])/(1+fSign*m_faMD[m_iRPot][iLayer*2+iSideFlag][iFiber])-b_ref;
561  fFibCen0 = (fYInter-fSign*fXInter)/sqrt(2.);
562 
563  fXInter= fSign*(b_ref-m_fbMD[m_iRPot][iLayer*2+iSideFlag][iFiber+1])/(1+fSign*m_faMD[m_iRPot][iLayer*2+iSideFlag][iFiber+1]);
564  fYInter= (fSign*m_faMD[m_iRPot][iLayer*2+iSideFlag][iFiber+1]*b_ref+m_fbMD[m_iRPot][iLayer*2+iSideFlag][iFiber+1])/(1+fSign*m_faMD[m_iRPot][iLayer*2+iSideFlag][iFiber+1])-b_ref;
565  fFibCen1 = (fYInter-fSign*fXInter)/sqrt(2.);
566 
567  b_center = (fFibCen1+fFibCen0)/2.;
568 
569  fXInter= fSign*(b_ref-b_rec)/2.;
570  fYInter= (b_ref+b_rec)/2.-b_ref;
571  fFibCen = (fYInter-fSign*fXInter)/sqrt(2.);
572 
573  gap_size = TMath::Abs(fFibCen1-fFibCen0)-0.480;
574  Gap_Width = int(gap_size*1000.);
575 
576  if (((b_center+gap_size/2.)<fFibCen+OverLap/2. && (b_center+gap_size/2.)> fFibCen-OverLap/2.) || ((b_center-gap_size/2.)>fFibCen-OverLap/2. && (b_center-gap_size/2.)<fFibCen+OverLap/2.))
577  {
578  Found_Gap++;
579  FGap[iLayer]=true;
580 
581  Gap_Fib[iLayer][0] = iFiber;
582  Gap_Fib[iLayer][1] = iFiber+1;
583 
584  for (Int_t bin=0;bin<Gap_Width;bin++)
585  {
586  Over[(Int_t)((b_center-gap_size/2.)*1000)+bin+36000]++;
587  }
588  }
589  }
590  }
591  }
592  }
593 
594  return Found_Gap;
595 }

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_MDGap::m_faMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT]
private

Definition at line 39 of file ALFA_MDGap.h.

◆ m_fbMD

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

Definition at line 40 of file ALFA_MDGap.h.

◆ m_fOverlapCut

Float_t ALFA_MDGap::m_fOverlapCut
private

Definition at line 36 of file ALFA_MDGap.h.

◆ m_fOvU

Float_t ALFA_MDGap::m_fOvU[MAXTRACKNUM]
private

Definition at line 51 of file ALFA_MDGap.h.

◆ m_fOvV

Float_t ALFA_MDGap::m_fOvV[MAXTRACKNUM]
private

Definition at line 52 of file ALFA_MDGap.h.

◆ m_fRecXPos

Float_t ALFA_MDGap::m_fRecXPos[MAXTRACKNUM]
private

Definition at line 49 of file ALFA_MDGap.h.

◆ m_fRecYPos

Float_t ALFA_MDGap::m_fRecYPos[MAXTRACKNUM]
private

Definition at line 50 of file ALFA_MDGap.h.

◆ m_iFibSel

Int_t ALFA_MDGap::m_iFibSel[ALFALAYERSCNT *ALFAPLATESCNT]
private

Definition at line 47 of file ALFA_MDGap.h.

◆ m_imsg

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

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

◆ m_iNU

Int_t ALFA_MDGap::m_iNU[MAXTRACKNUM]
private

Definition at line 45 of file ALFA_MDGap.h.

◆ m_iNumHitsLayer

Int_t ALFA_MDGap::m_iNumHitsLayer[ALFALAYERSCNT *ALFAPLATESCNT]
private

Definition at line 43 of file ALFA_MDGap.h.

◆ m_iNV

Int_t ALFA_MDGap::m_iNV[MAXTRACKNUM]
private

Definition at line 46 of file ALFA_MDGap.h.

◆ m_iRPot

Int_t ALFA_MDGap::m_iRPot
private

Definition at line 34 of file ALFA_MDGap.h.

◆ m_iUVCut

Int_t ALFA_MDGap::m_iUVCut
private

Definition at line 35 of file ALFA_MDGap.h.

◆ m_lvl

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

Current logging level.

Definition at line 138 of file AthMessaging.h.

◆ m_MapLayers

std::map<Int_t, FIBERS> ALFA_MDGap::m_MapLayers
private

Definition at line 55 of file ALFA_MDGap.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:
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
MAXTRACKNUM
#define MAXTRACKNUM
Definition: ALFA_MDGap.h:25
AthMessaging::m_lvl
std::atomic< MSG::Level > m_lvl
Current logging level.
Definition: AthMessaging.h:138
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
ALFA_MDGap::m_fOvU
Float_t m_fOvU[MAXTRACKNUM]
Definition: ALFA_MDGap.h:51
ALFA_MDGap::m_fOverlapCut
Float_t m_fOverlapCut
Definition: ALFA_MDGap.h:36
ALFA_MDGap::Silent_Gap
Int_t Silent_Gap(Int_t(&Over)[72000], Float_t b_ref, Float_t b_rec, const Int_t FSel[ALFAPLATESCNT], Bool_t(&FGap)[ALFAPLATESCNT], Int_t(&Gap_Fib)[ALFAPLATESCNT][2], Float_t OverLap, Int_t iSideFlag)
Definition: ALFA_MDGap.cxx:537
ALFAFIBERSCNT
#define ALFAFIBERSCNT
Definition: ALFA_constants.h:10
ALFA_MDGap::m_fRecYPos
Float_t m_fRecYPos[MAXTRACKNUM]
Definition: ALFA_MDGap.h:50
_FIBERS
Definition: ALFA_LocRec/ALFA_UserObjects.h:30
bin
Definition: BinsDiffFromStripMedian.h:43
RPOTSCNT
#define RPOTSCNT
Definition: ALFA_CLinkAlg.h:26
ALFA_MDGap::Proj_Store
void Proj_Store(Int_t iFiberSide, Int_t(&iOver)[72000], Float_t fbRef, Int_t iSideFlag)
Definition: ALFA_MDGap.cxx:158
ALFA_MDGap::Active_Gap
Int_t Active_Gap(Int_t iFiberSide, Int_t(&Over)[72000], Float_t b_ref, Float_t b_rec, const Int_t FSel[ALFAPLATESCNT], Float_t OverLap, Int_t iSideFlag)
Definition: ALFA_MDGap.cxx:597
ALFA_MDGap::Reco_Track
void Reco_Track(std::vector< Float_t > &b_p, std::vector< Float_t > &b_n, std::vector< Float_t > &Ov_p, std::vector< Float_t > &Ov_n, std::vector< int > &Num_p, std::vector< int > &Num_n, Int_t(&FSel_n)[ALFAPLATESCNT], Int_t(&FSel_p)[ALFAPLATESCNT], Int_t(&Gaps)[2][2], std::vector< Int_t > &GapsID, Bool_t(&FGaps_p)[ALFAPLATESCNT], Bool_t(&FGaps_n)[ALFAPLATESCNT], Int_t(&Gap_Fib_p)[ALFAPLATESCNT][2], Int_t(&Gap_Fib_n)[ALFAPLATESCNT][2])
Definition: ALFA_MDGap.cxx:327
AthMessaging::m_imsg
std::atomic< IMessageSvc * > m_imsg
MessageSvc pointer.
Definition: AthMessaging.h:135
x
#define x
python.SystemOfUnits.ms
int ms
Definition: SystemOfUnits.py:132
ALFA_MDGap::m_fOvV
Float_t m_fOvV[MAXTRACKNUM]
Definition: ALFA_MDGap.h:52
Athena::getMessageSvc
IMessageSvc * getMessageSvc(bool quiet=false)
Definition: getMessageSvc.cxx:20
ALFA_MDGap::m_MapLayers
std::map< Int_t, FIBERS > m_MapLayers
Definition: ALFA_MDGap.h:55
AthMessaging::AthMessaging
AthMessaging()
Default constructor:
TrigConf::MSGTC::Level
Level
Definition: Trigger/TrigConfiguration/TrigConfBase/TrigConfBase/MsgStream.h:21
lumiFormat.i
int i
Definition: lumiFormat.py:85
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
ALFA_MDGap::m_iRPot
Int_t m_iRPot
Definition: ALFA_MDGap.h:34
python.LArMinBiasAlgConfig.int
int
Definition: LArMinBiasAlgConfig.py:59
ALFA_MDGap::m_faMD
Float_t m_faMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT]
Definition: ALFA_MDGap.h:39
ALFA_MDGap::m_iFibSel
Int_t m_iFibSel[ALFALAYERSCNT *ALFAPLATESCNT]
Definition: ALFA_MDGap.h:47
ALFA_MDGap::Finding_Fib
void Finding_Fib(Int_t iFiberSide, Float_t fbRef, Float_t fbRec, Int_t(&iFSel)[ALFAPLATESCNT], Int_t iSideFlag)
Definition: ALFA_MDGap.cxx:263
_FIBERS::ListFibers
std::list< int > ListFibers
Definition: ALFA_LocRec/ALFA_UserObjects.h:31
ALFALAYERSCNT
#define ALFALAYERSCNT
Definition: ALFA_constants.h:8
AthMessaging::msg
MsgStream & msg() const
The standard message stream.
Definition: AthMessaging.h:164
ALFA_MDGap::m_iNumHitsLayer
Int_t m_iNumHitsLayer[ALFALAYERSCNT *ALFAPLATESCNT]
Definition: ALFA_MDGap.h:43
ALFA_MDGap::m_iUVCut
Int_t m_iUVCut
Definition: ALFA_MDGap.h:35
ALFA_MDGap::m_iNV
Int_t m_iNV[MAXTRACKNUM]
Definition: ALFA_MDGap.h:46
plotBeamSpotVxVal.bin
int bin
Definition: plotBeamSpotVxVal.py:83
ALFA_MDGap::m_iNU
Int_t m_iNU[MAXTRACKNUM]
Definition: ALFA_MDGap.h:45
y
#define y
AthMessaging::m_nm
std::string m_nm
Message source name.
Definition: AthMessaging.h:129
ALFA_MDGap::m_fbMD
Float_t m_fbMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT]
Definition: ALFA_MDGap.h:40
ALFA_MDGap::m_fRecXPos
Float_t m_fRecXPos[MAXTRACKNUM]
Definition: ALFA_MDGap.h:49
AthMessaging::initMessaging
void initMessaging() const
Initialize our message level and MessageSvc.
Definition: AthMessaging.cxx:39
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
ALFA_MDGap::Find_Proj
void Find_Proj(const Int_t iOver[72000], Float_t fbRef, Float_t &fb, Float_t &fOv, Int_t &fNum) const
Definition: ALFA_MDGap.cxx:199
ALFAPLATESCNT
#define ALFAPLATESCNT
Definition: ALFA_constants.h:9
Generated on Thu Apr 10 2025 21:25:32 for ATLAS Offline Software by   doxygen 1.8.18