ATLAS Offline Software
ALFA_LocRec.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.h"
6 #include "ALFA_Geometry/ALFA_GeometryReader.h"
7 #include "ALFA_LocRec/ALFA_ODTracking.h"
8 #include "ALFA_LocRec/ALFA_MDTracking.h"
9 #include "ALFA_LocRec/ALFA_MDOverlap.h"
10 #include "ALFA_LocRec/ALFA_CenterGravity.h"
11 #include "ALFA_LocRec/ALFA_MDMultiple.h"
12 #include "ALFA_LocRec/ALFA_HalfReco.h"
13 #include "ALFA_LocRec/ALFA_MDGap.h"
14 #include "ALFA_LocRec/ALFA_EdgeMethod.h"
15 #include "ALFA_LocRecEv/ALFA_LocRecEvCollection.h"
16 #include "ALFA_LocRecEv/ALFA_LocRecODEvCollection.h"
17 #include "ALFA_RawEv/ALFA_DigitCollection.h"
18 #include "ALFA_RawEv/ALFA_ODDigitCollection.h"
19 
20 
21 #include "AthenaKernel/errorcheck.h"
22 using namespace std;
23 
24 ALFA_LocRec::ALFA_LocRec(const std::string& name, ISvcLocator* pSvcLocator) :
25  AthAlgorithm(name, pSvcLocator)
26 {
27  ATH_MSG_DEBUG("begin ALFA_LocRec::ALFA_LocRec");
28 
29  m_pGeometryReader = new ALFA_GeometryReader();
30 
31 // m_Config.eOwner=EOT_RECO;
32  m_Config.clear();
33 
34  //begin of Geometry properties
35  declareProperty("MetrologyType",m_Config.eRPMetrologyGeoType=EMT_NOMINAL);//EGST_FILE
36  declareProperty("MetrologySource",m_Config.strRPMetrologyConnString=std::string(""));//"rpmetrology.dat"
37  declareProperty("ShiftToX97Pos",m_Config.bShiftToX97Pos=false);
38 
39  declareProperty("B7L1U_PosType",m_Config.CfgRPosParams[0].eRPPosType=ERPPT_ACTIVE);
40  declareProperty("B7L1U_MDGeometryType",m_Config.CfgRPosParams[0].eMDGeoType=EGST_IDEALGEOMETRY);
41  declareProperty("B7L1U_ODGeometryType",m_Config.CfgRPosParams[0].eODGeoType=EGST_IDEALGEOMETRY);
42  declareProperty("B7L1U_MDSource",m_Config.CfgRPosParams[0].strMDConnString=std::string(""));
43  declareProperty("B7L1U_ODSource",m_Config.CfgRPosParams[0].strODConnString=std::string(""));
44 // declareProperty("B7L1U_CurrentLVDT",m_Config.CfgRPosParams[0].fCurrentLVDTmm=7.0*CLHEP::mm);
45 
46  declareProperty("B7L1L_PosType",m_Config.CfgRPosParams[1].eRPPosType=ERPPT_ACTIVE);
47  declareProperty("B7L1L_MDGeometryType",m_Config.CfgRPosParams[1].eMDGeoType=EGST_IDEALGEOMETRY);
48  declareProperty("B7L1L_ODGeometryType",m_Config.CfgRPosParams[1].eODGeoType=EGST_IDEALGEOMETRY);
49  declareProperty("B7L1L_MDSource",m_Config.CfgRPosParams[1].strMDConnString=std::string(""));
50  declareProperty("B7L1L_ODSource",m_Config.CfgRPosParams[1].strODConnString=std::string(""));
51 // declareProperty("B7L1L_CurrentLVDT",m_Config.CfgRPosParams[1].fCurrentLVDTmm=7.0*CLHEP::mm);
52 
53  declareProperty("A7L1U_PosType",m_Config.CfgRPosParams[2].eRPPosType=ERPPT_ACTIVE);
54  declareProperty("A7L1U_MDGeometryType",m_Config.CfgRPosParams[2].eMDGeoType=EGST_IDEALGEOMETRY);
55  declareProperty("A7L1U_ODGeometryType",m_Config.CfgRPosParams[2].eODGeoType=EGST_IDEALGEOMETRY);
56  declareProperty("A7L1U_MDSource",m_Config.CfgRPosParams[2].strMDConnString=std::string(""));
57  declareProperty("A7L1U_ODSource",m_Config.CfgRPosParams[2].strODConnString=std::string(""));
58 // declareProperty("A7L1U_CurrentLVDT",m_Config.CfgRPosParams[2].fCurrentLVDTmm=7.0*CLHEP::mm);
59 
60  declareProperty("A7L1L_PosType",m_Config.CfgRPosParams[3].eRPPosType=ERPPT_ACTIVE);
61  declareProperty("A7L1L_MDGeometryType",m_Config.CfgRPosParams[3].eMDGeoType=EGST_IDEALGEOMETRY);
62  declareProperty("A7L1L_ODGeometryType",m_Config.CfgRPosParams[3].eODGeoType=EGST_IDEALGEOMETRY);
63  declareProperty("A7L1L_MDSource",m_Config.CfgRPosParams[3].strMDConnString=std::string(""));
64  declareProperty("A7L1L_ODSource",m_Config.CfgRPosParams[3].strODConnString=std::string(""));
65 // declareProperty("A7L1L_CurrentLVDT",m_Config.CfgRPosParams[3].fCurrentLVDTmm=7.0*CLHEP::mm);
66 
67  declareProperty("A7R1U_PosType",m_Config.CfgRPosParams[4].eRPPosType=ERPPT_ACTIVE);
68  declareProperty("A7R1U_MDGeometryType",m_Config.CfgRPosParams[4].eMDGeoType=EGST_IDEALGEOMETRY);
69  declareProperty("A7R1U_ODGeometryType",m_Config.CfgRPosParams[4].eODGeoType=EGST_IDEALGEOMETRY);
70  declareProperty("A7R1U_MDSource",m_Config.CfgRPosParams[4].strMDConnString=std::string(""));
71  declareProperty("A7R1U_ODSource",m_Config.CfgRPosParams[4].strODConnString=std::string(""));
72 // declareProperty("A7R1U_CurrentLVDT",m_Config.CfgRPosParams[4].fCurrentLVDTmm=7.0*CLHEP::mm);
73 
74  declareProperty("A7R1L_PosType",m_Config.CfgRPosParams[5].eRPPosType=ERPPT_ACTIVE);
75  declareProperty("A7R1L_MDGeometryType",m_Config.CfgRPosParams[5].eMDGeoType=EGST_IDEALGEOMETRY);
76  declareProperty("A7R1L_ODGeometryType",m_Config.CfgRPosParams[5].eODGeoType=EGST_IDEALGEOMETRY);
77  declareProperty("A7R1L_MDSource",m_Config.CfgRPosParams[5].strMDConnString=std::string(""));
78  declareProperty("A7R1L_ODSource",m_Config.CfgRPosParams[5].strODConnString=std::string(""));
79 // declareProperty("A7L1U_CurrentLVDT",m_Config.CfgRPosParams[5].fCurrentLVDTmm=7.0*CLHEP::mm);
80 
81  declareProperty("B7R1U_PosType",m_Config.CfgRPosParams[6].eRPPosType=ERPPT_ACTIVE);
82  declareProperty("B7R1U_MDGeometryType",m_Config.CfgRPosParams[6].eMDGeoType=EGST_IDEALGEOMETRY);
83  declareProperty("B7R1U_ODGeometryType",m_Config.CfgRPosParams[6].eODGeoType=EGST_IDEALGEOMETRY);
84  declareProperty("B7R1U_MDSource",m_Config.CfgRPosParams[6].strMDConnString=std::string(""));
85  declareProperty("B7R1U_ODSource",m_Config.CfgRPosParams[6].strODConnString=std::string(""));
86 // declareProperty("B7R1U_CurrentLVDT",m_Config.CfgRPosParams[6].fCurrentLVDTmm=7.0*CLHEP::mm);
87 
88  declareProperty("B7R1L_PosType",m_Config.CfgRPosParams[7].eRPPosType=ERPPT_ACTIVE);
89  declareProperty("B7R1L_MDGeometryType",m_Config.CfgRPosParams[7].eMDGeoType=EGST_IDEALGEOMETRY);
90  declareProperty("B7R1L_ODGeometryType",m_Config.CfgRPosParams[7].eODGeoType=EGST_IDEALGEOMETRY);
91  declareProperty("B7R1L_MDSource",m_Config.CfgRPosParams[7].strMDConnString=std::string(""));
92  declareProperty("B7R1L_ODSource",m_Config.CfgRPosParams[7].strODConnString=std::string(""));
93 // declareProperty("B7R1L_CurrentLVDT",m_Config.CfgRPosParams[7].fCurrentLVDTmm=7.0*CLHEP::mm);
94  //end of Geometry properties
95 
96  // data type using in the local reconstruction
97  // for the simulation data the value is 0, for the real data the value is 1. Unset value is -1
98  declareProperty("DataType", m_iDataType=1, "data type using in the local reconstruction");
99 
100  //reconstruction methods properties - MDTracking, MDMultiple, ODTracking
101  declareProperty("MultiplicityCutOD", m_iMultiplicityCutOD=30);
102  declareProperty("DistanceCutOD", m_fDistanceCutOD=0.5);
103  declareProperty("LayerCutOD", m_iLayerCutOD=3);
104 
105  declareProperty("OverlapCutMD", m_fOverlapCutMD=0.5);
106  declareProperty("MultiplicityCutMD", m_iMultiplicityCutMD=5);
107  declareProperty("NumLayerCutMD", m_iNumLayerCutMD=3);
108  declareProperty("UVCutMD", m_iUVCutMD=3);
109  declareProperty("UVCutMDHalfReco", m_iUVCutMDHalfReco=3);
110 
111  //reconstruction methods properties - EdgeMethod
112  declareProperty("EdgeMethod_Opt_Sisters", m_bEdgeMethod_Opt_Sisters = false);
113  declareProperty("EdgeMethod_Opt_UseGaps", m_bEdgeMethod_Opt_UseGaps = false);
114 
115  //reconstruction method selection for OD & MD
116  declareProperty("AlgoOD", m_strAlgoOD="ODTracking");
117  declareProperty("AlgoMD", m_strAlgoMD="MDTracking");
118 
119  m_vecListAlgoMD.clear();
120  declareProperty("ListAlgoMD", m_vecListAlgoMD);
121  m_vecListAlgoOD.clear();
122  declareProperty("ListAlgoOD", m_vecListAlgoOD);
123 
124  m_ListExistingRPots.clear();
125 
126  m_strKeyGeometryForReco = "ALFA_GeometryForReco";
127  m_strCollectionName = "ALFA_DigitCollection";
128  m_strODCollectionName = "ALFA_ODDigitCollection";
129  m_strKeyLocRecEvCollection = "ALFA_LocRecEvCollection";
130  m_strKeyLocRecODEvCollection = "ALFA_LocRecODEvCollection";
131 
132  m_pLocRecEvCollection = NULL;
133  m_pLocRecEvent = NULL;
134  m_pLocRecODEvCollection = NULL;
135  m_pLocRecODEvent = NULL;
136 
137  m_eventNum = 0;
138  m_iEvent = 0;
139 
140  ATH_MSG_DEBUG("end ALFA_LocRec::ALFA_LocRec");
141 }
142 
143 ALFA_LocRec::~ALFA_LocRec()
144 {
145  ATH_MSG_DEBUG("begin ALFA_LocRec::~ALFA_LocRec");
146 
147 // if(m_pGeometryReader!=NULL)
148 // {
149 // delete m_pGeometryReader;
150 // m_pGeometryReader = NULL;
151 // }
152 
153  ATH_MSG_DEBUG("begin ALFA_LocRec::~ALFA_LocRec");
154 }
155 
156 StatusCode ALFA_LocRec::initialize()
157 {
158  ATH_MSG_DEBUG("begin ALFA_LocRec::initialize()");
159 
160  StatusCode sc;
161  ClearGeometry();
162 
163 // sc = service("StoreGateSvc",m_storeGate);
164 // if(sc.isFailure())
165 // {
166 // ATH_MSG_ERROR("reconstruction: unable to retrieve pointer to StoreGateSvc");
167 // return sc;
168 // }
169 
170  //read geometry
171  if(ReadGeometryDetCS())
172  {
173  ATH_MSG_DEBUG("Geometry loaded successfully");
174  }
175  else
176  {
177  ATH_MSG_FATAL("Could not load geometry");
178  return StatusCode::FAILURE;
179  }
180 
181  //write ALFA_GeometryReader to StoreGate
182 // if (StatusCode::SUCCESS!=service("DetectorStore",m_pDetStore))
183 // {
184 // ATH_MSG_ERROR("Detector store not found");
185 // return StatusCode::FAILURE;
186 // }
187  sc = detStore()->record(m_pGeometryReader, m_strKeyGeometryForReco);
188  if(sc.isFailure())
189  {
190  ATH_MSG_ERROR("m_pGeometryReader: unable to record to StoreGate");
191  return sc;
192  }
193 
194 // if (!detStore()->contains<ALFA_GeometryReader>(m_strKeyGeometryForReco))
195 // {
196 // ATH_MSG_ERROR("m_pGeometryReader is not in StoreGate");
197 // }
198 // else
199 // {
200 // ATH_MSG_DEBUG("m_pGeometryReader is in StoreGate");
201 // }
202 
203  ATH_CHECK(m_eventInfoKey.initialize());
204 
205  m_iEvent = 0;
206 
207  ATH_MSG_DEBUG("end ALFA_LocRec::initialize()");
208  return StatusCode::SUCCESS;
209 }
210 
211 StatusCode ALFA_LocRec::execute()
212 {
213  ATH_MSG_DEBUG("begin ALFA_LocRec::execute()");
214 
215  StatusCode sc;
216  std::list<eRPotName>::const_iterator iterRPName;
217  eRPotName eRPName;
218 
219  std::list<MDHIT> ListMDHits;
220  std::list<ODHIT> ListODHits;
221  ListMDHits.clear();
222  ListODHits.clear();
223 
224  m_eventNum = 0;
225  SG::ReadHandle<xAOD::EventInfo> eventInfo (m_eventInfoKey,getContext());
226  if(!eventInfo.isValid()) {
227  ATH_MSG_ERROR("ALFA_LocRec, Cannot get event info.");
228 // return sc;
229  }
230  else
231  {
232  // current event number
233  m_eventNum = eventInfo->eventNumber();
234  }
235 
236  //************************************************************
237 // if (m_eventNum!=73681035) return StatusCode::SUCCESS;
238  //************************************************************
239 
240  sc = RecordCollection();
241  if (sc.isFailure())
242  {
243  ATH_MSG_ERROR("RecordCollection() failed");
244  return StatusCode::SUCCESS;
245  }
246 
247  sc = RecordODCollection();
248  if (sc.isFailure())
249  {
250  ATH_MSG_ERROR("RecordODCollection() failed");
251  return StatusCode::SUCCESS;
252  }
253 
254  sc = ALFACollectionReading(ListMDHits, ListODHits);
255  if (sc.isFailure())
256  {
257  ATH_MSG_WARNING("ALFA_Collection_Reading Failed");
258 // return StatusCode::SUCCESS;
259  }
260  else
261  {
262  std::string strAlgoMD;
263  for(auto & i : m_vecListAlgoMD)
264  {
265  strAlgoMD = i;
266  for(iterRPName=m_ListExistingRPots.begin();iterRPName!=m_ListExistingRPots.end();++iterRPName)
267  {
268  eRPName = *iterRPName;
269 
270 // cout << "eRPName = " << eRPName << endl;
271  //execute MD algorithm
272  sc = ExecuteRecoMethod(strAlgoMD, eRPName, ListMDHits, ListODHits);
273  if (sc.isFailure())
274  {
275  ATH_MSG_FATAL("Algorithm " << strAlgoMD << " for the pot " << m_pGeometryReader->GetRPotLabel(eRPName) << " failure!");
276  return sc;
277  }
278  }
279  }
280 
281  std::string strAlgoOD;
282  for(auto & i : m_vecListAlgoOD)
283  {
284  strAlgoOD = i;
285  for(iterRPName=m_ListExistingRPots.begin();iterRPName!=m_ListExistingRPots.end();++iterRPName)
286  {
287  eRPName = *iterRPName;
288 
289  // cout << "eRPName = " << eRPName << endl;
290  //execute OD algorithm
291  sc = ExecuteRecoMethod(strAlgoOD, eRPName, ListMDHits, ListODHits);
292  if (sc.isFailure())
293  {
294  ATH_MSG_FATAL("Algorithm " << strAlgoOD << " for the pot " << m_pGeometryReader->GetRPotLabel(eRPName) << " failure!");
295  return sc;
296  }
297  }
298  }
299 
300 
301 
302 
303 // // local reconstruction process for all existing pots, MD & OD
304 // for(iterRPName=m_ListExistingRPots.begin();iterRPName!=m_ListExistingRPots.end();iterRPName++)
305 // {
306 // eRPName = *iterRPName;
307 
308 // //execute MD reconstruction method
309 // if (!m_strAlgoMD.empty())
310 // {
311 // sc = ExecuteRecoMethod(m_strAlgoMD, eRPName, ListMDHits, ListODHits);
312 // if (sc.isFailure())
313 // {
314 // ATH_MSG_ERROR("Algorithm " << m_strAlgoMD << " for pot " << m_pGeometryReader->GetRPotLabel(eRPName) << " failure!");
315 // // return sc;
316 // }
317 // }
318 
319 // //execute OD reconstruction method
320 // if (!m_strAlgoOD.empty())
321 // {
322 // sc = ExecuteRecoMethod(m_strAlgoOD, eRPName, ListMDHits, ListODHits);
323 // if (sc.isFailure())
324 // {
325 // ATH_MSG_ERROR("Algorithm " << m_strAlgoOD << " for pot " << m_pGeometryReader->GetRPotLabel(eRPName) << " failure!");
326 // // return sc;
327 // }
328 // }
329 // }
330  }
331 
332  m_iEvent++;
333  ATH_MSG_DEBUG("end ALFA_LocRec::execute()");
334  return StatusCode::SUCCESS;
335 }
336 
337 StatusCode ALFA_LocRec::finalize()
338 {
339  ATH_MSG_DEBUG("begin ALFA_LocRec::finalize()");
340 
341 
342 
343  ATH_MSG_DEBUG("end ALFA_LocRec::finalize()");
344  return StatusCode::SUCCESS;
345 }
346 
347 void ALFA_LocRec::ClearGeometry()
348 {
349  ATH_MSG_DEBUG("begin ALFA_LocRec::ClearGeometry()");
350 
351  memset(&m_faMD, 0, sizeof(m_faMD));
352  memset(&m_fbMD, 0, sizeof(m_fbMD));
353  memset(&m_fzMD, 0, sizeof(m_fzMD));
354  memset(&m_faOD, 0, sizeof(m_faOD));
355  memset(&m_fbOD, 0, sizeof(m_fbOD));
356  memset(&m_fzOD, 0, sizeof(m_fzOD));
357 
358  ATH_MSG_DEBUG("end ALFA_LocRec::ClearGeometry()");
359 }
360 
361 StatusCode ALFA_LocRec::ALFACollectionReading(std::list<MDHIT> &ListMDHits, std::list<ODHIT> &ListODHits)
362 {
363  StatusCode sc;
364 
365  ATH_MSG_DEBUG("begin ALFA_LocRec::ALFACollectionReading()");
366 
367  ODHIT ODHit;
368  MDHIT MDHit;
369 
370  ListMDHits.clear();
371  ListODHits.clear();
372 
373  const ALFA_DigitCollection* mcGen = 0;
374  const ALFA_ODDigitCollection* mcODGen = 0;
375 
376  sc = evtStore()->retrieve(mcGen,m_strCollectionName);
377  if(sc.isFailure() || !mcGen)
378  {
379  return StatusCode::FAILURE;
380  }
381 
382  ALFA_DigitCollection::const_iterator mcGenBeg = mcGen->begin();
383  ALFA_DigitCollection::const_iterator mcGenEnd = mcGen->end();
384 
385  for(;mcGenBeg!=mcGenEnd;++mcGenBeg)
386  {
387  MDHit.iEvent = m_eventNum;
388 
389  MDHit.iRPot = ((*mcGenBeg)->getStation());
390  MDHit.iPlate = ((*mcGenBeg)->getPlate());
391  MDHit.iFiber = ((*mcGenBeg)->getFiber());
392 
393  ListMDHits.push_back(MDHit);
394  }
395 
396  sc = evtStore()->retrieve(mcODGen,m_strODCollectionName);
397  if(sc.isFailure() || !mcODGen)
398  {
399  return StatusCode::FAILURE;
400  }
401 
402  ALFA_ODDigitCollection::const_iterator mcODGenBeg = mcODGen->begin();
403  ALFA_ODDigitCollection::const_iterator mcODGenEnd = mcODGen->end();
404 
405  for(;mcODGenBeg!=mcODGenEnd;++mcODGenBeg)
406  {
407  ODHit.iEvent = m_eventNum;
408  ODHit.iRPot = ((*mcODGenBeg)->getStation());
409  ODHit.iPlate = ((*mcODGenBeg)->getPlate());
410  ODHit.iSide = ((*mcODGenBeg)->getSide());
411  ODHit.iFiber = ((*mcODGenBeg)->getFiber());
412 
413  ListODHits.push_back(ODHit);
414  }
415 
416  ATH_MSG_DEBUG("end ALFA_LocRec::ALFACollectionReading()");
417 
418  return StatusCode::SUCCESS;
419 }
420 
421 bool ALFA_LocRec::ReadGeometryDetCS()
422 {
423  ATH_MSG_DEBUG("begin ALFA_LocRec::ReadGeometryDetCS()");
424 
425  Int_t nPlateID, nFiberID;
426  FIBERPARAMS FiberParams;
427  eRPotName eRPName;
428 
429  bool bRes=false;
430  std::list<eRPotName>::const_iterator iterRPName;
431 
432  if((bRes=m_pGeometryReader->Initialize(&m_Config,EFCS_ATLAS))==true)
433  {
434  ATH_MSG_DEBUG("Geometry successfully initialized");
435  m_pGeometryReader->GetListOfExistingRPotIDs(&m_ListExistingRPots);
436  }
437  else
438  {
439  ATH_MSG_FATAL("Cannot initialize geometry");
440  return bRes;
441  }
442 
443  for(iterRPName=m_ListExistingRPots.begin();iterRPName!=m_ListExistingRPots.end();++iterRPName)
444  {
445  eRPName = *iterRPName;
446 
447  //for MD-fibers
448  for (nPlateID = 0; nPlateID < ALFAPLATESCNT; nPlateID++)
449  {
450  for (nFiberID = 0; nFiberID < ALFAFIBERSCNT; nFiberID++)
451  {
452  //for V-fibers
453  if (m_pGeometryReader->GetVFiberParams(&FiberParams, eRPName, nPlateID+1, nFiberID+1))
454  {
455  m_faMD[eRPName-1][2*nPlateID+1][nFiberID] = FiberParams.fSlope;
456  m_fbMD[eRPName-1][2*nPlateID+1][nFiberID] = FiberParams.fOffset;
457  m_fzMD[eRPName-1][2*nPlateID+1][nFiberID] = FiberParams.fZPos;
458  }
459  else
460  {
461  ATH_MSG_ERROR("Unable to get FiberV parameters");
462  return false;
463  }
464 
465  //for U-fibers
466  if (m_pGeometryReader->GetUFiberParams(&FiberParams, eRPName, nPlateID+1, nFiberID+1))
467  {
468  m_faMD[eRPName-1][2*nPlateID][nFiberID] = FiberParams.fSlope;
469  m_fbMD[eRPName-1][2*nPlateID][nFiberID] = FiberParams.fOffset;
470  m_fzMD[eRPName-1][2*nPlateID][nFiberID] = FiberParams.fZPos;
471  }
472  else
473  {
474  ATH_MSG_ERROR("Unable to get FiberU parameters");
475  return false;
476  }
477  }
478  }
479 
480  //m_ODfiber = (m_ODside==0)? m_ODfiber : 29-m_ODfiber;
481  //for OD-fibers
482  for (nPlateID = 0; nPlateID < ODPLATESCNT; nPlateID++)
483  {
484  for (nFiberID = 0; nFiberID < ODFIBERSCNT; nFiberID++)
485  {
486  //(+16 because U0-nFiberID is indexed from 16 to 30 in Geometry package)
487  if (m_pGeometryReader->GetODFiberParams(&FiberParams, EFT_ODFIBERU0, eRPName, nPlateID+1, nFiberID+16))
488  {
489  m_faOD[eRPName-1][nPlateID][0][nFiberID+15] = FiberParams.fSlope;
490  m_fbOD[eRPName-1][nPlateID][0][nFiberID+15] = FiberParams.fOffset;
491  m_fzOD[eRPName-1][nPlateID][0][nFiberID+15] = FiberParams.fZPos;
492  }
493  else
494  {
495  ATH_MSG_ERROR("Unable to get ODFiberU0 parameters");
496  return false;
497  }
498 
499  if (m_pGeometryReader->GetODFiberParams(&FiberParams, EFT_ODFIBERV0, eRPName, nPlateID+1, nFiberID+1))
500  {
501  m_faOD[eRPName-1][nPlateID][0][nFiberID] = FiberParams.fSlope;
502  m_fbOD[eRPName-1][nPlateID][0][nFiberID] = FiberParams.fOffset;
503  m_fzOD[eRPName-1][nPlateID][0][nFiberID] = FiberParams.fZPos;
504  }
505  else
506  {
507  ATH_MSG_ERROR("Unable to get ODFiberV0 parameters");
508  return false;
509  }
510 
511  if (m_pGeometryReader->GetODFiberParams(&FiberParams, EFT_ODFIBERU1, eRPName, nPlateID+1, nFiberID+16))
512  {
513  if (m_iDataType==1) //for the tunnel and testbeam data
514  {
515  m_faOD[eRPName-1][nPlateID][1][14-nFiberID] = FiberParams.fSlope;
516  m_fbOD[eRPName-1][nPlateID][1][14-nFiberID] = FiberParams.fOffset;
517  m_fzOD[eRPName-1][nPlateID][1][14-nFiberID] = FiberParams.fZPos;
518  }
519  else //simulation
520  {
521  m_faOD[eRPName-1][nPlateID][1][nFiberID+15] = FiberParams.fSlope;
522  m_fbOD[eRPName-1][nPlateID][1][nFiberID+15] = FiberParams.fOffset;
523  m_fzOD[eRPName-1][nPlateID][1][nFiberID+15] = FiberParams.fZPos;
524  }
525  }
526  else
527  {
528  ATH_MSG_ERROR("Unable to get ODFiberU1 parameters");
529  return false;
530  }
531  //(+16 because V1-nFiberID is indexed from 16 to 30 in Geometry package)
532  if (m_pGeometryReader->GetODFiberParams(&FiberParams, EFT_ODFIBERV1, eRPName, nPlateID+1, nFiberID+1))
533  {
534  if (m_iDataType==1) //for the tunnel and testbeam data
535  {
536  m_faOD[eRPName-1][nPlateID][1][29-nFiberID] = FiberParams.fSlope;
537  m_fbOD[eRPName-1][nPlateID][1][29-nFiberID] = FiberParams.fOffset;
538  m_fzOD[eRPName-1][nPlateID][1][29-nFiberID] = FiberParams.fZPos;
539  }
540  else //simulation
541  {
542  m_faOD[eRPName-1][nPlateID][1][nFiberID] = FiberParams.fSlope;
543  m_fbOD[eRPName-1][nPlateID][1][nFiberID] = FiberParams.fOffset;
544  m_fzOD[eRPName-1][nPlateID][1][nFiberID] = FiberParams.fZPos;
545  }
546  }
547  else
548  {
549  ATH_MSG_ERROR("Unable to get ODFiberV1 parameters");
550  return false;
551  }
552  }
553  }
554  }
555 
556 // SaveGeometry();
557 
558  ATH_MSG_DEBUG("end ALFA_LocRec::ReadGeometryDetCS()");
559 
560  return bRes;
561 }
562 
563 bool ALFA_LocRec::StoreReconstructionGeometry(const eRPotName eRPName, const eFiberType eFType, const char* szDataDestination)
564 {
565  ATH_MSG_DEBUG("begin ALFA_LocRec::StoreReconstructionGeometry()");
566 
567  Int_t iLayer, iFiber, iPlate, iSide;
568  Float_t fParamB, fZ, fSlope;
569  FILE * pFile;
570 
571  pFile = fopen(szDataDestination, "w");
572  if(pFile==NULL) return false;
573  fprintf(pFile, "xxxxxxxxxxxxxxxxxxx\n");
574  if (eFType==EFT_FIBERMD)
575  {
576  fprintf(pFile, "20\n");
577  for(iLayer=0; iLayer<2*ALFAPLATESCNT; iLayer++)
578  {
579  for(iFiber=0; iFiber<ALFAFIBERSCNT; iFiber++)
580  {
581  fSlope=m_faMD[eRPName-1][iLayer][iFiber];
582  fParamB=m_fbMD[eRPName-1][iLayer][iFiber];
583  fZ=m_fzMD[eRPName-1][iLayer][iFiber];
584 
585  fprintf(pFile, " %2d %2d %7.5f %7.4f %7.3f\n", iLayer+1, iFiber+1, fSlope, fParamB, fZ);
586  }
587  }
588  }
589  else if (eFType==EFT_FIBEROD)
590  {
591  fprintf(pFile, "6\n");
592  for(iPlate=0; iPlate<ODPLATESCNT; iPlate++)
593  {
594  for (iSide=0; iSide<ODSIDESCNT; iSide++)
595  {
596  for(iFiber=0; iFiber<ODLAYERSCNT*ODFIBERSCNT; iFiber++)
597  {
598  fSlope=m_faOD[eRPName-1][iPlate][iSide][iFiber];
599  fParamB=m_fbOD[eRPName-1][iPlate][iSide][iFiber];
600  fZ=m_fzOD[eRPName-1][iPlate][iSide][iFiber];
601 
602  fprintf(pFile, " %2d %2d %7.5f %7.4f %7.3f\n", (2*iPlate+iSide+1), iFiber+1, fSlope, fParamB, fZ);
603  }
604  }
605  }
606  }
607  fclose(pFile);
608 
609  ATH_MSG_DEBUG("end ALFA_LocRec::StoreReconstructionGeometry()");
610 
611  return true;
612 }
613 
614 void ALFA_LocRec::SaveGeometry()
615 {
616  ATH_MSG_DEBUG("begin ALFA_LocRec::SaveGeometry()");
617 
618 
619  eGeoSourceType eGeoType;
620  char szFilename[64];
621  std::list<eRPotName>::const_iterator iterRPName;
622 
623  for(iterRPName=m_ListExistingRPots.begin();iterRPName!=m_ListExistingRPots.end();++iterRPName)
624  {
625  eGeoType=m_pGeometryReader->GetRPGeometryType(*iterRPName, EFT_FIBERMD);
626  switch(eGeoType)
627  {
628  case EGST_IDEALGEOMETRY:
629  sprintf(szFilename,"ALFA_LocRec_Idealgeometry_RP-%s.txt",m_pGeometryReader->GetRPotLabel(*iterRPName));
630  StoreReconstructionGeometry(*iterRPName, EFT_FIBERMD, szFilename);
631  ATH_MSG_DEBUG("The ALFA Fiber geometry was stored in the "<<szFilename<<" file");
632  break;
633  case EGST_FILE:
634  sprintf(szFilename,"ALFA_LocRec_Realgeometry_RP-%s.txt",m_pGeometryReader->GetRPotLabel(*iterRPName));
635  StoreReconstructionGeometry(*iterRPName, EFT_FIBERMD, szFilename);
636  ATH_MSG_DEBUG("The ALFA Fiber geometry was stored in the "<<szFilename<<" file");
637  break;
638  case EGST_DATABASE:
639  sprintf(szFilename,"ALFA_LocRec_Realdbgeometry_RP-%s.txt",m_pGeometryReader->GetRPotLabel(*iterRPName));
640  StoreReconstructionGeometry(*iterRPName, EFT_FIBERMD, szFilename);
641  ATH_MSG_DEBUG("The ALFA Fiber geometry was stored in the "<<szFilename<<" file");
642  break;
643  default:
644  ATH_MSG_DEBUG("Unrecognized MD geometry!");
645  return;
646  break;
647  }
648 
649  eGeoType=m_pGeometryReader->GetRPGeometryType(*iterRPName, EFT_FIBEROD);
650  switch(eGeoType)
651  {
652  case EGST_IDEALGEOMETRY:
653  sprintf(szFilename,"ALFA_LocRec_Idealgeometry_OD_RP-%s.txt",m_pGeometryReader->GetRPotLabel(*iterRPName));
654  StoreReconstructionGeometry(*iterRPName, EFT_FIBEROD, szFilename);
655  ATH_MSG_DEBUG("The ODFiber geometry was stored in the "<<szFilename<<" file");
656  break;
657  case EGST_FILE:
658  sprintf(szFilename,"ALFA_LocRec_Realgeometry_OD_RP-%s.txt",m_pGeometryReader->GetRPotLabel(*iterRPName));
659  StoreReconstructionGeometry(*iterRPName, EFT_FIBEROD, szFilename);
660  ATH_MSG_DEBUG("The ODFiber geometry was stored in the "<<szFilename<<" file");
661  break;
662  case EGST_DATABASE:
663  sprintf(szFilename,"ALFA_LocRec_Realdbgeometry_OD_RP-%s.txt",m_pGeometryReader->GetRPotLabel(*iterRPName));
664  StoreReconstructionGeometry(*iterRPName, EFT_FIBEROD, szFilename);
665  ATH_MSG_DEBUG("The ODFiber geometry was stored in the "<<szFilename<<" file");
666  break;
667  default:
668  ATH_MSG_DEBUG("Unrecognized OD geometry!");
669  return;
670  break;
671  }
672  }
673 
674  ATH_MSG_DEBUG("end ALFA_LocRec::SaveGeometry()");
675 }
676 
677 StatusCode ALFA_LocRec::ExecuteRecoMethod(const std::string& strAlgo, const eRPotName eRPName, const std::list<MDHIT> &ListMDHits, const std::list<ODHIT> &ListODHits)
678 {
679  ATH_MSG_DEBUG("begin ALFA_LocRec::ExecuteRecoMethod()");
680 
681  StatusCode sc = StatusCode::SUCCESS;
682  ODRESULT ODResults;
683  std::list<ODRESULT> listODResults;
684  listODResults.clear();
685  Float_t fRecPosX = -9999.0;
686  Float_t fRecPosY = -9999.0;
687 
688  std::map<string, int> mapRecoMethods;
689  mapRecoMethods.clear();
690  mapRecoMethods.insert(std::pair<string, int>("ODTracking", 1));
691  mapRecoMethods.insert(std::pair<string, int>("MDTracking", 2));
692  mapRecoMethods.insert(std::pair<string, int>("MDOverlap", 3));
693  mapRecoMethods.insert(std::pair<string, int>("CenterGravity", 4));
694  mapRecoMethods.insert(std::pair<string, int>("MDMultiple", 5));
695  mapRecoMethods.insert(std::pair<string, int>("HalfReco", 6));
696  mapRecoMethods.insert(std::pair<string, int>("MDGap", 7));
697  mapRecoMethods.insert(std::pair<string, int>("EdgeMethod", 8));
698 
699  std::vector<int> vecFibSel;
700  vecFibSel.clear();
701 
702  switch(mapRecoMethods[strAlgo])
703  {
704  case 1:
705  {
706  ALFA_ODTracking* pODTracking = new ALFA_ODTracking();
707 
708  sc = pODTracking->Initialize(m_iMultiplicityCutOD, m_fDistanceCutOD, m_iLayerCutOD, m_iDataType);
709  sc = pODTracking->Execute(eRPName-1, ListODHits, m_faOD, m_fbOD);
710  sc = pODTracking->Finalize(&listODResults);
711 
712  std::list<ODRESULT>::const_iterator iter;
713  for(iter=listODResults.begin(); iter!=listODResults.end(); ++iter)
714  {
715  ODResults.iSide = (*iter).iSide;
716  ODResults.fRecPos = (*iter).fRecPos;
717  ODResults.fOverY = (*iter).fOverY;
718  ODResults.iNumY = (*iter).iNumY;
719 
720  if ((ODResults.fRecPos != -9999.0))
721  {
722  Int_t iFibSel[ODSIDESCNT][ODPLATESCNT];
723  std::fill_n(&iFibSel[0][0], sizeof(iFibSel)/sizeof(Int_t), -9999);
724 
725  pODTracking->GetData(iFibSel);
726  vecFibSel.clear();
727  for (int iPlate=0; iPlate<ODPLATESCNT; iPlate++)
728  {
729  vecFibSel.push_back(iFibSel[ODResults.iSide][iPlate]);
730  }
731 
732  m_pLocRecODEvCollection->push_back(new ALFA_LocRecODEvent(1, eRPName-1, ODResults.iSide, ODResults.fRecPos, ODResults.fOverY, ODResults.iNumY, vecFibSel));
733  }
734  }
735 
736  delete pODTracking;
737  break;
738  }
739  case 2:
740  {
741  ALFA_MDTracking* pMDTracking = new ALFA_MDTracking();
742  sc = pMDTracking->Initialize(m_faMD, m_fbMD, m_iMultiplicityCutMD, m_iUVCutMD, m_fOverlapCutMD);
743  sc = pMDTracking->Execute(eRPName-1, ListMDHits);
744  sc = pMDTracking->Finalize(fRecPosX, fRecPosY);
745 
746  if (fRecPosX!=-9999.0 && fRecPosY!=-9999.0)
747  {
748  Int_t iFibSel[ALFALAYERSCNT*ALFAPLATESCNT];
749  Int_t iNumU = 0, iNumV = 0;
750  Float_t fOverlapU = -9999.0, fOverlapV = -9999.0;
751  std::fill_n(&iFibSel[0], sizeof(iFibSel)/sizeof(Int_t), -9999);
752 
753  pMDTracking->GetData(iNumU, iNumV, fOverlapU, fOverlapV, iFibSel);
754  vecFibSel.clear();
755  for (int & iLayer : iFibSel)
756  {
757  vecFibSel.push_back(iLayer);
758  }
759 
760  m_pLocRecEvCollection->push_back(new ALFA_LocRecEvent(2, eRPName-1, fRecPosX, fRecPosY, fOverlapU, fOverlapV, iNumU, iNumV, std::move(vecFibSel)));
761  }
762 
763  delete pMDTracking;
764  break;
765  }
766  case 3:
767  {
768  ALFA_MDOverlap* pMDOverlap = new ALFA_MDOverlap();
769 
770  sc = pMDOverlap->Initialize(eRPName, ListMDHits, m_faMD, m_fbMD, m_fzMD);
771  sc = pMDOverlap->Execute();
772  sc = pMDOverlap->Finalize(fRecPosX, fRecPosY);
773 
774  Int_t iFibSel[ALFALAYERSCNT*ALFAPLATESCNT];
775  Int_t iNumU = 0, iNumV = 0;
776  Float_t fOverlapU = -9999.0, fOverlapV = -9999.0;
777  std::fill_n(&iFibSel[0], sizeof(iFibSel)/sizeof(Int_t), -9999);
778 
779  pMDOverlap->GetData(iFibSel);
780  if (fRecPosX!=-9999 && fRecPosY!=-9999)
781  {
782  vecFibSel.clear();
783  for (int & iLayer : iFibSel)
784  {
785  vecFibSel.push_back(iLayer);
786  }
787 
788  m_pLocRecEvCollection->push_back(new ALFA_LocRecEvent(3, eRPName-1, fRecPosX, fRecPosY, fOverlapU, fOverlapV, iNumU, iNumV, vecFibSel));
789  }
790 
791  delete pMDOverlap;
792  break;
793  }
794  case 4:
795  {
796  ALFA_CenterGravity* pCenterGravity = new ALFA_CenterGravity();
797 
798  sc = pCenterGravity->Initialize(eRPName, ListMDHits, m_faMD, m_fbMD, m_fzMD);
799  sc = pCenterGravity->Execute();
800  sc = pCenterGravity->Finalize(fRecPosX, fRecPosY);
801 
802  Int_t iFibSel[ALFALAYERSCNT*ALFAPLATESCNT];
803  Int_t iNumU = 0, iNumV = 0;
804  Float_t fOverlapU = -9999.0, fOverlapV = -9999.0;
805  std::fill_n(&iFibSel[0], sizeof(iFibSel)/sizeof(Int_t), -9999);
806 
807  pCenterGravity->GetData(iFibSel);
808  if (fRecPosX!=-9999 && fRecPosY!=-9999)
809  {
810  vecFibSel.clear();
811  for (int & iLayer : iFibSel)
812  {
813  vecFibSel.push_back(iLayer);
814  }
815 
816  m_pLocRecEvCollection->push_back(new ALFA_LocRecEvent(4, eRPName-1, fRecPosX, fRecPosY, fOverlapU, fOverlapV, iNumU, iNumV, vecFibSel));
817  }
818 
819  delete pCenterGravity;
820  break;
821  }
822  case 5:
823  {
824  // MDMultiple algorihm ------------------------------------------------------
825  Float_t fRecPosX[NTRACK];
826  Float_t fRecPosY[NTRACK];
827  ALFA_MDMultiple* pMDMultiple = new ALFA_MDMultiple();
828 
829  sc = pMDMultiple->Initialize(eRPName-1, m_faMD, m_fbMD, m_iMultiplicityCutMD, m_iNumLayerCutMD, m_iUVCutMD, m_fOverlapCutMD);
830  sc = pMDMultiple->Execute(ListMDHits);
831  sc = pMDMultiple->Finalize(fRecPosX, fRecPosY);
832 
833  Int_t iNumU[NTRACK], iNumV[NTRACK], iFibSel[NTRACK][ALFALAYERSCNT*ALFAPLATESCNT];
834  Float_t fOverU[NTRACK], fOverV[NTRACK];
835  std::fill_n(&iFibSel[0][0], sizeof(iFibSel)/sizeof(Int_t), -9999);
836  std::fill_n(&fOverU[0], sizeof(fOverU)/sizeof(Float_t), -9999.0);
837  std::fill_n(&fOverV[0], sizeof(fOverV)/sizeof(Float_t), -9999.0);
838  memset(&iNumU, 0, sizeof(iNumU));
839  memset(&iNumV, 0, sizeof(iNumV));
840 
841  pMDMultiple->GetData(iNumU, iNumV, fOverU, fOverV, iFibSel);
842  for (Int_t iTrack=0; iTrack<NTRACK; iTrack++)
843  {
844  if (fRecPosX[iTrack] != -9999.0 && fRecPosY[iTrack] != -9999.0)
845  {
846  vecFibSel.clear();
847  for (Int_t iLayer=0; iLayer<ALFALAYERSCNT*ALFAPLATESCNT; iLayer++)
848  {
849  vecFibSel.push_back(iFibSel[iTrack][iLayer]);
850  }
851 
852  m_pLocRecEvCollection->push_back(new ALFA_LocRecEvent(5, eRPName-1, fRecPosX[iTrack], fRecPosY[iTrack], fOverU[iTrack], fOverV[iTrack], iNumU[iTrack], iNumV[iTrack], vecFibSel));
853  }
854  }
855 
856  delete pMDMultiple;
857  break;
858  }
859  case 6:
860  {
861  //TODO - cele prepracovat
862  ALFA_HalfReco* pHalfReco = new ALFA_HalfReco();
863 
864  Int_t iNumU[2] = {0, 0};
865  Int_t iNumV[2] = {0, 0};
866  Int_t iHalfFirst=0;
867  Int_t iHalfSecond=1;
868  Float_t fOverlapU[2] = {-9999, -9999};
869  Float_t fOverlapV[2] = {-9999, -9999};
870  Float_t fRecPosX[2] = {-9999, -9999};
871  Float_t fRecPosY[2] = {-9999, -9999};
872 
873  Int_t iFibSel[ALFALAYERSCNT*ALFAPLATESCNT];
874  std::fill_n(&iFibSel[0], sizeof(iFibSel)/sizeof(Int_t), -9999);
875 
876  std::vector<int> vecFibSel0;
877  std::vector<int> vecFibSel1;
878  vecFibSel0.clear();
879  vecFibSel1.clear();
880 
881  if (eRPName==1 || eRPName==3 || eRPName==6 || eRPName==8)
882  {
883  iHalfFirst = 0;
884  iHalfSecond = 1;
885  }
886  else
887  {
888  iHalfFirst = 1;
889  iHalfSecond = 0;
890  }
891 
892  sc = pHalfReco->Initialize(m_faMD, m_fbMD, iHalfFirst, m_iMultiplicityCutMD, m_iUVCutMDHalfReco, m_fOverlapCutMD);
893  sc = pHalfReco->Execute(eRPName-1, ListMDHits);
894  sc = pHalfReco->Finalize(fRecPosX[0], fRecPosY[0]);
895 
896  pHalfReco->GetData(iNumU[0], iNumV[0], fOverlapU[0], fOverlapV[0], iFibSel);
897  vecFibSel0.clear();
898  for (int & iLayer : iFibSel)
899  {
900  vecFibSel0.push_back(iLayer);
901  }
902 
903  sc = pHalfReco->Initialize(m_faMD, m_fbMD, iHalfSecond, m_iMultiplicityCutMD, m_iUVCutMDHalfReco, m_fOverlapCutMD);
904  sc = pHalfReco->Execute(eRPName-1, ListMDHits);
905  sc = pHalfReco->Finalize(fRecPosX[1], fRecPosY[1]);
906 
907  pHalfReco->GetData(iNumU[1], iNumV[1], fOverlapU[1], fOverlapV[1], iFibSel);
908  vecFibSel1.clear();
909  for (int & iLayer : iFibSel)
910  {
911  vecFibSel1.push_back(iLayer);
912  }
913 
914  if (fRecPosX[0]!=-9999.0 && fRecPosY[0]!=-9999.0 && fRecPosX[1]!=-9999.0 && fRecPosY[1]!=-9999.0)
915  {
916  m_pLocRecEvCollection->push_back(new ALFA_LocRecEvent(6, eRPName-1, fRecPosX[0], fRecPosY[0], fOverlapU[0], fOverlapV[0], iNumU[0], iNumV[0], std::move(vecFibSel0)));
917  m_pLocRecEvCollection->push_back(new ALFA_LocRecEvent(6, eRPName-1, fRecPosX[1], fRecPosY[1], fOverlapU[1], fOverlapV[1], iNumU[1], iNumV[1], std::move(vecFibSel1)));
918  }
919 
920  delete pHalfReco;
921  break;
922  }
923  case 7:
924  {
925  Float_t fRecPosX[NTRACK];
926  Float_t fRecPosY[NTRACK];
927  ALFA_MDGap* pMDGap = new ALFA_MDGap();
928 
929  sc = pMDGap->Initialize(eRPName-1, m_faMD, m_fbMD, m_iUVCutMD, m_fOverlapCutMD);
930  sc = pMDGap->Execute(ListMDHits);
931  sc = pMDGap->Finalize(fRecPosX, fRecPosY);
932 
933  Int_t iNumU[NTRACK], iNumV[NTRACK];
934  Int_t iFibSel[ALFALAYERSCNT*ALFAPLATESCNT];
935  Float_t fOverU[NTRACK], fOverV[NTRACK];
936 
937  std::fill_n(&iFibSel[0], sizeof(iFibSel)/sizeof(Int_t), -9999);
938  std::fill_n(&fOverU[0], sizeof(fOverU)/sizeof(Float_t), -9999.0);
939  std::fill_n(&fOverV[0], sizeof(fOverV)/sizeof(Float_t), -9999.0);
940 
941  pMDGap->GetData(iNumU, iNumV, fOverU, fOverV, iFibSel);
942  for (Int_t iTrack=0; iTrack<NTRACK; iTrack++)
943  {
944  if (fRecPosX[iTrack] != -9999.0 && fRecPosY[iTrack] != -9999.0)
945  {
946  vecFibSel.clear();
947  for (int & iLayer : iFibSel)
948  {
949  vecFibSel.push_back(iLayer);
950  }
951 
952  m_pLocRecEvCollection->push_back(new ALFA_LocRecEvent(7, eRPName-1, fRecPosX[iTrack], fRecPosY[iTrack], fOverU[iTrack], fOverV[iTrack], iNumU[iTrack], iNumV[iTrack], vecFibSel));
953  }
954  }
955 
956  delete pMDGap;
957  break;
958  }
959  case 8:
960  {
961  Float_t fRecPosX[NTRACK];
962  Float_t fRecPosY[NTRACK];
963  ALFA_EdgeMethod* pEdgeMethod = new ALFA_EdgeMethod(m_bEdgeMethod_Opt_Sisters, m_bEdgeMethod_Opt_UseGaps);
964  pEdgeMethod->Initialize(eRPName-1, m_faMD, m_fbMD, ListMDHits);
965 
966  Int_t iNumU[NTRACK], iNumV[NTRACK];
967  Int_t iFibSel[ALFALAYERSCNT*ALFAPLATESCNT];
968  Float_t fOverU[NTRACK], fOverV[NTRACK];
969 
970  std::fill_n(&iFibSel[0], sizeof(iFibSel)/sizeof(Int_t), -9999);
971  std::fill_n(&fOverU[0], sizeof(fOverU)/sizeof(Float_t), -9999.0);
972  std::fill_n(&fOverV[0], sizeof(fOverV)/sizeof(Float_t), -9999.0);
973 
974 
975  std::vector<ALFA_EdgeMethod::Track> tracks;
976  pEdgeMethod->EdgeMethod(eRPName - 1, tracks);
977 
978  for (UInt_t iTrack=0; iTrack<tracks.size(); iTrack++)
979  {
980  pEdgeMethod->selectedFibers(eRPName - 1, tracks.at(iTrack), iFibSel);
981 
982  iNumU[iTrack] = tracks.at(iTrack).first.second;
983  iNumV[iTrack] = tracks.at(iTrack).second.second;
984  fOverU[iTrack] = tracks.at(iTrack).first.first.second;
985  fOverV[iTrack] = tracks.at(iTrack).second.first.second;
986  fRecPosX[iTrack] = 0.5*TMath::Sqrt2()*(-tracks.at(iTrack).first.first.first-tracks.at(iTrack).second.first.first);
987  fRecPosY[iTrack] = 0.5*TMath::Sqrt2()*(-tracks.at(iTrack).first.first.first+tracks.at(iTrack).second.first.first);
988 
989  if (fRecPosX[iTrack] != -9999.0 && fRecPosY[iTrack] != -9999.0)
990  {
991  vecFibSel.clear();
992  for (int & iLayer : iFibSel)
993  {
994  vecFibSel.push_back(iLayer);
995  }
996 
997  m_pLocRecEvCollection->push_back(new ALFA_LocRecEvent(8, eRPName-1, fRecPosX[iTrack], fRecPosY[iTrack], fOverU[iTrack], fOverV[iTrack], iNumU[iTrack], iNumV[iTrack], vecFibSel));
998  }
999  }
1000 
1001  delete pEdgeMethod;
1002  sc = StatusCode::SUCCESS;
1003  break;
1004  }
1005  default:
1006  {
1007  ATH_MSG_ERROR("Unable to recognize selected algorithm");
1008  std::cout << "strAlgo: " << strAlgo << std::endl;
1009  return StatusCode::SUCCESS;
1010  }
1011  }
1012 
1013  ATH_MSG_DEBUG("end ALFA_LocRec::ExecuteRecoMethod()");
1014 
1015  return sc;
1016 }
1017 
1018 StatusCode ALFA_LocRec::RecordCollection()
1019 {
1020  ATH_MSG_DEBUG("begin ALFA_LocRec::RecordCollection()");
1021 
1022  StatusCode sc = StatusCode::SUCCESS;
1023 
1024  m_pLocRecEvCollection = new ALFA_LocRecEvCollection();
1025  sc = evtStore()->record(m_pLocRecEvCollection, m_strKeyLocRecEvCollection);
1026 
1027  if (sc.isFailure())
1028  {
1029  ATH_MSG_ERROR(m_strAlgoMD << "MD - Could not record the empty LocRecEv collection in StoreGate");
1030  return sc;
1031  }
1032  else
1033  {
1034  ATH_MSG_DEBUG("MD - LocRecEv collection was recorded in StoreGate");
1035  }
1036 
1037  ATH_MSG_DEBUG("end ALFA_LocRec::RecordCollection()");
1038 
1039  return sc;
1040 }
1041 
1042 StatusCode ALFA_LocRec::RecordODCollection()
1043 {
1044  ATH_MSG_DEBUG("begin ALFA_LocRec::RecordODCollection()");
1045 
1046  StatusCode sc = StatusCode::SUCCESS;
1047 
1048  m_pLocRecODEvCollection = new ALFA_LocRecODEvCollection();
1049  sc = evtStore()->record(m_pLocRecODEvCollection, m_strKeyLocRecODEvCollection);
1050 
1051  if (sc.isFailure())
1052  {
1053  ATH_MSG_ERROR(m_strAlgoOD << "OD - Could not record the empty LocRecEv collection in StoreGate");
1054 
1055  return sc;
1056  }
1057  else
1058  {
1059  ATH_MSG_DEBUG("OD - LocRecEv collection is recorded in StoreGate");
1060  }
1061 
1062  ATH_MSG_DEBUG("end ALFA_LocRec::RecordODCollection()");
1063 
1064  return sc;
1065 }
1066 
1067 void ODRESULT::clear()
1068 {
1069  iSide = -1;
1070  fRecPos = -9999.0;
1071  fOverY = -9999.0;
1072  iNumY = -1;
1073 }
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_LocRec::m_fzMD
Float_t m_fzMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT]
Definition: ALFA_LocRec.h:81
ALFA_MDTracking::Execute
StatusCode Execute(Int_t iRPot, const std::list< MDHIT > &ListMDHits)
Definition: ALFA_MDTracking.cxx:62
eFiberType
eFiberType
Definition: ALFA_GeometryReader.h:25
ALFA_LocRec::StoreReconstructionGeometry
bool StoreReconstructionGeometry(const eRPotName eRPName, const eFiberType eFType, const char *szDataDestination)
Definition: ALFA_LocRec.cxx:563
createLinkingScheme.iter
iter
Definition: createLinkingScheme.py:62
ALFA_ODDigitCollection.h
ALFA_LocRec::m_fbOD
Float_t m_fbOD[RPOTSCNT][ODPLATESCNT][ODSIDESCNT][ODLAYERSCNT *ODFIBERSCNT]
Definition: ALFA_LocRec.h:85
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
_MDHIT::iRPot
int iRPot
Definition: ALFA_LocRec/ALFA_UserObjects.h:24
ALFA_LocRec::m_strODCollectionName
std::string m_strODCollectionName
Definition: ALFA_LocRec.h:96
ALFA_LocRec::m_bEdgeMethod_Opt_UseGaps
Bool_t m_bEdgeMethod_Opt_UseGaps
Definition: ALFA_LocRec.h:76
ALFA_MDTracking::GetData
void GetData(Int_t &NumU, Int_t &NumV, Float_t &OL_U, Float_t &OL_V, Int_t(&iFibSel)[ALFALAYERSCNT *ALFAPLATESCNT])
Definition: ALFA_MDTracking.cxx:450
NTRACK
#define NTRACK
Definition: ALFA_LocRec.h:36
ALFA_LocRec::m_strAlgoOD
std::string m_strAlgoOD
Definition: ALFA_LocRec.h:91
ALFA_LocRec::m_ListExistingRPots
std::list< eRPotName > m_ListExistingRPots
Definition: ALFA_LocRec.h:62
ALFA_LocRec::m_Config
GEOMETRYCONFIGURATION m_Config
Definition: ALFA_LocRec.h:50
ALFA_LocRec::m_iMultiplicityCutOD
Int_t m_iMultiplicityCutOD
Definition: ALFA_LocRec.h:71
xAOD::EventInfo_v1::eventNumber
uint64_t eventNumber() const
The current event's event number.
ALFA_MDGap.h
EFT_ODFIBERV0
@ EFT_ODFIBERV0
Definition: ALFA_GeometryReader.h:25
ODLAYERSCNT
#define ODLAYERSCNT
Definition: ALFA_CLinkAlg.h:30
ALFA_HalfReco::Execute
StatusCode Execute(Int_t iRPot, const std::list< MDHIT > &ListMDHits)
Definition: ALFA_HalfReco.cxx:63
ALFA_MDTracking::Initialize
StatusCode Initialize(Float_t faMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT], Float_t fbMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT], Int_t iMultiplicityCut, Int_t iUVCut, Float_t fOverlapCut)
Definition: ALFA_MDTracking.cxx:37
ALFA_LocRec::m_strKeyGeometryForReco
std::string m_strKeyGeometryForReco
Definition: ALFA_LocRec.h:88
ALFA_LocRec::RecordODCollection
StatusCode RecordODCollection()
Definition: ALFA_LocRec.cxx:1042
ALFA_LocRec::SaveGeometry
void SaveGeometry()
Definition: ALFA_LocRec.cxx:614
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
EGST_IDEALGEOMETRY
@ EGST_IDEALGEOMETRY
Definition: ALFA_GeometryReader.h:23
ALFA_LocRec::initialize
StatusCode initialize()
Definition: ALFA_LocRec.cxx:156
FIBERPARAMS::fOffset
double fOffset
Definition: ALFA_GeometryReader.h:113
ALFA_GeometryReader::GetRPGeometryType
eGeoSourceType GetRPGeometryType(const eRPotName eRPName, eFiberType eFType)
Definition: ALFA_GeometryReader.cxx:1861
FIBERPARAMS::fZPos
double fZPos
Definition: ALFA_GeometryReader.h:114
ALFAFIBERSCNT
#define ALFAFIBERSCNT
Definition: ALFA_constants.h:10
eRPotName
eRPotName
Definition: ALFA_GeometryReader.h:27
ALFA_LocRec::m_eventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
Definition: ALFA_LocRec.h:59
ALFA_GeometryReader.h
ALFA_GeometryReader::GetRPotLabel
const char * GetRPotLabel(const eRPotName eRPName)
Definition: ALFA_GeometryReader.h:279
ALFA_CenterGravity
Definition: ALFA_CenterGravity.h:25
ALFA_LocRec::m_pLocRecODEvent
ALFA_LocRecODEvent * m_pLocRecODEvent
Definition: ALFA_LocRec.h:57
ALFA_GeometryReader::GetVFiberParams
bool GetVFiberParams(PFIBERPARAMS pFiberParams, const eRPotName eRPName, const int nPlateID, const int nFiberID)
Definition: ALFA_GeometryReader.cxx:1339
ALFA_ODTracking::GetData
void GetData(Int_t(&iFibSel)[ODSIDESCNT][ODPLATESCNT])
Definition: ALFA_ODTracking.cxx:331
ALFA_LocRec::m_strKeyLocRecEvCollection
std::string m_strKeyLocRecEvCollection
Definition: ALFA_LocRec.h:93
_ODHIT::iRPot
int iRPot
Definition: ALFA_LocRec/ALFA_UserObjects.h:15
ALFA_MDOverlap::Execute
StatusCode Execute()
Definition: ALFA_MDOverlap.cxx:90
_ODRESULT::iNumY
int iNumY
Definition: ALFA_LocRec/ALFA_UserObjects.h:39
ALFA_MDOverlap::Finalize
StatusCode Finalize(Float_t &fRecXPos, Float_t &fRecYPos)
Definition: ALFA_MDOverlap.cxx:113
ALFA_ODTracking::Finalize
StatusCode Finalize(std::list< ODRESULT > *pListResults)
Definition: ALFA_ODTracking.cxx:80
ALFA_LocRec::m_pLocRecODEvCollection
ALFA_LocRecODEvCollection * m_pLocRecODEvCollection
Definition: ALFA_LocRec.h:56
ALFA_LocRec::m_bEdgeMethod_Opt_Sisters
Bool_t m_bEdgeMethod_Opt_Sisters
Definition: ALFA_LocRec.h:75
ALFA_MDGap::Execute
StatusCode Execute(const std::list< MDHIT > &ListMDHits)
Definition: ALFA_MDGap.cxx:64
ALFA_LocRec::m_iLayerCutOD
Float_t m_iLayerCutOD
Definition: ALFA_LocRec.h:74
EFT_FIBERMD
@ EFT_FIBERMD
Definition: ALFA_GeometryReader.h:25
ALFA_MDTracking
Definition: ALFA_MDTracking.h:24
ALFA_LocRec::~ALFA_LocRec
~ALFA_LocRec()
Definition: ALFA_LocRec.cxx:143
FIBERPARAMS
Definition: ALFA_GeometryReader.h:98
ALFA_LocRec::finalize
StatusCode finalize()
Definition: ALFA_LocRec.cxx:337
ALFA_LocRecEvent
Definition: ALFA_LocRecEvent.h:10
ALFA_MDGap
Definition: ALFA_MDGap.h:28
ALFA_EdgeMethod::EdgeMethod
Bool_t EdgeMethod(UInt_t no_Detector, std::vector< Track > &tracks)
Definition: ALFA_EdgeMethod.cxx:276
GEOMETRYCONFIGURATION::clear
void clear()
Definition: ALFA_GeometryReader.cxx:72
_ODRESULT::clear
void clear()
Definition: ALFA_LocRec.cxx:1067
ALFA_LocRec::m_strKeyLocRecODEvCollection
std::string m_strKeyLocRecODEvCollection
Definition: ALFA_LocRec.h:94
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
EMT_NOMINAL
@ EMT_NOMINAL
Definition: ALFA_GeometryReader.h:24
_ODHIT::iFiber
int iFiber
Definition: ALFA_LocRec/ALFA_UserObjects.h:18
CFGRPPOSPARAMS::strODConnString
std::string strODConnString
Definition: ALFA_GeometryReader.h:178
AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
CFGRPPOSPARAMS::strMDConnString
std::string strMDConnString
Definition: ALFA_GeometryReader.h:177
ALFA_ODTracking
Definition: ALFA_ODTracking.h:23
ALFA_LocRecODEvCollection
Definition: ALFA_LocRecODEvCollection.h:13
ALFA_EdgeMethod
Definition: ALFA_EdgeMethod.h:20
ALFA_LocRec::m_fDistanceCutOD
Float_t m_fDistanceCutOD
Definition: ALFA_LocRec.h:73
ALFA_MDGap::Finalize
StatusCode Finalize(Float_t(&fRecXPos)[MAXTRACKNUM], Float_t(&fRecYPos)[MAXTRACKNUM])
Definition: ALFA_MDGap.cxx:144
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
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
ALFA_HalfReco::Finalize
StatusCode Finalize(Float_t &fRecXPos, Float_t &fRecYPos)
Definition: ALFA_HalfReco.cxx:121
ALFA_MDGap::GetData
void GetData(Int_t(&iNumU)[MAXTRACKNUM], Int_t(&iNumV)[MAXTRACKNUM], Float_t(&fOvU)[MAXTRACKNUM], Float_t(&fOvV)[MAXTRACKNUM], Int_t(&iFibSel)[ALFALAYERSCNT *ALFAPLATESCNT])
Definition: ALFA_MDGap.cxx:520
ALFA_HalfReco::GetData
void GetData(Int_t &iNumU, Int_t &iNumV, Float_t &fOvU, Float_t &fOvV, Int_t(&iFibSel)[ALFALAYERSCNT *ALFAPLATESCNT])
Definition: ALFA_HalfReco.cxx:448
ALFA_MDMultiple::Finalize
StatusCode Finalize(Float_t(&fRecXPos)[MAXTRACKNUM], Float_t(&fRecYPos)[MAXTRACKNUM])
Definition: ALFA_MDMultiple.cxx:327
ALFA_LocRec::m_vecListAlgoMD
std::vector< std::string > m_vecListAlgoMD
Definition: ALFA_LocRec.h:89
ALFA_MDOverlap.h
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
ALFA_LocRec::m_strCollectionName
std::string m_strCollectionName
Definition: ALFA_LocRec.h:95
ERPPT_ACTIVE
@ ERPPT_ACTIVE
Definition: ALFA_GeometryReader.h:28
ALFA_LocRec::ReadGeometryDetCS
bool ReadGeometryDetCS()
Definition: ALFA_LocRec.cxx:421
_ODHIT::iPlate
int iPlate
Definition: ALFA_LocRec/ALFA_UserObjects.h:16
ALFA_MDMultiple
Definition: ALFA_MDMultiple.h:28
_ODRESULT::fOverY
double fOverY
Definition: ALFA_LocRec/ALFA_UserObjects.h:38
_MDHIT::iEvent
int iEvent
Definition: ALFA_LocRec/ALFA_UserObjects.h:23
ALFA_LocRec::m_pLocRecEvent
ALFA_LocRecEvent * m_pLocRecEvent
Definition: ALFA_LocRec.h:54
ALFA_LocRec::ExecuteRecoMethod
StatusCode ExecuteRecoMethod(const std::string &strAlgo, const eRPotName eRPName, const std::list< MDHIT > &ListMDHits, const std::list< ODHIT > &ListODHits)
Definition: ALFA_LocRec.cxx:677
lumiFormat.i
int i
Definition: lumiFormat.py:85
ALFA_ODTracking::Execute
StatusCode Execute(Int_t iRPot, const std::list< ODHIT > &ListODHits, Float_t faOD[RPOTSCNT][ODPLATESCNT][ODSIDESCNT][ODLAYERSCNT *ODFIBERSCNT], Float_t fbOD[RPOTSCNT][ODPLATESCNT][ODSIDESCNT][ODLAYERSCNT *ODFIBERSCNT])
Definition: ALFA_ODTracking.cxx:38
ALFA_CenterGravity::Initialize
StatusCode Initialize(const eRPotName &eRPName, const std::list< MDHIT > &ListMDHits, Float_t faMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT], Float_t fbMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT], Float_t fzMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT])
Definition: ALFA_CenterGravity.cxx:37
ALFA_HalfReco
Definition: ALFA_HalfReco.h:24
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
EFT_ODFIBERU1
@ EFT_ODFIBERU1
Definition: ALFA_GeometryReader.h:25
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
ALFA_CenterGravity.h
ALFA_MDOverlap::GetData
void GetData(Int_t(&iFibSel)[ALFALAYERSCNT *ALFAPLATESCNT])
Definition: ALFA_MDOverlap.cxx:439
ALFA_EdgeMethod.h
ALFA_ODTracking::Initialize
StatusCode Initialize(Int_t fMultiplicityCut, Float_t fDistanceCut, Int_t iLayerCut, Int_t iDataType)
Definition: ALFA_ODTracking.cxx:28
ALFA_LocRec::m_iUVCutMD
Int_t m_iUVCutMD
Definition: ALFA_LocRec.h:69
ALFA_LocRec::ALFACollectionReading
StatusCode ALFACollectionReading(std::list< MDHIT > &ListMDHits, std::list< ODHIT > &ListODHits)
Definition: ALFA_LocRec.cxx:361
_ODRESULT::iSide
int iSide
Definition: ALFA_LocRec/ALFA_UserObjects.h:36
ALFA_GeometryReader::Initialize
bool Initialize(const PGEOMETRYCONFIGURATION pConfig, eFiberCoordSystem eFCoordSystem)
Definition: ALFA_GeometryReader.cxx:623
ALFA_HalfReco.h
ALFA_LocRec::m_pGeometryReader
ALFA_GeometryReader * m_pGeometryReader
Definition: ALFA_LocRec.h:51
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
ALFA_LocRec::m_iEvent
Int_t m_iEvent
Definition: ALFA_LocRec.h:66
ALFA_MDTracking.h
ODSIDESCNT
#define ODSIDESCNT
Definition: ALFA_constants.h:16
ALFA_EdgeMethod::selectedFibers
void selectedFibers(UInt_t no_Detector, Track &track, Int_t *selectedFib)
Definition: ALFA_EdgeMethod.cxx:298
GEOMETRYCONFIGURATION::CfgRPosParams
CFGRPPOSPARAMS CfgRPosParams[RPOTSCNT]
Definition: ALFA_GeometryReader.h:205
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
ALFA_LocRecODEvent
Definition: ALFA_LocRecODEvent.h:10
ALFA_DigitCollection.h
ALFALAYERSCNT
#define ALFALAYERSCNT
Definition: ALFA_constants.h:8
AthAlgorithm
Definition: AthAlgorithm.h:47
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
ALFA_MDMultiple::Execute
StatusCode Execute(const std::list< MDHIT > &ListMDHits)
Definition: ALFA_MDMultiple.cxx:167
_MDHIT::iFiber
int iFiber
Definition: ALFA_LocRec/ALFA_UserObjects.h:26
ALFA_MDOverlap::Initialize
StatusCode Initialize(const eRPotName &eRPName, const std::list< MDHIT > &ListMDHits, Float_t faMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT], Float_t fbMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT], Float_t fzMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT])
Definition: ALFA_MDOverlap.cxx:36
ALFA_LocRec::m_eventNum
UInt_t m_eventNum
Definition: ALFA_LocRec.h:64
GEOMETRYCONFIGURATION::eRPMetrologyGeoType
int eRPMetrologyGeoType
Definition: ALFA_GeometryReader.h:197
ALFA_DigitCollection
Definition: ALFA_DigitCollection.h:15
ALFA_CenterGravity::GetData
void GetData(Int_t(&iFibSel)[ALFALAYERSCNT *ALFAPLATESCNT])
Definition: ALFA_CenterGravity.cxx:337
ALFA_EdgeMethod::Initialize
void Initialize(Int_t iRPot, Float_t faMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT], Float_t fbMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT], const std::list< MDHIT > &ListMDHits)
Definition: ALFA_EdgeMethod.cxx:27
ALFA_LocRecEvCollection
Definition: ALFA_LocRecEvCollection.h:13
_ODRESULT::fRecPos
double fRecPos
Definition: ALFA_LocRec/ALFA_UserObjects.h:37
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
ALFA_LocRec::m_vecListAlgoOD
std::vector< std::string > m_vecListAlgoOD
Definition: ALFA_LocRec.h:90
EGST_DATABASE
@ EGST_DATABASE
Definition: ALFA_GeometryReader.h:23
ALFA_LocRec::m_iNumLayerCutMD
Int_t m_iNumLayerCutMD
Definition: ALFA_LocRec.h:68
errorcheck.h
Helpers for checking error return status codes and reporting errors.
ALFA_LocRec::m_faOD
Float_t m_faOD[RPOTSCNT][ODPLATESCNT][ODSIDESCNT][ODLAYERSCNT *ODFIBERSCNT]
Definition: ALFA_LocRec.h:84
ALFA_LocRecEvCollection.h
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
ALFA_LocRec::ALFA_LocRec
ALFA_LocRec(const std::string &name, ISvcLocator *pSvcLocator)
Definition: ALFA_LocRec.cxx:24
ALFA_GeometryReader::GetODFiberParams
bool GetODFiberParams(PFIBERPARAMS pFiberParams, const eFiberType eFType, const eRPotName eRPName, const int nPlateID, const int nFiberID)
Definition: ALFA_GeometryReader.cxx:1910
ALFA_CenterGravity::Finalize
StatusCode Finalize(Float_t &fRecXPos, Float_t &fRecYPos)
Definition: ALFA_CenterGravity.cxx:114
ALFA_LocRec::m_strAlgoMD
std::string m_strAlgoMD
Definition: ALFA_LocRec.h:92
ALFA_LocRec::m_pLocRecEvCollection
ALFA_LocRecEvCollection * m_pLocRecEvCollection
Definition: ALFA_LocRec.h:53
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
CFGRPPOSPARAMS::eODGeoType
int eODGeoType
Definition: ALFA_GeometryReader.h:176
ALFA_GeometryReader
Definition: ALFA_GeometryReader.h:215
ALFA_LocRec::m_fbMD
Float_t m_fbMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT]
Definition: ALFA_LocRec.h:80
ODPLATESCNT
#define ODPLATESCNT
Definition: ALFA_CLinkAlg.h:31
ALFA_MDMultiple.h
ALFA_GeometryReader::GetUFiberParams
bool GetUFiberParams(PFIBERPARAMS pFiberParams, const eRPotName eRPName, const int nPlateID, const int nFiberID)
Definition: ALFA_GeometryReader.cxx:1311
ALFA_HalfReco::Initialize
StatusCode Initialize(Float_t faMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT], Float_t fbMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT], Int_t iHalf, Int_t fMultiplicityCut, Int_t iUVCut, Float_t fOverlapCut)
Definition: ALFA_HalfReco.cxx:37
_MDHIT
Definition: ALFA_LocRec/ALFA_UserObjects.h:22
ALFA_GeometryReader::GetListOfExistingRPotIDs
void GetListOfExistingRPotIDs(std::list< eRPotName > *pListRPotName)
Definition: ALFA_GeometryReader.cxx:1818
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
EFCS_ATLAS
@ EFCS_ATLAS
Definition: ALFA_GeometryReader.h:29
ODFIBERSCNT
#define ODFIBERSCNT
Definition: ALFA_CLinkAlg.h:32
CFGRPPOSPARAMS::eRPPosType
int eRPPosType
Definition: ALFA_GeometryReader.h:174
ALFA_LocRec.h
_MDHIT::iPlate
int iPlate
Definition: ALFA_LocRec/ALFA_UserObjects.h:25
ALFA_LocRec::m_iUVCutMDHalfReco
Int_t m_iUVCutMDHalfReco
Definition: ALFA_LocRec.h:70
ALFA_MDOverlap
Definition: ALFA_MDOverlap.h:26
GEOMETRYCONFIGURATION::bShiftToX97Pos
bool bShiftToX97Pos
Definition: ALFA_GeometryReader.h:199
ALFA_LocRec::execute
StatusCode execute()
Definition: ALFA_LocRec.cxx:211
FIBERPARAMS::fSlope
double fSlope
Definition: ALFA_GeometryReader.h:112
EFT_ODFIBERU0
@ EFT_ODFIBERU0
Definition: ALFA_GeometryReader.h:25
EGST_FILE
@ EGST_FILE
Definition: ALFA_GeometryReader.h:23
eGeoSourceType
eGeoSourceType
Definition: ALFA_GeometryReader.h:23
_ODHIT::iSide
int iSide
Definition: ALFA_LocRec/ALFA_UserObjects.h:17
EFT_ODFIBERV1
@ EFT_ODFIBERV1
Definition: ALFA_GeometryReader.h:25
ALFA_LocRecODEvCollection.h
ALFA_CenterGravity::Execute
StatusCode Execute()
Definition: ALFA_CenterGravity.cxx:91
GEOMETRYCONFIGURATION::strRPMetrologyConnString
std::string strRPMetrologyConnString
Definition: ALFA_GeometryReader.h:198
ALFA_MDTracking::Finalize
StatusCode Finalize(Float_t &fRecXPos, Float_t &fRecYPos)
Definition: ALFA_MDTracking.cxx:116
_ODRESULT
Definition: ALFA_LocRec/ALFA_UserObjects.h:35
EFT_FIBEROD
@ EFT_FIBEROD
Definition: ALFA_GeometryReader.h:25
ALFA_LocRec::ClearGeometry
void ClearGeometry()
Definition: ALFA_LocRec.cxx:347
ALFA_LocRec::m_faMD
Float_t m_faMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT]
Definition: ALFA_LocRec.h:79
CFGRPPOSPARAMS::eMDGeoType
int eMDGeoType
Definition: ALFA_GeometryReader.h:175
ALFA_MDGap::Initialize
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)
Definition: ALFA_MDGap.cxx:30
ALFA_LocRec::m_fOverlapCutMD
Float_t m_fOverlapCutMD
Definition: ALFA_LocRec.h:72
ALFAPLATESCNT
#define ALFAPLATESCNT
Definition: ALFA_constants.h:9
_ODHIT::iEvent
int iEvent
Definition: ALFA_LocRec/ALFA_UserObjects.h:14
_ODHIT
Definition: ALFA_LocRec/ALFA_UserObjects.h:13
ALFA_LocRec::RecordCollection
StatusCode RecordCollection()
Definition: ALFA_LocRec.cxx:1018
ALFA_LocRec::m_iMultiplicityCutMD
Int_t m_iMultiplicityCutMD
Definition: ALFA_LocRec.h:67
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
ALFA_LocRec::m_fzOD
Float_t m_fzOD[RPOTSCNT][ODPLATESCNT][ODSIDESCNT][ODLAYERSCNT *ODFIBERSCNT]
Definition: ALFA_LocRec.h:86
ALFA_ODTracking.h
ALFA_LocRec::m_iDataType
Int_t m_iDataType
Definition: ALFA_LocRec.h:65
ALFA_ODDigitCollection
Definition: ALFA_ODDigitCollection.h:15
Generated on Fri Oct 31 2025 21:06:18 for ATLAS Offline Software by   doxygen 1.8.18