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 > &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 > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &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 79 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 11 of file ALFA_LocRec.cxx.

11  :
12  AthAlgorithm(name, pSvcLocator)
13 {
14  ATH_MSG_DEBUG("begin ALFA_LocRec::ALFA_LocRec");
15 
16  m_pGeometryReader = new ALFA_GeometryReader();
17 
18 // m_Config.eOwner=EOT_RECO;
19  m_Config.clear();
20 
21  //begin of Geometry properties
22  declareProperty("MetrologyType",m_Config.eRPMetrologyGeoType=EMT_NOMINAL);//EGST_FILE
23  declareProperty("MetrologySource",m_Config.strRPMetrologyConnString=std::string(""));//"rpmetrology.dat"
24  declareProperty("ShiftToX97Pos",m_Config.bShiftToX97Pos=false);
25 
26  declareProperty("B7L1U_PosType",m_Config.CfgRPosParams[0].eRPPosType=ERPPT_ACTIVE);
27  declareProperty("B7L1U_MDGeometryType",m_Config.CfgRPosParams[0].eMDGeoType=EGST_IDEALGEOMETRY);
28  declareProperty("B7L1U_ODGeometryType",m_Config.CfgRPosParams[0].eODGeoType=EGST_IDEALGEOMETRY);
29  declareProperty("B7L1U_MDSource",m_Config.CfgRPosParams[0].strMDConnString=std::string(""));
30  declareProperty("B7L1U_ODSource",m_Config.CfgRPosParams[0].strODConnString=std::string(""));
31 // declareProperty("B7L1U_CurrentLVDT",m_Config.CfgRPosParams[0].fCurrentLVDTmm=7.0*CLHEP::mm);
32 
33  declareProperty("B7L1L_PosType",m_Config.CfgRPosParams[1].eRPPosType=ERPPT_ACTIVE);
34  declareProperty("B7L1L_MDGeometryType",m_Config.CfgRPosParams[1].eMDGeoType=EGST_IDEALGEOMETRY);
35  declareProperty("B7L1L_ODGeometryType",m_Config.CfgRPosParams[1].eODGeoType=EGST_IDEALGEOMETRY);
36  declareProperty("B7L1L_MDSource",m_Config.CfgRPosParams[1].strMDConnString=std::string(""));
37  declareProperty("B7L1L_ODSource",m_Config.CfgRPosParams[1].strODConnString=std::string(""));
38 // declareProperty("B7L1L_CurrentLVDT",m_Config.CfgRPosParams[1].fCurrentLVDTmm=7.0*CLHEP::mm);
39 
40  declareProperty("A7L1U_PosType",m_Config.CfgRPosParams[2].eRPPosType=ERPPT_ACTIVE);
41  declareProperty("A7L1U_MDGeometryType",m_Config.CfgRPosParams[2].eMDGeoType=EGST_IDEALGEOMETRY);
42  declareProperty("A7L1U_ODGeometryType",m_Config.CfgRPosParams[2].eODGeoType=EGST_IDEALGEOMETRY);
43  declareProperty("A7L1U_MDSource",m_Config.CfgRPosParams[2].strMDConnString=std::string(""));
44  declareProperty("A7L1U_ODSource",m_Config.CfgRPosParams[2].strODConnString=std::string(""));
45 // declareProperty("A7L1U_CurrentLVDT",m_Config.CfgRPosParams[2].fCurrentLVDTmm=7.0*CLHEP::mm);
46 
47  declareProperty("A7L1L_PosType",m_Config.CfgRPosParams[3].eRPPosType=ERPPT_ACTIVE);
48  declareProperty("A7L1L_MDGeometryType",m_Config.CfgRPosParams[3].eMDGeoType=EGST_IDEALGEOMETRY);
49  declareProperty("A7L1L_ODGeometryType",m_Config.CfgRPosParams[3].eODGeoType=EGST_IDEALGEOMETRY);
50  declareProperty("A7L1L_MDSource",m_Config.CfgRPosParams[3].strMDConnString=std::string(""));
51  declareProperty("A7L1L_ODSource",m_Config.CfgRPosParams[3].strODConnString=std::string(""));
52 // declareProperty("A7L1L_CurrentLVDT",m_Config.CfgRPosParams[3].fCurrentLVDTmm=7.0*CLHEP::mm);
53 
54  declareProperty("A7R1U_PosType",m_Config.CfgRPosParams[4].eRPPosType=ERPPT_ACTIVE);
55  declareProperty("A7R1U_MDGeometryType",m_Config.CfgRPosParams[4].eMDGeoType=EGST_IDEALGEOMETRY);
56  declareProperty("A7R1U_ODGeometryType",m_Config.CfgRPosParams[4].eODGeoType=EGST_IDEALGEOMETRY);
57  declareProperty("A7R1U_MDSource",m_Config.CfgRPosParams[4].strMDConnString=std::string(""));
58  declareProperty("A7R1U_ODSource",m_Config.CfgRPosParams[4].strODConnString=std::string(""));
59 // declareProperty("A7R1U_CurrentLVDT",m_Config.CfgRPosParams[4].fCurrentLVDTmm=7.0*CLHEP::mm);
60 
61  declareProperty("A7R1L_PosType",m_Config.CfgRPosParams[5].eRPPosType=ERPPT_ACTIVE);
62  declareProperty("A7R1L_MDGeometryType",m_Config.CfgRPosParams[5].eMDGeoType=EGST_IDEALGEOMETRY);
63  declareProperty("A7R1L_ODGeometryType",m_Config.CfgRPosParams[5].eODGeoType=EGST_IDEALGEOMETRY);
64  declareProperty("A7R1L_MDSource",m_Config.CfgRPosParams[5].strMDConnString=std::string(""));
65  declareProperty("A7R1L_ODSource",m_Config.CfgRPosParams[5].strODConnString=std::string(""));
66 // declareProperty("A7L1U_CurrentLVDT",m_Config.CfgRPosParams[5].fCurrentLVDTmm=7.0*CLHEP::mm);
67 
68  declareProperty("B7R1U_PosType",m_Config.CfgRPosParams[6].eRPPosType=ERPPT_ACTIVE);
69  declareProperty("B7R1U_MDGeometryType",m_Config.CfgRPosParams[6].eMDGeoType=EGST_IDEALGEOMETRY);
70  declareProperty("B7R1U_ODGeometryType",m_Config.CfgRPosParams[6].eODGeoType=EGST_IDEALGEOMETRY);
71  declareProperty("B7R1U_MDSource",m_Config.CfgRPosParams[6].strMDConnString=std::string(""));
72  declareProperty("B7R1U_ODSource",m_Config.CfgRPosParams[6].strODConnString=std::string(""));
73 // declareProperty("B7R1U_CurrentLVDT",m_Config.CfgRPosParams[6].fCurrentLVDTmm=7.0*CLHEP::mm);
74 
75  declareProperty("B7R1L_PosType",m_Config.CfgRPosParams[7].eRPPosType=ERPPT_ACTIVE);
76  declareProperty("B7R1L_MDGeometryType",m_Config.CfgRPosParams[7].eMDGeoType=EGST_IDEALGEOMETRY);
77  declareProperty("B7R1L_ODGeometryType",m_Config.CfgRPosParams[7].eODGeoType=EGST_IDEALGEOMETRY);
78  declareProperty("B7R1L_MDSource",m_Config.CfgRPosParams[7].strMDConnString=std::string(""));
79  declareProperty("B7R1L_ODSource",m_Config.CfgRPosParams[7].strODConnString=std::string(""));
80 // declareProperty("B7R1L_CurrentLVDT",m_Config.CfgRPosParams[7].fCurrentLVDTmm=7.0*CLHEP::mm);
81  //end of Geometry properties
82 
83  // data type using in the local reconstruction
84  // for the simulation data the value is 0, for the real data the value is 1. Unset value is -1
85  declareProperty("DataType", m_iDataType=1, "data type using in the local reconstruction");
86 
87  //reconstruction methods properties - MDTracking, MDMultiple, ODTracking
88  declareProperty("MultiplicityCutOD", m_iMultiplicityCutOD=30);
89  declareProperty("DistanceCutOD", m_fDistanceCutOD=0.5);
90  declareProperty("LayerCutOD", m_iLayerCutOD=3);
91 
92  declareProperty("OverlapCutMD", m_fOverlapCutMD=0.5);
93  declareProperty("MultiplicityCutMD", m_iMultiplicityCutMD=5);
94  declareProperty("NumLayerCutMD", m_iNumLayerCutMD=3);
95  declareProperty("UVCutMD", m_iUVCutMD=3);
96  declareProperty("UVCutMDHalfReco", m_iUVCutMDHalfReco=3);
97 
98  //reconstruction methods properties - EdgeMethod
99  declareProperty("EdgeMethod_Opt_Sisters", m_bEdgeMethod_Opt_Sisters = false);
100  declareProperty("EdgeMethod_Opt_UseGaps", m_bEdgeMethod_Opt_UseGaps = false);
101 
102  //reconstruction method selection for OD & MD
103  declareProperty("AlgoOD", m_strAlgoOD="ODTracking");
104  declareProperty("AlgoMD", m_strAlgoMD="MDTracking");
105 
106  m_vecListAlgoMD.clear();
107  declareProperty("ListAlgoMD", m_vecListAlgoMD);
108  m_vecListAlgoOD.clear();
109  declareProperty("ListAlgoOD", m_vecListAlgoOD);
110 
111  m_ListExistingRPots.clear();
112 
113  m_strKeyGeometryForReco = "ALFA_GeometryForReco";
114  m_strCollectionName = "ALFA_DigitCollection";
115  m_strODCollectionName = "ALFA_ODDigitCollection";
116  m_strKeyLocRecEvCollection = "ALFA_LocRecEvCollection";
117  m_strKeyLocRecODEvCollection = "ALFA_LocRecODEvCollection";
118 
119  m_pLocRecEvCollection = NULL;
120  m_pLocRecEvent = NULL;
121  m_pLocRecODEvCollection = NULL;
122  m_pLocRecODEvent = NULL;
123 
124  m_eventNum = 0;
125  m_iEvent = 0;
126 
127  ATH_MSG_DEBUG("end ALFA_LocRec::ALFA_LocRec");
128 }

◆ ~ALFA_LocRec()

ALFA_LocRec::~ALFA_LocRec ( )

Definition at line 130 of file ALFA_LocRec.cxx.

131 {
132  ATH_MSG_DEBUG("begin ALFA_LocRec::~ALFA_LocRec");
133 
134 // if(m_pGeometryReader!=NULL)
135 // {
136 // delete m_pGeometryReader;
137 // m_pGeometryReader = NULL;
138 // }
139 
140  ATH_MSG_DEBUG("begin ALFA_LocRec::~ALFA_LocRec");
141 }

Member Function Documentation

◆ ALFACollectionReading()

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

Definition at line 348 of file ALFA_LocRec.cxx.

349 {
350  StatusCode sc;
351 
352  ATH_MSG_DEBUG("begin ALFA_LocRec::ALFACollectionReading()");
353 
354  ODHIT ODHit;
355  MDHIT MDHit;
356 
357  ListMDHits.clear();
358  ListODHits.clear();
359 
360  const ALFA_DigitCollection* mcGen = 0;
361  const ALFA_ODDigitCollection* mcODGen = 0;
362 
363  sc = evtStore()->retrieve(mcGen,m_strCollectionName);
364  if(sc.isFailure() || !mcGen)
365  {
366  return StatusCode::FAILURE;
367  }
368 
369  ALFA_DigitCollection::const_iterator mcGenBeg = mcGen->begin();
370  ALFA_DigitCollection::const_iterator mcGenEnd = mcGen->end();
371 
372  for(;mcGenBeg!=mcGenEnd;++mcGenBeg)
373  {
374  MDHit.iEvent = m_eventNum;
375 
376  MDHit.iRPot = ((*mcGenBeg)->getStation());
377  MDHit.iPlate = ((*mcGenBeg)->getPlate());
378  MDHit.iFiber = ((*mcGenBeg)->getFiber());
379 
380  ListMDHits.push_back(MDHit);
381  }
382 
383  sc = evtStore()->retrieve(mcODGen,m_strODCollectionName);
384  if(sc.isFailure() || !mcODGen)
385  {
386  return StatusCode::FAILURE;
387  }
388 
389  ALFA_ODDigitCollection::const_iterator mcODGenBeg = mcODGen->begin();
390  ALFA_ODDigitCollection::const_iterator mcODGenEnd = mcODGen->end();
391 
392  for(;mcODGenBeg!=mcODGenEnd;++mcODGenBeg)
393  {
394  ODHit.iEvent = m_eventNum;
395  ODHit.iRPot = ((*mcODGenBeg)->getStation());
396  ODHit.iPlate = ((*mcODGenBeg)->getPlate());
397  ODHit.iSide = ((*mcODGenBeg)->getSide());
398  ODHit.iFiber = ((*mcODGenBeg)->getFiber());
399 
400  ListODHits.push_back(ODHit);
401  }
402 
403  ATH_MSG_DEBUG("end ALFA_LocRec::ALFACollectionReading()");
404 
405  return StatusCode::SUCCESS;
406 }

◆ ClearGeometry()

void ALFA_LocRec::ClearGeometry ( )
private

Definition at line 334 of file ALFA_LocRec.cxx.

335 {
336  ATH_MSG_DEBUG("begin ALFA_LocRec::ClearGeometry()");
337 
338  memset(&m_faMD, 0, sizeof(m_faMD));
339  memset(&m_fbMD, 0, sizeof(m_fbMD));
340  memset(&m_fzMD, 0, sizeof(m_fzMD));
341  memset(&m_faOD, 0, sizeof(m_faOD));
342  memset(&m_fbOD, 0, sizeof(m_fbOD));
343  memset(&m_fzOD, 0, sizeof(m_fzOD));
344 
345  ATH_MSG_DEBUG("end ALFA_LocRec::ClearGeometry()");
346 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  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 > &  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 > &  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 > &  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 > &  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 198 of file ALFA_LocRec.cxx.

199 {
200  ATH_MSG_DEBUG("begin ALFA_LocRec::execute()");
201 
202  StatusCode sc;
203  std::list<eRPotName>::const_iterator iterRPName;
204  eRPotName eRPName;
205 
206  std::list<MDHIT> ListMDHits;
207  std::list<ODHIT> ListODHits;
208  ListMDHits.clear();
209  ListODHits.clear();
210 
211  m_eventNum = 0;
212  SG::ReadHandle<xAOD::EventInfo> eventInfo (m_eventInfoKey,getContext());
213  if(!eventInfo.isValid()) {
214  ATH_MSG_ERROR("ALFA_LocRec, Cannot get event info.");
215 // return sc;
216  }
217  else
218  {
219  // current event number
220  m_eventNum = eventInfo->eventNumber();
221  }
222 
223  //************************************************************
224 // if (m_eventNum!=73681035) return StatusCode::SUCCESS;
225  //************************************************************
226 
227  sc = RecordCollection();
228  if (sc.isFailure())
229  {
230  ATH_MSG_ERROR("RecordCollection() failed");
231  return StatusCode::SUCCESS;
232  }
233 
234  sc = RecordODCollection();
235  if (sc.isFailure())
236  {
237  ATH_MSG_ERROR("RecordODCollection() failed");
238  return StatusCode::SUCCESS;
239  }
240 
241  sc = ALFACollectionReading(ListMDHits, ListODHits);
242  if (sc.isFailure())
243  {
244  ATH_MSG_WARNING("ALFA_Collection_Reading Failed");
245 // return StatusCode::SUCCESS;
246  }
247  else
248  {
249  std::string strAlgoMD;
250  for(auto & i : m_vecListAlgoMD)
251  {
252  strAlgoMD = i;
253  for(iterRPName=m_ListExistingRPots.begin();iterRPName!=m_ListExistingRPots.end();++iterRPName)
254  {
255  eRPName = *iterRPName;
256 
257 // cout << "eRPName = " << eRPName << endl;
258  //execute MD algorithm
259  sc = ExecuteRecoMethod(strAlgoMD, eRPName, ListMDHits, ListODHits);
260  if (sc.isFailure())
261  {
262  ATH_MSG_FATAL("Algorithm " << strAlgoMD << " for the pot " << m_pGeometryReader->GetRPotLabel(eRPName) << " failure!");
263  return sc;
264  }
265  }
266  }
267 
268  std::string strAlgoOD;
269  for(auto & i : m_vecListAlgoOD)
270  {
271  strAlgoOD = i;
272  for(iterRPName=m_ListExistingRPots.begin();iterRPName!=m_ListExistingRPots.end();++iterRPName)
273  {
274  eRPName = *iterRPName;
275 
276  // cout << "eRPName = " << eRPName << endl;
277  //execute OD algorithm
278  sc = ExecuteRecoMethod(strAlgoOD, eRPName, ListMDHits, ListODHits);
279  if (sc.isFailure())
280  {
281  ATH_MSG_FATAL("Algorithm " << strAlgoOD << " for the pot " << m_pGeometryReader->GetRPotLabel(eRPName) << " failure!");
282  return sc;
283  }
284  }
285  }
286 
287 
288 
289 
290 // // local reconstruction process for all existing pots, MD & OD
291 // for(iterRPName=m_ListExistingRPots.begin();iterRPName!=m_ListExistingRPots.end();iterRPName++)
292 // {
293 // eRPName = *iterRPName;
294 
295 // //execute MD reconstruction method
296 // if (!m_strAlgoMD.empty())
297 // {
298 // sc = ExecuteRecoMethod(m_strAlgoMD, eRPName, ListMDHits, ListODHits);
299 // if (sc.isFailure())
300 // {
301 // ATH_MSG_ERROR("Algorithm " << m_strAlgoMD << " for pot " << m_pGeometryReader->GetRPotLabel(eRPName) << " failure!");
302 // // return sc;
303 // }
304 // }
305 
306 // //execute OD reconstruction method
307 // if (!m_strAlgoOD.empty())
308 // {
309 // sc = ExecuteRecoMethod(m_strAlgoOD, eRPName, ListMDHits, ListODHits);
310 // if (sc.isFailure())
311 // {
312 // ATH_MSG_ERROR("Algorithm " << m_strAlgoOD << " for pot " << m_pGeometryReader->GetRPotLabel(eRPName) << " failure!");
313 // // return sc;
314 // }
315 // }
316 // }
317  }
318 
319  m_iEvent++;
320  ATH_MSG_DEBUG("end ALFA_LocRec::execute()");
321  return StatusCode::SUCCESS;
322 }

◆ 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 664 of file ALFA_LocRec.cxx.

665 {
666  ATH_MSG_DEBUG("begin ALFA_LocRec::ExecuteRecoMethod()");
667 
668  StatusCode sc = StatusCode::SUCCESS;
669  ODRESULT ODResults;
670  std::list<ODRESULT> listODResults;
671  listODResults.clear();
672  Float_t fRecPosX = -9999.0;
673  Float_t fRecPosY = -9999.0;
674 
675  std::map<string, int> mapRecoMethods;
676  mapRecoMethods.clear();
677  mapRecoMethods.insert(std::pair<string, int>("ODTracking", 1));
678  mapRecoMethods.insert(std::pair<string, int>("MDTracking", 2));
679  mapRecoMethods.insert(std::pair<string, int>("MDOverlap", 3));
680  mapRecoMethods.insert(std::pair<string, int>("CenterGravity", 4));
681  mapRecoMethods.insert(std::pair<string, int>("MDMultiple", 5));
682  mapRecoMethods.insert(std::pair<string, int>("HalfReco", 6));
683  mapRecoMethods.insert(std::pair<string, int>("MDGap", 7));
684  mapRecoMethods.insert(std::pair<string, int>("EdgeMethod", 8));
685 
686  std::vector<int> vecFibSel;
687  vecFibSel.clear();
688 
689  switch(mapRecoMethods[strAlgo])
690  {
691  case 1:
692  {
693  ALFA_ODTracking* pODTracking = new ALFA_ODTracking();
694 
695  sc = pODTracking->Initialize(m_iMultiplicityCutOD, m_fDistanceCutOD, m_iLayerCutOD, m_iDataType);
696  sc = pODTracking->Execute(eRPName-1, ListODHits, m_faOD, m_fbOD);
697  sc = pODTracking->Finalize(&listODResults);
698 
699  std::list<ODRESULT>::const_iterator iter;
700  for(iter=listODResults.begin(); iter!=listODResults.end(); ++iter)
701  {
702  ODResults.iSide = (*iter).iSide;
703  ODResults.fRecPos = (*iter).fRecPos;
704  ODResults.fOverY = (*iter).fOverY;
705  ODResults.iNumY = (*iter).iNumY;
706 
707  if ((ODResults.fRecPos != -9999.0))
708  {
709  Int_t iFibSel[ODSIDESCNT][ODPLATESCNT];
710  std::fill_n(&iFibSel[0][0], sizeof(iFibSel)/sizeof(Int_t), -9999);
711 
712  pODTracking->GetData(iFibSel);
713  vecFibSel.clear();
714  for (int iPlate=0; iPlate<ODPLATESCNT; iPlate++)
715  {
716  vecFibSel.push_back(iFibSel[ODResults.iSide][iPlate]);
717  }
718 
719  m_pLocRecODEvCollection->push_back(new ALFA_LocRecODEvent(1, eRPName-1, ODResults.iSide, ODResults.fRecPos, ODResults.fOverY, ODResults.iNumY, vecFibSel));
720  }
721  }
722 
723  delete pODTracking;
724  break;
725  }
726  case 2:
727  {
728  ALFA_MDTracking* pMDTracking = new ALFA_MDTracking();
729  sc = pMDTracking->Initialize(m_faMD, m_fbMD, m_iMultiplicityCutMD, m_iUVCutMD, m_fOverlapCutMD);
730  sc = pMDTracking->Execute(eRPName-1, ListMDHits);
731  sc = pMDTracking->Finalize(fRecPosX, fRecPosY);
732 
733  if (fRecPosX!=-9999.0 && fRecPosY!=-9999.0)
734  {
735  Int_t iFibSel[ALFALAYERSCNT*ALFAPLATESCNT];
736  Int_t iNumU = 0, iNumV = 0;
737  Float_t fOverlapU = -9999.0, fOverlapV = -9999.0;
738  std::fill_n(&iFibSel[0], sizeof(iFibSel)/sizeof(Int_t), -9999);
739 
740  pMDTracking->GetData(iNumU, iNumV, fOverlapU, fOverlapV, iFibSel);
741  vecFibSel.clear();
742  for (int & iLayer : iFibSel)
743  {
744  vecFibSel.push_back(iLayer);
745  }
746 
747  m_pLocRecEvCollection->push_back(new ALFA_LocRecEvent(2, eRPName-1, fRecPosX, fRecPosY, fOverlapU, fOverlapV, iNumU, iNumV, vecFibSel));
748  }
749 
750  delete pMDTracking;
751  break;
752  }
753  case 3:
754  {
755  ALFA_MDOverlap* pMDOverlap = new ALFA_MDOverlap();
756 
757  sc = pMDOverlap->Initialize(eRPName, ListMDHits, m_faMD, m_fbMD, m_fzMD);
758  sc = pMDOverlap->Execute();
759  sc = pMDOverlap->Finalize(fRecPosX, fRecPosY);
760 
761  Int_t iFibSel[ALFALAYERSCNT*ALFAPLATESCNT];
762  Int_t iNumU = 0, iNumV = 0;
763  Float_t fOverlapU = -9999.0, fOverlapV = -9999.0;
764  std::fill_n(&iFibSel[0], sizeof(iFibSel)/sizeof(Int_t), -9999);
765 
766  pMDOverlap->GetData(iFibSel);
767  if (fRecPosX!=-9999 && fRecPosY!=-9999)
768  {
769  vecFibSel.clear();
770  for (int & iLayer : iFibSel)
771  {
772  vecFibSel.push_back(iLayer);
773  }
774 
775  m_pLocRecEvCollection->push_back(new ALFA_LocRecEvent(3, eRPName-1, fRecPosX, fRecPosY, fOverlapU, fOverlapV, iNumU, iNumV, vecFibSel));
776  }
777 
778  delete pMDOverlap;
779  break;
780  }
781  case 4:
782  {
783  ALFA_CenterGravity* pCenterGravity = new ALFA_CenterGravity();
784 
785  sc = pCenterGravity->Initialize(eRPName, ListMDHits, m_faMD, m_fbMD, m_fzMD);
786  sc = pCenterGravity->Execute();
787  sc = pCenterGravity->Finalize(fRecPosX, fRecPosY);
788 
789  Int_t iFibSel[ALFALAYERSCNT*ALFAPLATESCNT];
790  Int_t iNumU = 0, iNumV = 0;
791  Float_t fOverlapU = -9999.0, fOverlapV = -9999.0;
792  std::fill_n(&iFibSel[0], sizeof(iFibSel)/sizeof(Int_t), -9999);
793 
794  pCenterGravity->GetData(iFibSel);
795  if (fRecPosX!=-9999 && fRecPosY!=-9999)
796  {
797  vecFibSel.clear();
798  for (int & iLayer : iFibSel)
799  {
800  vecFibSel.push_back(iLayer);
801  }
802 
803  m_pLocRecEvCollection->push_back(new ALFA_LocRecEvent(4, eRPName-1, fRecPosX, fRecPosY, fOverlapU, fOverlapV, iNumU, iNumV, vecFibSel));
804  }
805 
806  delete pCenterGravity;
807  break;
808  }
809  case 5:
810  {
811  // MDMultiple algorihm ------------------------------------------------------
812  Float_t fRecPosX[NTRACK];
813  Float_t fRecPosY[NTRACK];
814  ALFA_MDMultiple* pMDMultiple = new ALFA_MDMultiple();
815 
816  sc = pMDMultiple->Initialize(eRPName-1, m_faMD, m_fbMD, m_iMultiplicityCutMD, m_iNumLayerCutMD, m_iUVCutMD, m_fOverlapCutMD);
817  sc = pMDMultiple->Execute(ListMDHits);
818  sc = pMDMultiple->Finalize(fRecPosX, fRecPosY);
819 
820  Int_t iNumU[NTRACK], iNumV[NTRACK], iFibSel[NTRACK][ALFALAYERSCNT*ALFAPLATESCNT];
821  Float_t fOverU[NTRACK], fOverV[NTRACK];
822  std::fill_n(&iFibSel[0][0], sizeof(iFibSel)/sizeof(Int_t), -9999);
823  std::fill_n(&fOverU[0], sizeof(fOverU)/sizeof(Float_t), -9999.0);
824  std::fill_n(&fOverV[0], sizeof(fOverV)/sizeof(Float_t), -9999.0);
825  memset(&iNumU, 0, sizeof(iNumU));
826  memset(&iNumV, 0, sizeof(iNumV));
827 
828  pMDMultiple->GetData(iNumU, iNumV, fOverU, fOverV, iFibSel);
829  for (Int_t iTrack=0; iTrack<NTRACK; iTrack++)
830  {
831  if (fRecPosX[iTrack] != -9999.0 && fRecPosY[iTrack] != -9999.0)
832  {
833  vecFibSel.clear();
834  for (Int_t iLayer=0; iLayer<ALFALAYERSCNT*ALFAPLATESCNT; iLayer++)
835  {
836  vecFibSel.push_back(iFibSel[iTrack][iLayer]);
837  }
838 
839  m_pLocRecEvCollection->push_back(new ALFA_LocRecEvent(5, eRPName-1, fRecPosX[iTrack], fRecPosY[iTrack], fOverU[iTrack], fOverV[iTrack], iNumU[iTrack], iNumV[iTrack], vecFibSel));
840  }
841  }
842 
843  delete pMDMultiple;
844  break;
845  }
846  case 6:
847  {
848  //TODO - cele prepracovat
849  ALFA_HalfReco* pHalfReco = new ALFA_HalfReco();
850 
851  Int_t iNumU[2] = {0, 0};
852  Int_t iNumV[2] = {0, 0};
853  Int_t iHalfFirst=0;
854  Int_t iHalfSecond=1;
855  Float_t fOverlapU[2] = {-9999, -9999};
856  Float_t fOverlapV[2] = {-9999, -9999};
857  Float_t fRecPosX[2] = {-9999, -9999};
858  Float_t fRecPosY[2] = {-9999, -9999};
859 
860  Int_t iFibSel[ALFALAYERSCNT*ALFAPLATESCNT];
861  std::fill_n(&iFibSel[0], sizeof(iFibSel)/sizeof(Int_t), -9999);
862 
863  std::vector<int> vecFibSel0;
864  std::vector<int> vecFibSel1;
865  vecFibSel0.clear();
866  vecFibSel1.clear();
867 
868  if (eRPName==1 || eRPName==3 || eRPName==6 || eRPName==8)
869  {
870  iHalfFirst = 0;
871  iHalfSecond = 1;
872  }
873  else
874  {
875  iHalfFirst = 1;
876  iHalfSecond = 0;
877  }
878 
879  sc = pHalfReco->Initialize(m_faMD, m_fbMD, iHalfFirst, m_iMultiplicityCutMD, m_iUVCutMDHalfReco, m_fOverlapCutMD);
880  sc = pHalfReco->Execute(eRPName-1, ListMDHits);
881  sc = pHalfReco->Finalize(fRecPosX[0], fRecPosY[0]);
882 
883  pHalfReco->GetData(iNumU[0], iNumV[0], fOverlapU[0], fOverlapV[0], iFibSel);
884  vecFibSel0.clear();
885  for (int & iLayer : iFibSel)
886  {
887  vecFibSel0.push_back(iLayer);
888  }
889 
890  sc = pHalfReco->Initialize(m_faMD, m_fbMD, iHalfSecond, m_iMultiplicityCutMD, m_iUVCutMDHalfReco, m_fOverlapCutMD);
891  sc = pHalfReco->Execute(eRPName-1, ListMDHits);
892  sc = pHalfReco->Finalize(fRecPosX[1], fRecPosY[1]);
893 
894  pHalfReco->GetData(iNumU[1], iNumV[1], fOverlapU[1], fOverlapV[1], iFibSel);
895  vecFibSel1.clear();
896  for (int & iLayer : iFibSel)
897  {
898  vecFibSel1.push_back(iLayer);
899  }
900 
901  if (fRecPosX[0]!=-9999.0 && fRecPosY[0]!=-9999.0 && fRecPosX[1]!=-9999.0 && fRecPosY[1]!=-9999.0)
902  {
903  m_pLocRecEvCollection->push_back(new ALFA_LocRecEvent(6, eRPName-1, fRecPosX[0], fRecPosY[0], fOverlapU[0], fOverlapV[0], iNumU[0], iNumV[0], vecFibSel0));
904  m_pLocRecEvCollection->push_back(new ALFA_LocRecEvent(6, eRPName-1, fRecPosX[1], fRecPosY[1], fOverlapU[1], fOverlapV[1], iNumU[1], iNumV[1], vecFibSel1));
905  }
906 
907  delete pHalfReco;
908  break;
909  }
910  case 7:
911  {
912  Float_t fRecPosX[NTRACK];
913  Float_t fRecPosY[NTRACK];
914  ALFA_MDGap* pMDGap = new ALFA_MDGap();
915 
916  sc = pMDGap->Initialize(eRPName-1, m_faMD, m_fbMD, m_iUVCutMD, m_fOverlapCutMD);
917  sc = pMDGap->Execute(ListMDHits);
918  sc = pMDGap->Finalize(fRecPosX, fRecPosY);
919 
920  Int_t iNumU[NTRACK], iNumV[NTRACK];
921  Int_t iFibSel[ALFALAYERSCNT*ALFAPLATESCNT];
922  Float_t fOverU[NTRACK], fOverV[NTRACK];
923 
924  std::fill_n(&iFibSel[0], sizeof(iFibSel)/sizeof(Int_t), -9999);
925  std::fill_n(&fOverU[0], sizeof(fOverU)/sizeof(Float_t), -9999.0);
926  std::fill_n(&fOverV[0], sizeof(fOverV)/sizeof(Float_t), -9999.0);
927 
928  pMDGap->GetData(iNumU, iNumV, fOverU, fOverV, iFibSel);
929  for (Int_t iTrack=0; iTrack<NTRACK; iTrack++)
930  {
931  if (fRecPosX[iTrack] != -9999.0 && fRecPosY[iTrack] != -9999.0)
932  {
933  vecFibSel.clear();
934  for (int & iLayer : iFibSel)
935  {
936  vecFibSel.push_back(iLayer);
937  }
938 
939  m_pLocRecEvCollection->push_back(new ALFA_LocRecEvent(7, eRPName-1, fRecPosX[iTrack], fRecPosY[iTrack], fOverU[iTrack], fOverV[iTrack], iNumU[iTrack], iNumV[iTrack], vecFibSel));
940  }
941  }
942 
943  delete pMDGap;
944  break;
945  }
946  case 8:
947  {
948  Float_t fRecPosX[NTRACK];
949  Float_t fRecPosY[NTRACK];
950  ALFA_EdgeMethod* pEdgeMethod = new ALFA_EdgeMethod(m_bEdgeMethod_Opt_Sisters, m_bEdgeMethod_Opt_UseGaps);
951  pEdgeMethod->Initialize(eRPName-1, m_faMD, m_fbMD, ListMDHits);
952 
953  Int_t iNumU[NTRACK], iNumV[NTRACK];
954  Int_t iFibSel[ALFALAYERSCNT*ALFAPLATESCNT];
955  Float_t fOverU[NTRACK], fOverV[NTRACK];
956 
957  std::fill_n(&iFibSel[0], sizeof(iFibSel)/sizeof(Int_t), -9999);
958  std::fill_n(&fOverU[0], sizeof(fOverU)/sizeof(Float_t), -9999.0);
959  std::fill_n(&fOverV[0], sizeof(fOverV)/sizeof(Float_t), -9999.0);
960 
961 
962  std::vector<ALFA_EdgeMethod::Track> tracks;
963  pEdgeMethod->EdgeMethod(eRPName - 1, tracks);
964 
965  for (UInt_t iTrack=0; iTrack<tracks.size(); iTrack++)
966  {
967  pEdgeMethod->selectedFibers(eRPName - 1, tracks.at(iTrack), iFibSel);
968 
969  iNumU[iTrack] = tracks.at(iTrack).first.second;
970  iNumV[iTrack] = tracks.at(iTrack).second.second;
971  fOverU[iTrack] = tracks.at(iTrack).first.first.second;
972  fOverV[iTrack] = tracks.at(iTrack).second.first.second;
973  fRecPosX[iTrack] = 0.5*TMath::Sqrt2()*(-tracks.at(iTrack).first.first.first-tracks.at(iTrack).second.first.first);
974  fRecPosY[iTrack] = 0.5*TMath::Sqrt2()*(-tracks.at(iTrack).first.first.first+tracks.at(iTrack).second.first.first);
975 
976  if (fRecPosX[iTrack] != -9999.0 && fRecPosY[iTrack] != -9999.0)
977  {
978  vecFibSel.clear();
979  for (int & iLayer : iFibSel)
980  {
981  vecFibSel.push_back(iLayer);
982  }
983 
984  m_pLocRecEvCollection->push_back(new ALFA_LocRecEvent(8, eRPName-1, fRecPosX[iTrack], fRecPosY[iTrack], fOverU[iTrack], fOverV[iTrack], iNumU[iTrack], iNumV[iTrack], vecFibSel));
985  }
986  }
987 
988  delete pEdgeMethod;
989  sc = StatusCode::SUCCESS;
990  break;
991  }
992  default:
993  {
994  ATH_MSG_ERROR("Unable to recognize selected algorithm");
995  std::cout << "strAlgo: " << strAlgo << std::endl;
996  return StatusCode::SUCCESS;
997  }
998  }
999 
1000  ATH_MSG_DEBUG("end ALFA_LocRec::ExecuteRecoMethod()");
1001 
1002  return sc;
1003 }

◆ 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 324 of file ALFA_LocRec.cxx.

325 {
326  ATH_MSG_DEBUG("begin ALFA_LocRec::finalize()");
327 
328 
329 
330  ATH_MSG_DEBUG("end ALFA_LocRec::finalize()");
331  return StatusCode::SUCCESS;
332 }

◆ initialize()

StatusCode ALFA_LocRec::initialize ( )

Definition at line 143 of file ALFA_LocRec.cxx.

144 {
145  ATH_MSG_DEBUG("begin ALFA_LocRec::initialize()");
146 
147  StatusCode sc;
148  ClearGeometry();
149 
150 // sc = service("StoreGateSvc",m_storeGate);
151 // if(sc.isFailure())
152 // {
153 // ATH_MSG_ERROR("reconstruction: unable to retrieve pointer to StoreGateSvc");
154 // return sc;
155 // }
156 
157  //read geometry
158  if(ReadGeometryDetCS())
159  {
160  ATH_MSG_DEBUG("Geometry loaded successfully");
161  }
162  else
163  {
164  ATH_MSG_FATAL("Could not load geometry");
165  return StatusCode::FAILURE;
166  }
167 
168  //write ALFA_GeometryReader to StoreGate
169 // if (StatusCode::SUCCESS!=service("DetectorStore",m_pDetStore))
170 // {
171 // ATH_MSG_ERROR("Detector store not found");
172 // return StatusCode::FAILURE;
173 // }
174  sc = detStore()->record(m_pGeometryReader, m_strKeyGeometryForReco);
175  if(sc.isFailure())
176  {
177  ATH_MSG_ERROR("m_pGeometryReader: unable to record to StoreGate");
178  return sc;
179  }
180 
181 // if (!detStore()->contains<ALFA_GeometryReader>(m_strKeyGeometryForReco))
182 // {
183 // ATH_MSG_ERROR("m_pGeometryReader is not in StoreGate");
184 // }
185 // else
186 // {
187 // ATH_MSG_DEBUG("m_pGeometryReader is in StoreGate");
188 // }
189 
190  ATH_CHECK(m_eventInfoKey.initialize());
191 
192  m_iEvent = 0;
193 
194  ATH_MSG_DEBUG("end ALFA_LocRec::initialize()");
195  return StatusCode::SUCCESS;
196 }

◆ 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 408 of file ALFA_LocRec.cxx.

409 {
410  ATH_MSG_DEBUG("begin ALFA_LocRec::ReadGeometryDetCS()");
411 
412  Int_t nPlateID, nFiberID;
413  FIBERPARAMS FiberParams;
414  eRPotName eRPName;
415 
416  bool bRes=false;
417  std::list<eRPotName>::const_iterator iterRPName;
418 
419  if((bRes=m_pGeometryReader->Initialize(&m_Config,EFCS_ATLAS))==true)
420  {
421  ATH_MSG_DEBUG("Geometry successfully initialized");
422  m_pGeometryReader->GetListOfExistingRPotIDs(&m_ListExistingRPots);
423  }
424  else
425  {
426  ATH_MSG_FATAL("Cannot initialize geometry");
427  return bRes;
428  }
429 
430  for(iterRPName=m_ListExistingRPots.begin();iterRPName!=m_ListExistingRPots.end();++iterRPName)
431  {
432  eRPName = *iterRPName;
433 
434  //for MD-fibers
435  for (nPlateID = 0; nPlateID < ALFAPLATESCNT; nPlateID++)
436  {
437  for (nFiberID = 0; nFiberID < ALFAFIBERSCNT; nFiberID++)
438  {
439  //for V-fibers
440  if (m_pGeometryReader->GetVFiberParams(&FiberParams, eRPName, nPlateID+1, nFiberID+1))
441  {
442  m_faMD[eRPName-1][2*nPlateID+1][nFiberID] = FiberParams.fSlope;
443  m_fbMD[eRPName-1][2*nPlateID+1][nFiberID] = FiberParams.fOffset;
444  m_fzMD[eRPName-1][2*nPlateID+1][nFiberID] = FiberParams.fZPos;
445  }
446  else
447  {
448  ATH_MSG_ERROR("Unable to get FiberV parameters");
449  return false;
450  }
451 
452  //for U-fibers
453  if (m_pGeometryReader->GetUFiberParams(&FiberParams, eRPName, nPlateID+1, nFiberID+1))
454  {
455  m_faMD[eRPName-1][2*nPlateID][nFiberID] = FiberParams.fSlope;
456  m_fbMD[eRPName-1][2*nPlateID][nFiberID] = FiberParams.fOffset;
457  m_fzMD[eRPName-1][2*nPlateID][nFiberID] = FiberParams.fZPos;
458  }
459  else
460  {
461  ATH_MSG_ERROR("Unable to get FiberU parameters");
462  return false;
463  }
464  }
465  }
466 
467  //m_ODfiber = (m_ODside==0)? m_ODfiber : 29-m_ODfiber;
468  //for OD-fibers
469  for (nPlateID = 0; nPlateID < ODPLATESCNT; nPlateID++)
470  {
471  for (nFiberID = 0; nFiberID < ODFIBERSCNT; nFiberID++)
472  {
473  //(+16 because U0-nFiberID is indexed from 16 to 30 in Geometry package)
474  if (m_pGeometryReader->GetODFiberParams(&FiberParams, EFT_ODFIBERU0, eRPName, nPlateID+1, nFiberID+16))
475  {
476  m_faOD[eRPName-1][nPlateID][0][nFiberID+15] = FiberParams.fSlope;
477  m_fbOD[eRPName-1][nPlateID][0][nFiberID+15] = FiberParams.fOffset;
478  m_fzOD[eRPName-1][nPlateID][0][nFiberID+15] = FiberParams.fZPos;
479  }
480  else
481  {
482  ATH_MSG_ERROR("Unable to get ODFiberU0 parameters");
483  return false;
484  }
485 
486  if (m_pGeometryReader->GetODFiberParams(&FiberParams, EFT_ODFIBERV0, eRPName, nPlateID+1, nFiberID+1))
487  {
488  m_faOD[eRPName-1][nPlateID][0][nFiberID] = FiberParams.fSlope;
489  m_fbOD[eRPName-1][nPlateID][0][nFiberID] = FiberParams.fOffset;
490  m_fzOD[eRPName-1][nPlateID][0][nFiberID] = FiberParams.fZPos;
491  }
492  else
493  {
494  ATH_MSG_ERROR("Unable to get ODFiberV0 parameters");
495  return false;
496  }
497 
498  if (m_pGeometryReader->GetODFiberParams(&FiberParams, EFT_ODFIBERU1, eRPName, nPlateID+1, nFiberID+16))
499  {
500  if (m_iDataType==1) //for the tunnel and testbeam data
501  {
502  m_faOD[eRPName-1][nPlateID][1][14-nFiberID] = FiberParams.fSlope;
503  m_fbOD[eRPName-1][nPlateID][1][14-nFiberID] = FiberParams.fOffset;
504  m_fzOD[eRPName-1][nPlateID][1][14-nFiberID] = FiberParams.fZPos;
505  }
506  else //simulation
507  {
508  m_faOD[eRPName-1][nPlateID][1][nFiberID+15] = FiberParams.fSlope;
509  m_fbOD[eRPName-1][nPlateID][1][nFiberID+15] = FiberParams.fOffset;
510  m_fzOD[eRPName-1][nPlateID][1][nFiberID+15] = FiberParams.fZPos;
511  }
512  }
513  else
514  {
515  ATH_MSG_ERROR("Unable to get ODFiberU1 parameters");
516  return false;
517  }
518  //(+16 because V1-nFiberID is indexed from 16 to 30 in Geometry package)
519  if (m_pGeometryReader->GetODFiberParams(&FiberParams, EFT_ODFIBERV1, eRPName, nPlateID+1, nFiberID+1))
520  {
521  if (m_iDataType==1) //for the tunnel and testbeam data
522  {
523  m_faOD[eRPName-1][nPlateID][1][29-nFiberID] = FiberParams.fSlope;
524  m_fbOD[eRPName-1][nPlateID][1][29-nFiberID] = FiberParams.fOffset;
525  m_fzOD[eRPName-1][nPlateID][1][29-nFiberID] = FiberParams.fZPos;
526  }
527  else //simulation
528  {
529  m_faOD[eRPName-1][nPlateID][1][nFiberID] = FiberParams.fSlope;
530  m_fbOD[eRPName-1][nPlateID][1][nFiberID] = FiberParams.fOffset;
531  m_fzOD[eRPName-1][nPlateID][1][nFiberID] = FiberParams.fZPos;
532  }
533  }
534  else
535  {
536  ATH_MSG_ERROR("Unable to get ODFiberV1 parameters");
537  return false;
538  }
539  }
540  }
541  }
542 
543 // SaveGeometry();
544 
545  ATH_MSG_DEBUG("end ALFA_LocRec::ReadGeometryDetCS()");
546 
547  return bRes;
548 }

◆ RecordCollection()

StatusCode ALFA_LocRec::RecordCollection ( )
private

Definition at line 1005 of file ALFA_LocRec.cxx.

1006 {
1007  ATH_MSG_DEBUG("begin ALFA_LocRec::RecordCollection()");
1008 
1009  StatusCode sc = StatusCode::SUCCESS;
1010 
1011  m_pLocRecEvCollection = new ALFA_LocRecEvCollection();
1012  sc = evtStore()->record(m_pLocRecEvCollection, m_strKeyLocRecEvCollection);
1013 
1014  if (sc.isFailure())
1015  {
1016  ATH_MSG_ERROR(m_strAlgoMD << "MD - Could not record the empty LocRecEv collection in StoreGate");
1017  return sc;
1018  }
1019  else
1020  {
1021  ATH_MSG_DEBUG("MD - LocRecEv collection was recorded in StoreGate");
1022  }
1023 
1024  ATH_MSG_DEBUG("end ALFA_LocRec::RecordCollection()");
1025 
1026  return sc;
1027 }

◆ RecordODCollection()

StatusCode ALFA_LocRec::RecordODCollection ( )
private

Definition at line 1029 of file ALFA_LocRec.cxx.

1030 {
1031  ATH_MSG_DEBUG("begin ALFA_LocRec::RecordODCollection()");
1032 
1033  StatusCode sc = StatusCode::SUCCESS;
1034 
1035  m_pLocRecODEvCollection = new ALFA_LocRecODEvCollection();
1036  sc = evtStore()->record(m_pLocRecODEvCollection, m_strKeyLocRecODEvCollection);
1037 
1038  if (sc.isFailure())
1039  {
1040  ATH_MSG_ERROR(m_strAlgoOD << "OD - Could not record the empty LocRecEv collection in StoreGate");
1041 
1042  return sc;
1043  }
1044  else
1045  {
1046  ATH_MSG_DEBUG("OD - LocRecEv collection is recorded in StoreGate");
1047  }
1048 
1049  ATH_MSG_DEBUG("end ALFA_LocRec::RecordODCollection()");
1050 
1051  return sc;
1052 }

◆ 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 601 of file ALFA_LocRec.cxx.

602 {
603  ATH_MSG_DEBUG("begin ALFA_LocRec::SaveGeometry()");
604 
605 
606  eGeoSourceType eGeoType;
607  char szFilename[64];
608  std::list<eRPotName>::const_iterator iterRPName;
609 
610  for(iterRPName=m_ListExistingRPots.begin();iterRPName!=m_ListExistingRPots.end();++iterRPName)
611  {
612  eGeoType=m_pGeometryReader->GetRPGeometryType(*iterRPName, EFT_FIBERMD);
613  switch(eGeoType)
614  {
615  case EGST_IDEALGEOMETRY:
616  sprintf(szFilename,"ALFA_LocRec_Idealgeometry_RP-%s.txt",m_pGeometryReader->GetRPotLabel(*iterRPName));
617  StoreReconstructionGeometry(*iterRPName, EFT_FIBERMD, szFilename);
618  ATH_MSG_DEBUG("The ALFA Fiber geometry was stored in the "<<szFilename<<" file");
619  break;
620  case EGST_FILE:
621  sprintf(szFilename,"ALFA_LocRec_Realgeometry_RP-%s.txt",m_pGeometryReader->GetRPotLabel(*iterRPName));
622  StoreReconstructionGeometry(*iterRPName, EFT_FIBERMD, szFilename);
623  ATH_MSG_DEBUG("The ALFA Fiber geometry was stored in the "<<szFilename<<" file");
624  break;
625  case EGST_DATABASE:
626  sprintf(szFilename,"ALFA_LocRec_Realdbgeometry_RP-%s.txt",m_pGeometryReader->GetRPotLabel(*iterRPName));
627  StoreReconstructionGeometry(*iterRPName, EFT_FIBERMD, szFilename);
628  ATH_MSG_DEBUG("The ALFA Fiber geometry was stored in the "<<szFilename<<" file");
629  break;
630  default:
631  ATH_MSG_DEBUG("Unrecognized MD geometry!");
632  return;
633  break;
634  }
635 
636  eGeoType=m_pGeometryReader->GetRPGeometryType(*iterRPName, EFT_FIBEROD);
637  switch(eGeoType)
638  {
639  case EGST_IDEALGEOMETRY:
640  sprintf(szFilename,"ALFA_LocRec_Idealgeometry_OD_RP-%s.txt",m_pGeometryReader->GetRPotLabel(*iterRPName));
641  StoreReconstructionGeometry(*iterRPName, EFT_FIBEROD, szFilename);
642  ATH_MSG_DEBUG("The ODFiber geometry was stored in the "<<szFilename<<" file");
643  break;
644  case EGST_FILE:
645  sprintf(szFilename,"ALFA_LocRec_Realgeometry_OD_RP-%s.txt",m_pGeometryReader->GetRPotLabel(*iterRPName));
646  StoreReconstructionGeometry(*iterRPName, EFT_FIBEROD, szFilename);
647  ATH_MSG_DEBUG("The ODFiber geometry was stored in the "<<szFilename<<" file");
648  break;
649  case EGST_DATABASE:
650  sprintf(szFilename,"ALFA_LocRec_Realdbgeometry_OD_RP-%s.txt",m_pGeometryReader->GetRPotLabel(*iterRPName));
651  StoreReconstructionGeometry(*iterRPName, EFT_FIBEROD, szFilename);
652  ATH_MSG_DEBUG("The ODFiber geometry was stored in the "<<szFilename<<" file");
653  break;
654  default:
655  ATH_MSG_DEBUG("Unrecognized OD geometry!");
656  return;
657  break;
658  }
659  }
660 
661  ATH_MSG_DEBUG("end ALFA_LocRec::SaveGeometry()");
662 }

◆ StoreReconstructionGeometry()

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

Definition at line 550 of file ALFA_LocRec.cxx.

551 {
552  ATH_MSG_DEBUG("begin ALFA_LocRec::StoreReconstructionGeometry()");
553 
554  Int_t iLayer, iFiber, iPlate, iSide;
555  Float_t fParamB, fZ, fSlope;
556  FILE * pFile;
557 
558  pFile = fopen(szDataDestination, "w");
559  if(pFile==NULL) return false;
560  fprintf(pFile, "xxxxxxxxxxxxxxxxxxx\n");
561  if (eFType==EFT_FIBERMD)
562  {
563  fprintf(pFile, "20\n");
564  for(iLayer=0; iLayer<2*ALFAPLATESCNT; iLayer++)
565  {
566  for(iFiber=0; iFiber<ALFAFIBERSCNT; iFiber++)
567  {
568  fSlope=m_faMD[eRPName-1][iLayer][iFiber];
569  fParamB=m_fbMD[eRPName-1][iLayer][iFiber];
570  fZ=m_fzMD[eRPName-1][iLayer][iFiber];
571 
572  fprintf(pFile, " %2d %2d %7.5f %7.4f %7.3f\n", iLayer+1, iFiber+1, fSlope, fParamB, fZ);
573  }
574  }
575  }
576  else if (eFType==EFT_FIBEROD)
577  {
578  fprintf(pFile, "6\n");
579  for(iPlate=0; iPlate<ODPLATESCNT; iPlate++)
580  {
581  for (iSide=0; iSide<ODSIDESCNT; iSide++)
582  {
583  for(iFiber=0; iFiber<ODLAYERSCNT*ODFIBERSCNT; iFiber++)
584  {
585  fSlope=m_faOD[eRPName-1][iPlate][iSide][iFiber];
586  fParamB=m_fbOD[eRPName-1][iPlate][iSide][iFiber];
587  fZ=m_fzOD[eRPName-1][iPlate][iSide][iFiber];
588 
589  fprintf(pFile, " %2d %2d %7.5f %7.4f %7.3f\n", (2*iPlate+iSide+1), iFiber+1, fSlope, fParamB, fZ);
590  }
591  }
592  }
593  }
594  fclose(pFile);
595 
596  ATH_MSG_DEBUG("end ALFA_LocRec::StoreReconstructionGeometry()");
597 
598  return true;
599 }

◆ 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 114 of file ALFA_LocRec.h.

◆ m_bEdgeMethod_Opt_UseGaps

Bool_t ALFA_LocRec::m_bEdgeMethod_Opt_UseGaps
private

Definition at line 115 of file ALFA_LocRec.h.

◆ m_Config

GEOMETRYCONFIGURATION ALFA_LocRec::m_Config
private

Definition at line 86 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 98 of file ALFA_LocRec.h.

◆ m_eventNum

UInt_t ALFA_LocRec::m_eventNum
private

Definition at line 103 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 118 of file ALFA_LocRec.h.

◆ m_faOD

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

Definition at line 123 of file ALFA_LocRec.h.

◆ m_fbMD

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

Definition at line 119 of file ALFA_LocRec.h.

◆ m_fbOD

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

Definition at line 124 of file ALFA_LocRec.h.

◆ m_fDistanceCutOD

Float_t ALFA_LocRec::m_fDistanceCutOD
private

Definition at line 112 of file ALFA_LocRec.h.

◆ m_fOverlapCutMD

Float_t ALFA_LocRec::m_fOverlapCutMD
private

Definition at line 111 of file ALFA_LocRec.h.

◆ m_fzMD

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

Definition at line 120 of file ALFA_LocRec.h.

◆ m_fzOD

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

Definition at line 125 of file ALFA_LocRec.h.

◆ m_iDataType

Int_t ALFA_LocRec::m_iDataType
private

Definition at line 104 of file ALFA_LocRec.h.

◆ m_iEvent

Int_t ALFA_LocRec::m_iEvent
private

Definition at line 105 of file ALFA_LocRec.h.

◆ m_iLayerCutOD

Float_t ALFA_LocRec::m_iLayerCutOD
private

Definition at line 113 of file ALFA_LocRec.h.

◆ m_iMultiplicityCutMD

Int_t ALFA_LocRec::m_iMultiplicityCutMD
private

Definition at line 106 of file ALFA_LocRec.h.

◆ m_iMultiplicityCutOD

Int_t ALFA_LocRec::m_iMultiplicityCutOD
private

Definition at line 110 of file ALFA_LocRec.h.

◆ m_iNumLayerCutMD

Int_t ALFA_LocRec::m_iNumLayerCutMD
private

Definition at line 107 of file ALFA_LocRec.h.

◆ m_iUVCutMD

Int_t ALFA_LocRec::m_iUVCutMD
private

Definition at line 108 of file ALFA_LocRec.h.

◆ m_iUVCutMDHalfReco

Int_t ALFA_LocRec::m_iUVCutMDHalfReco
private

Definition at line 109 of file ALFA_LocRec.h.

◆ m_ListExistingRPots

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

Definition at line 101 of file ALFA_LocRec.h.

◆ m_pGeometryReader

ALFA_GeometryReader* ALFA_LocRec::m_pGeometryReader
private

Definition at line 87 of file ALFA_LocRec.h.

◆ m_pLocRecEvCollection

ALFA_LocRecEvCollection* ALFA_LocRec::m_pLocRecEvCollection
private

Definition at line 92 of file ALFA_LocRec.h.

◆ m_pLocRecEvent

ALFA_LocRecEvent* ALFA_LocRec::m_pLocRecEvent
private

Definition at line 93 of file ALFA_LocRec.h.

◆ m_pLocRecODEvCollection

ALFA_LocRecODEvCollection* ALFA_LocRec::m_pLocRecODEvCollection
private

Definition at line 95 of file ALFA_LocRec.h.

◆ m_pLocRecODEvent

ALFA_LocRecODEvent* ALFA_LocRec::m_pLocRecODEvent
private

Definition at line 96 of file ALFA_LocRec.h.

◆ m_strAlgoMD

std::string ALFA_LocRec::m_strAlgoMD
private

Definition at line 131 of file ALFA_LocRec.h.

◆ m_strAlgoOD

std::string ALFA_LocRec::m_strAlgoOD
private

Definition at line 130 of file ALFA_LocRec.h.

◆ m_strCollectionName

std::string ALFA_LocRec::m_strCollectionName
private

Definition at line 134 of file ALFA_LocRec.h.

◆ m_strKeyGeometryForReco

std::string ALFA_LocRec::m_strKeyGeometryForReco
private

Definition at line 127 of file ALFA_LocRec.h.

◆ m_strKeyLocRecEvCollection

std::string ALFA_LocRec::m_strKeyLocRecEvCollection
private

Definition at line 132 of file ALFA_LocRec.h.

◆ m_strKeyLocRecODEvCollection

std::string ALFA_LocRec::m_strKeyLocRecODEvCollection
private

Definition at line 133 of file ALFA_LocRec.h.

◆ m_strODCollectionName

std::string ALFA_LocRec::m_strODCollectionName
private

Definition at line 135 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 128 of file ALFA_LocRec.h.

◆ m_vecListAlgoOD

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

Definition at line 129 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:1009
ALFA_LocRec::m_fzMD
Float_t m_fzMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT]
Definition: ALFA_LocRec.h:120
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:550
ALFA_LocRec::m_fbOD
Float_t m_fbOD[RPOTSCNT][ODPLATESCNT][ODSIDESCNT][ODLAYERSCNT *ODFIBERSCNT]
Definition: ALFA_LocRec.h:124
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:135
ALFA_LocRec::m_bEdgeMethod_Opt_UseGaps
Bool_t m_bEdgeMethod_Opt_UseGaps
Definition: ALFA_LocRec.h:115
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:72
ALFA_LocRec::m_strAlgoOD
std::string m_strAlgoOD
Definition: ALFA_LocRec.h:130
ALFA_LocRec::m_ListExistingRPots
std::list< eRPotName > m_ListExistingRPots
Definition: ALFA_LocRec.h:101
ALFA_LocRec::m_Config
GEOMETRYCONFIGURATION m_Config
Definition: ALFA_LocRec.h:86
ALFA_LocRec::m_iMultiplicityCutOD
Int_t m_iMultiplicityCutOD
Definition: ALFA_LocRec.h:110
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:127
ALFA_LocRec::RecordODCollection
StatusCode RecordODCollection()
Definition: ALFA_LocRec.cxx:1029
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
EGST_IDEALGEOMETRY
@ EGST_IDEALGEOMETRY
Definition: ALFA_GeometryReader.h:23
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
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:98
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:96
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:132
_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:95
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:114
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:113
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:133
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:112
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:157
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:344
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
ALFA_LocRec::m_vecListAlgoMD
std::vector< std::string > m_vecListAlgoMD
Definition: ALFA_LocRec.h:128
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:134
ERPPT_ACTIVE
@ ERPPT_ACTIVE
Definition: ALFA_GeometryReader.h:28
ALFA_LocRec::ReadGeometryDetCS
bool ReadGeometryDetCS()
Definition: ALFA_LocRec.cxx:408
_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:93
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:664
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
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:108
ALFA_LocRec::ALFACollectionReading
StatusCode ALFACollectionReading(std::list< MDHIT > &ListMDHits, std::list< ODHIT > &ListODHits)
Definition: ALFA_LocRec.cxx:348
_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:87
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
ALFA_LocRec::m_iEvent
Int_t m_iEvent
Definition: ALFA_LocRec.h:105
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:184
_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:103
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:228
ALFA_LocRec::m_vecListAlgoOD
std::vector< std::string > m_vecListAlgoOD
Definition: ALFA_LocRec.h:129
EGST_DATABASE
@ EGST_DATABASE
Definition: ALFA_GeometryReader.h:23
ALFA_LocRec::m_iNumLayerCutMD
Int_t m_iNumLayerCutMD
Definition: ALFA_LocRec.h:107
ALFA_LocRec::m_faOD
Float_t m_faOD[RPOTSCNT][ODPLATESCNT][ODSIDESCNT][ODLAYERSCNT *ODFIBERSCNT]
Definition: ALFA_LocRec.h:123
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:131
ALFA_LocRec::m_pLocRecEvCollection
ALFA_LocRecEvCollection * m_pLocRecEvCollection
Definition: ALFA_LocRec.h:92
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:119
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:109
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:623
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:798
_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:334
ALFA_LocRec::m_faMD
Float_t m_faMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT]
Definition: ALFA_LocRec.h:118
CFGRPPOSPARAMS::eMDGeoType
int eMDGeoType
Definition: ALFA_GeometryReader.h:175
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
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:111
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:1005
ALFA_LocRec::m_iMultiplicityCutMD
Int_t m_iMultiplicityCutMD
Definition: ALFA_LocRec.h:106
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:125
fitman.k
k
Definition: fitman.py:528
ServiceHandle< ICondSvc >
ALFA_LocRec::m_iDataType
Int_t m_iDataType
Definition: ALFA_LocRec.h:104
ALFA_ODDigitCollection
Definition: ALFA_ODDigitCollection.h:15
Generated on Sun Dec 22 2024 21:25:53 for ATLAS Offline Software by   doxygen 1.8.18