ATLAS Offline Software
Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
ALFA_LocRec Class Reference

#include <ALFA_LocRec.h>

Inheritance diagram for ALFA_LocRec:
Collaboration diagram for ALFA_LocRec:

Public Member Functions

 ALFA_LocRec (const std::string &name, ISvcLocator *pSvcLocator)
 
 ~ALFA_LocRec ()
 
StatusCode initialize ()
 
StatusCode execute ()
 
StatusCode finalize ()
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

bool ReadGeometryDetCS ()
 
bool StoreReconstructionGeometry (const eRPotName eRPName, const eFiberType eFType, const char *szDataDestination)
 
void SaveGeometry ()
 
void ClearGeometry ()
 
StatusCode ALFACollectionReading (std::list< MDHIT > &ListMDHits, std::list< ODHIT > &ListODHits)
 
StatusCode RecordCollection ()
 
StatusCode RecordODCollection ()
 
StatusCode ExecuteRecoMethod (const std::string &strAlgo, const eRPotName eRPName, const std::list< MDHIT > &ListMDHits, const std::list< ODHIT > &ListODHits)
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

GEOMETRYCONFIGURATION m_Config
 
ALFA_GeometryReader * m_pGeometryReader
 
ALFA_LocRecEvCollection * m_pLocRecEvCollection
 
ALFA_LocRecEvent * m_pLocRecEvent
 
ALFA_LocRecODEvCollection * m_pLocRecODEvCollection
 
ALFA_LocRecODEvent * m_pLocRecODEvent
 
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey {this, "EvtInfo", "EventInfo", "EventInfo name"}
 
std::list< eRPotName > m_ListExistingRPots
 
UInt_t m_eventNum
 
Int_t m_iDataType
 
Int_t m_iEvent
 
Int_t m_iMultiplicityCutMD
 
Int_t m_iNumLayerCutMD
 
Int_t m_iUVCutMD
 
Int_t m_iUVCutMDHalfReco
 
Int_t m_iMultiplicityCutOD
 
Float_t m_fOverlapCutMD
 
Float_t m_fDistanceCutOD
 
Float_t m_iLayerCutOD
 
Bool_t m_bEdgeMethod_Opt_Sisters
 
Bool_t m_bEdgeMethod_Opt_UseGaps
 
Float_t m_faMD [RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT]
 
Float_t m_fbMD [RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT]
 
Float_t m_fzMD [RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT]
 
Float_t m_faOD [RPOTSCNT][ODPLATESCNT][ODSIDESCNT][ODLAYERSCNT *ODFIBERSCNT]
 
Float_t m_fbOD [RPOTSCNT][ODPLATESCNT][ODSIDESCNT][ODLAYERSCNT *ODFIBERSCNT]
 
Float_t m_fzOD [RPOTSCNT][ODPLATESCNT][ODSIDESCNT][ODLAYERSCNT *ODFIBERSCNT]
 
std::string m_strKeyGeometryForReco
 
std::vector< std::string > m_vecListAlgoMD
 
std::vector< std::string > m_vecListAlgoOD
 
std::string m_strAlgoOD
 
std::string m_strAlgoMD
 
std::string m_strKeyLocRecEvCollection
 
std::string m_strKeyLocRecODEvCollection
 
std::string m_strCollectionName
 
std::string m_strODCollectionName
 
DataObjIDColl m_extendedExtraObjects
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Definition at line 43 of file ALFA_LocRec.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ ALFA_LocRec()

ALFA_LocRec::ALFA_LocRec ( const std::string &  name,
ISvcLocator *  pSvcLocator 
)

Definition at line 24 of file ALFA_LocRec.cxx.

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

◆ ~ALFA_LocRec()

ALFA_LocRec::~ALFA_LocRec ( )

Definition at line 143 of file ALFA_LocRec.cxx.

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 }

Member Function Documentation

◆ ALFACollectionReading()

StatusCode ALFA_LocRec::ALFACollectionReading ( std::list< MDHIT > &  ListMDHits,
std::list< ODHIT > &  ListODHits 
)
private

Definition at line 361 of file ALFA_LocRec.cxx.

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 }

◆ ClearGeometry()

void ALFA_LocRec::ClearGeometry ( )
private

Definition at line 347 of file ALFA_LocRec.cxx.

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 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  hndl,
const SG::VarHandleKeyArrayType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  hndl,
const SG::VarHandleKeyType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  hndl,
const SG::VarHandleType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  t,
const SG::NotHandleType &   
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode ALFA_LocRec::execute ( )

Definition at line 211 of file ALFA_LocRec.cxx.

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 }

◆ ExecuteRecoMethod()

StatusCode ALFA_LocRec::ExecuteRecoMethod ( const std::string &  strAlgo,
const eRPotName  eRPName,
const std::list< MDHIT > &  ListMDHits,
const std::list< ODHIT > &  ListODHits 
)
private

Definition at line 677 of file ALFA_LocRec.cxx.

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 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

51 {
52  // If we didn't find any symlinks to add, just return the collection
53  // from the base class. Otherwise, return the extended collection.
54  if (!m_extendedExtraObjects.empty()) {
55  return m_extendedExtraObjects;
56  }
57  return Algorithm::extraOutputDeps();
58 }

◆ finalize()

StatusCode ALFA_LocRec::finalize ( )

Definition at line 337 of file ALFA_LocRec.cxx.

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 }

◆ initialize()

StatusCode ALFA_LocRec::initialize ( )

Definition at line 156 of file ALFA_LocRec.cxx.

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 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ msg() [1/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ ReadGeometryDetCS()

bool ALFA_LocRec::ReadGeometryDetCS ( )
private

Definition at line 421 of file ALFA_LocRec.cxx.

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 }

◆ RecordCollection()

StatusCode ALFA_LocRec::RecordCollection ( )
private

Definition at line 1018 of file ALFA_LocRec.cxx.

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 }

◆ RecordODCollection()

StatusCode ALFA_LocRec::RecordODCollection ( )
private

Definition at line 1042 of file ALFA_LocRec.cxx.

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 }

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ SaveGeometry()

void ALFA_LocRec::SaveGeometry ( )
private

Definition at line 614 of file ALFA_LocRec.cxx.

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 }

◆ StoreReconstructionGeometry()

bool ALFA_LocRec::StoreReconstructionGeometry ( const eRPotName  eRPName,
const eFiberType  eFType,
const char *  szDataDestination 
)
private

Definition at line 563 of file ALFA_LocRec.cxx.

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 }

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, PyAthena::Alg, and AthHistogramAlgorithm.

Definition at line 66 of file AthAlgorithm.cxx.

66  {
67  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
68 
69  if (sc.isFailure()) {
70  return sc;
71  }
72  ServiceHandle<ICondSvc> cs("CondSvc",name());
73  for (auto h : outputHandles()) {
74  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
75  // do this inside the loop so we don't create the CondSvc until needed
76  if ( cs.retrieve().isFailure() ) {
77  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
78  return StatusCode::SUCCESS;
79  }
80  if (cs->regHandle(this,*h).isFailure()) {
81  sc = StatusCode::FAILURE;
82  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
83  << " with CondSvc");
84  }
85  }
86  }
87  return sc;
88 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_bEdgeMethod_Opt_Sisters

Bool_t ALFA_LocRec::m_bEdgeMethod_Opt_Sisters
private

Definition at line 75 of file ALFA_LocRec.h.

◆ m_bEdgeMethod_Opt_UseGaps

Bool_t ALFA_LocRec::m_bEdgeMethod_Opt_UseGaps
private

Definition at line 76 of file ALFA_LocRec.h.

◆ m_Config

GEOMETRYCONFIGURATION ALFA_LocRec::m_Config
private

Definition at line 50 of file ALFA_LocRec.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> ALFA_LocRec::m_eventInfoKey {this, "EvtInfo", "EventInfo", "EventInfo name"}
private

Definition at line 59 of file ALFA_LocRec.h.

◆ m_eventNum

UInt_t ALFA_LocRec::m_eventNum
private

Definition at line 64 of file ALFA_LocRec.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects
privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_faMD

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

Definition at line 79 of file ALFA_LocRec.h.

◆ m_faOD

Float_t ALFA_LocRec::m_faOD[RPOTSCNT][ODPLATESCNT][ODSIDESCNT][ODLAYERSCNT *ODFIBERSCNT]
private

Definition at line 84 of file ALFA_LocRec.h.

◆ m_fbMD

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

Definition at line 80 of file ALFA_LocRec.h.

◆ m_fbOD

Float_t ALFA_LocRec::m_fbOD[RPOTSCNT][ODPLATESCNT][ODSIDESCNT][ODLAYERSCNT *ODFIBERSCNT]
private

Definition at line 85 of file ALFA_LocRec.h.

◆ m_fDistanceCutOD

Float_t ALFA_LocRec::m_fDistanceCutOD
private

Definition at line 73 of file ALFA_LocRec.h.

◆ m_fOverlapCutMD

Float_t ALFA_LocRec::m_fOverlapCutMD
private

Definition at line 72 of file ALFA_LocRec.h.

◆ m_fzMD

Float_t ALFA_LocRec::m_fzMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT]
private

Definition at line 81 of file ALFA_LocRec.h.

◆ m_fzOD

Float_t ALFA_LocRec::m_fzOD[RPOTSCNT][ODPLATESCNT][ODSIDESCNT][ODLAYERSCNT *ODFIBERSCNT]
private

Definition at line 86 of file ALFA_LocRec.h.

◆ m_iDataType

Int_t ALFA_LocRec::m_iDataType
private

Definition at line 65 of file ALFA_LocRec.h.

◆ m_iEvent

Int_t ALFA_LocRec::m_iEvent
private

Definition at line 66 of file ALFA_LocRec.h.

◆ m_iLayerCutOD

Float_t ALFA_LocRec::m_iLayerCutOD
private

Definition at line 74 of file ALFA_LocRec.h.

◆ m_iMultiplicityCutMD

Int_t ALFA_LocRec::m_iMultiplicityCutMD
private

Definition at line 67 of file ALFA_LocRec.h.

◆ m_iMultiplicityCutOD

Int_t ALFA_LocRec::m_iMultiplicityCutOD
private

Definition at line 71 of file ALFA_LocRec.h.

◆ m_iNumLayerCutMD

Int_t ALFA_LocRec::m_iNumLayerCutMD
private

Definition at line 68 of file ALFA_LocRec.h.

◆ m_iUVCutMD

Int_t ALFA_LocRec::m_iUVCutMD
private

Definition at line 69 of file ALFA_LocRec.h.

◆ m_iUVCutMDHalfReco

Int_t ALFA_LocRec::m_iUVCutMDHalfReco
private

Definition at line 70 of file ALFA_LocRec.h.

◆ m_ListExistingRPots

std::list<eRPotName> ALFA_LocRec::m_ListExistingRPots
private

Definition at line 62 of file ALFA_LocRec.h.

◆ m_pGeometryReader

ALFA_GeometryReader* ALFA_LocRec::m_pGeometryReader
private

Definition at line 51 of file ALFA_LocRec.h.

◆ m_pLocRecEvCollection

ALFA_LocRecEvCollection* ALFA_LocRec::m_pLocRecEvCollection
private

Definition at line 53 of file ALFA_LocRec.h.

◆ m_pLocRecEvent

ALFA_LocRecEvent* ALFA_LocRec::m_pLocRecEvent
private

Definition at line 54 of file ALFA_LocRec.h.

◆ m_pLocRecODEvCollection

ALFA_LocRecODEvCollection* ALFA_LocRec::m_pLocRecODEvCollection
private

Definition at line 56 of file ALFA_LocRec.h.

◆ m_pLocRecODEvent

ALFA_LocRecODEvent* ALFA_LocRec::m_pLocRecODEvent
private

Definition at line 57 of file ALFA_LocRec.h.

◆ m_strAlgoMD

std::string ALFA_LocRec::m_strAlgoMD
private

Definition at line 92 of file ALFA_LocRec.h.

◆ m_strAlgoOD

std::string ALFA_LocRec::m_strAlgoOD
private

Definition at line 91 of file ALFA_LocRec.h.

◆ m_strCollectionName

std::string ALFA_LocRec::m_strCollectionName
private

Definition at line 95 of file ALFA_LocRec.h.

◆ m_strKeyGeometryForReco

std::string ALFA_LocRec::m_strKeyGeometryForReco
private

Definition at line 88 of file ALFA_LocRec.h.

◆ m_strKeyLocRecEvCollection

std::string ALFA_LocRec::m_strKeyLocRecEvCollection
private

Definition at line 93 of file ALFA_LocRec.h.

◆ m_strKeyLocRecODEvCollection

std::string ALFA_LocRec::m_strKeyLocRecODEvCollection
private

Definition at line 94 of file ALFA_LocRec.h.

◆ m_strODCollectionName

std::string ALFA_LocRec::m_strODCollectionName
private

Definition at line 96 of file ALFA_LocRec.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vecListAlgoMD

std::vector<std::string> ALFA_LocRec::m_vecListAlgoMD
private

Definition at line 89 of file ALFA_LocRec.h.

◆ m_vecListAlgoOD

std::vector<std::string> ALFA_LocRec::m_vecListAlgoOD
private

Definition at line 90 of file ALFA_LocRec.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
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
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_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
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
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
EGST_IDEALGEOMETRY
@ EGST_IDEALGEOMETRY
Definition: ALFA_GeometryReader.h:23
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::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
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
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
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
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
FIBERPARAMS
Definition: ALFA_GeometryReader.h:98
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
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
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
ALFA_ODTracking
Definition: ALFA_ODTracking.h:23
ALFA_LocRecODEvCollection
Definition: ALFA_LocRecODEvCollection.h:13
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
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
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
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
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
ALFA_LocRec::m_vecListAlgoMD
std::vector< std::string > m_vecListAlgoMD
Definition: ALFA_LocRec.h:89
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
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
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
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_MDOverlap::GetData
void GetData(Int_t(&iFibSel)[ALFALAYERSCNT *ALFAPLATESCNT])
Definition: ALFA_MDOverlap.cxx:439
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_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
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
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
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
ALFALAYERSCNT
#define ALFALAYERSCNT
Definition: ALFA_constants.h:8
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
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
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
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
ALFA_LocRec::m_faOD
Float_t m_faOD[RPOTSCNT][ODPLATESCNT][ODSIDESCNT][ODLAYERSCNT *ODFIBERSCNT]
Definition: ALFA_LocRec.h:84
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
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
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
ODPLATESCNT
#define ODPLATESCNT
Definition: ALFA_CLinkAlg.h:31
ALFA_GeometryReader::GetUFiberParams
bool GetUFiberParams(PFIBERPARAMS pFiberParams, const eRPotName eRPName, const int nPlateID, const int nFiberID)
Definition: ALFA_GeometryReader.cxx:1311
a
TList * a
Definition: liststreamerinfos.cxx:10
h
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
_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
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
GEOMETRYCONFIGURATION::bShiftToX97Pos
bool bShiftToX97Pos
Definition: ALFA_GeometryReader.h:199
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
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
_ODHIT::iSide
int iSide
Definition: ALFA_LocRec/ALFA_UserObjects.h:17
EFT_ODFIBERV1
@ EFT_ODFIBERV1
Definition: ALFA_GeometryReader.h:25
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
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
fitman.k
k
Definition: fitman.py:528
ServiceHandle< ICondSvc >
ALFA_LocRec::m_iDataType
Int_t m_iDataType
Definition: ALFA_LocRec.h:65
ALFA_ODDigitCollection
Definition: ALFA_ODDigitCollection.h:15
Generated on Wed Oct 29 2025 21:26:53 for ATLAS Offline Software by   doxygen 1.8.18