ATLAS Offline Software
Loading...
Searching...
No Matches
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 (const EventContext &ctx)
 Execute method.
StatusCode finalize ()
virtual StatusCode sysInitialize () override
 Override sysInitialize.
virtual bool isClonable () const override
 Specify if the algorithm is clonable.
virtual StatusCode sysExecute (const EventContext &ctx) override
 Execute an algorithm.
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies.
virtual bool filterPassed (const EventContext &ctx) const
 Get filter decision:
virtual void setFilterPassed (bool state, const EventContext &ctx) const
 Set filter decision:
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode sysStart () override
 Handle START transition.
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles.
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
void updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream & msg () const
bool msgLvl (const MSG::Level lvl) const

Protected Member Functions

virtual bool isReEntrant () const override final
 Legacy algorithms are not thread-safe.
void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution
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.

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>

Private Attributes

GEOMETRYCONFIGURATION m_Config
ALFA_GeometryReader * m_pGeometryReader {new ALFA_GeometryReader()}
ALFA_LocRecEvCollection * m_pLocRecEvCollection {nullptr}
ALFA_LocRecODEvCollection * m_pLocRecODEvCollection {nullptr}
Gaudi::Property< int > m_metrologyType {this, "MetrologyType", EMT_NOMINAL}
Gaudi::Property< std::string > m_metrologySource {this, "MetrologySource", ""}
Gaudi::Property< bool > m_shiftToX97Pos {this, "ShiftToX97Pos", false}
Gaudi::Property< int > m_rpPosType [RPOTSCNT]
Gaudi::Property< int > m_mdGeoType [RPOTSCNT]
Gaudi::Property< int > m_odGeoType [RPOTSCNT]
Gaudi::Property< std::string > m_mdConnString [RPOTSCNT]
Gaudi::Property< std::string > m_odConnString [RPOTSCNT]
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey {this, "EvtInfo", "EventInfo", "EventInfo name"}
std::list< eRPotName > m_ListExistingRPots
UInt_t m_eventNum {0}
Gaudi::Property< Int_t > m_iDataType {this, "DataType", 1, "data type using in the local reconstruction"}
Int_t m_iEvent {0}
Gaudi::Property< Int_t > m_iMultiplicityCutMD {this, "MultiplicityCutMD", 5}
Gaudi::Property< Int_t > m_iNumLayerCutMD {this, "NumLayerCutMD", 3}
Gaudi::Property< Int_t > m_iUVCutMD {this, "UVCutMD", 3}
Gaudi::Property< Int_t > m_iUVCutMDHalfReco {this, "UVCutMDHalfReco", 3}
Gaudi::Property< Int_t > m_iMultiplicityCutOD {this, "MultiplicityCutOD", 30}
Gaudi::Property< Float_t > m_fOverlapCutMD {this, "OverlapCutMD", 0.5}
Gaudi::Property< Float_t > m_fDistanceCutOD {this, "DistanceCutOD", 0.5}
Gaudi::Property< Float_t > m_iLayerCutOD {this, "LayerCutOD", 3}
Gaudi::Property< Bool_t > m_bEdgeMethod_Opt_Sisters {this, "EdgeMethod_Opt_Sisters", false}
Gaudi::Property< Bool_t > m_bEdgeMethod_Opt_UseGaps {this, "EdgeMethod_Opt_UseGaps", false}
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 {"ALFA_GeometryForReco"}
Gaudi::Property< std::vector< std::string > > m_vecListAlgoMD {this, "ListAlgoMD", {}}
Gaudi::Property< std::vector< std::string > > m_vecListAlgoOD {this, "ListAlgoOD", {}}
Gaudi::Property< std::string > m_strAlgoOD {this, "AlgoOD", "ODTracking"}
Gaudi::Property< std::string > m_strAlgoMD {this, "AlgoMD", "MDTracking"}
std::string m_strKeyLocRecEvCollection {"ALFA_LocRecEvCollection"}
std::string m_strKeyLocRecODEvCollection {"ALFA_LocRecODEvCollection"}
std::string m_strCollectionName {"ALFA_DigitCollection"}
std::string m_strODCollectionName {"ALFA_ODDigitCollection"}
DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default).
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * > m_vhka
bool m_varHandleArraysDeclared

Detailed Description

Definition at line 44 of file ALFA_LocRec.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 376 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 ATH_MSG_DEBUG("end ALFA_LocRec::ALFA_LocRec");
29}
#define ATH_MSG_DEBUG(x,...)
AthAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Constructor.

◆ ~ALFA_LocRec()

ALFA_LocRec::~ALFA_LocRec ( )

Definition at line 31 of file ALFA_LocRec.cxx.

32{
33 ATH_MSG_DEBUG("begin ALFA_LocRec::~ALFA_LocRec");
34
35// if(m_pGeometryReader!=NULL)
36// {
37// delete m_pGeometryReader;
38// m_pGeometryReader = NULL;
39// }
40
41 ATH_MSG_DEBUG("begin ALFA_LocRec::~ALFA_LocRec");
42}

Member Function Documentation

◆ ALFACollectionReading()

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

Definition at line 262 of file ALFA_LocRec.cxx.

263{
265
266 ATH_MSG_DEBUG("begin ALFA_LocRec::ALFACollectionReading()");
267
268 ODHIT ODHit;
269 MDHIT MDHit;
270
271 ListMDHits.clear();
272 ListODHits.clear();
273
274 const ALFA_DigitCollection* mcGen = 0;
275 const ALFA_ODDigitCollection* mcODGen = 0;
276
277 sc = evtStore()->retrieve(mcGen,m_strCollectionName);
278 if(sc.isFailure() || !mcGen)
279 {
280 return StatusCode::FAILURE;
281 }
282
284 ALFA_DigitCollection::const_iterator mcGenEnd = mcGen->end();
285
286 for(;mcGenBeg!=mcGenEnd;++mcGenBeg)
287 {
288 MDHit.iEvent = m_eventNum;
289
290 MDHit.iRPot = ((*mcGenBeg)->getStation());
291 MDHit.iPlate = ((*mcGenBeg)->getPlate());
292 MDHit.iFiber = ((*mcGenBeg)->getFiber());
293
294 ListMDHits.push_back(MDHit);
295 }
296
297 sc = evtStore()->retrieve(mcODGen,m_strODCollectionName);
298 if(sc.isFailure() || !mcODGen)
299 {
300 return StatusCode::FAILURE;
301 }
302
303 ALFA_ODDigitCollection::const_iterator mcODGenBeg = mcODGen->begin();
304 ALFA_ODDigitCollection::const_iterator mcODGenEnd = mcODGen->end();
305
306 for(;mcODGenBeg!=mcODGenEnd;++mcODGenBeg)
307 {
308 ODHit.iEvent = m_eventNum;
309 ODHit.iRPot = ((*mcODGenBeg)->getStation());
310 ODHit.iPlate = ((*mcODGenBeg)->getPlate());
311 ODHit.iSide = ((*mcODGenBeg)->getSide());
312 ODHit.iFiber = ((*mcODGenBeg)->getFiber());
313
314 ListODHits.push_back(ODHit);
315 }
316
317 ATH_MSG_DEBUG("end ALFA_LocRec::ALFACollectionReading()");
318
319 return StatusCode::SUCCESS;
320}
struct _MDHIT MDHIT
struct _ODHIT ODHIT
static Double_t sc
std::string m_strODCollectionName
std::string m_strCollectionName
UInt_t m_eventNum
ServiceHandle< StoreGateSvc > & evtStore()
DataModel_detail::const_iterator< DataVector > const_iterator
Definition DataVector.h:861
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
::StatusCode StatusCode
StatusCode definition for legacy code.

◆ ClearGeometry()

void ALFA_LocRec::ClearGeometry ( )
private

Definition at line 248 of file ALFA_LocRec.cxx.

249{
250 ATH_MSG_DEBUG("begin ALFA_LocRec::ClearGeometry()");
251
252 memset(&m_faMD, 0, sizeof(m_faMD));
253 memset(&m_fbMD, 0, sizeof(m_fbMD));
254 memset(&m_fzMD, 0, sizeof(m_fzMD));
255 memset(&m_faOD, 0, sizeof(m_faOD));
256 memset(&m_fbOD, 0, sizeof(m_fbOD));
257 memset(&m_fzOD, 0, sizeof(m_fzOD));
258
259 ATH_MSG_DEBUG("end ALFA_LocRec::ClearGeometry()");
260}
Float_t m_fbOD[RPOTSCNT][ODPLATESCNT][ODSIDESCNT][ODLAYERSCNT *ODFIBERSCNT]
Float_t m_faOD[RPOTSCNT][ODPLATESCNT][ODSIDESCNT][ODLAYERSCNT *ODFIBERSCNT]
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_fzOD[RPOTSCNT][ODPLATESCNT][ODSIDESCNT][ODLAYERSCNT *ODFIBERSCNT]

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::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 {
160 hndl.value(),
161 hndl.documentation());
162
163 }
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::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;
148 }
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

◆ evtStore()

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

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

Definition at line 85 of file AthCommonDataStore.h.

◆ execute()

StatusCode ALFA_LocRec::execute ( const EventContext & ctx)
virtual

Execute method.

Implements AthAlgorithm.

Definition at line 112 of file ALFA_LocRec.cxx.

113{
114 ATH_MSG_DEBUG("begin ALFA_LocRec::execute()");
115
117 std::list<eRPotName>::const_iterator iterRPName;
118 eRPotName eRPName;
119
120 std::list<MDHIT> ListMDHits;
121 std::list<ODHIT> ListODHits;
122 ListMDHits.clear();
123 ListODHits.clear();
124
125 m_eventNum = 0;
126 SG::ReadHandle<xAOD::EventInfo> eventInfo (m_eventInfoKey, ctx);
127 if(!eventInfo.isValid()) {
128 ATH_MSG_ERROR("ALFA_LocRec, Cannot get event info.");
129// return sc;
130 }
131 else
132 {
133 // current event number
134 m_eventNum = eventInfo->eventNumber();
135 }
136
137 //************************************************************
138// if (m_eventNum!=73681035) return StatusCode::SUCCESS;
139 //************************************************************
140
142 if (sc.isFailure())
143 {
144 ATH_MSG_ERROR("RecordCollection() failed");
145 return StatusCode::SUCCESS;
146 }
147
149 if (sc.isFailure())
150 {
151 ATH_MSG_ERROR("RecordODCollection() failed");
152 return StatusCode::SUCCESS;
153 }
154
155 sc = ALFACollectionReading(ListMDHits, ListODHits);
156 if (sc.isFailure())
157 {
158 ATH_MSG_WARNING("ALFA_Collection_Reading Failed");
159// return StatusCode::SUCCESS;
160 }
161 else
162 {
163 std::string strAlgoMD;
164 for(auto & i : m_vecListAlgoMD)
165 {
166 strAlgoMD = i;
167 for(iterRPName=m_ListExistingRPots.begin();iterRPName!=m_ListExistingRPots.end();++iterRPName)
168 {
169 eRPName = *iterRPName;
170
171// cout << "eRPName = " << eRPName << endl;
172 //execute MD algorithm
173 sc = ExecuteRecoMethod(strAlgoMD, eRPName, ListMDHits, ListODHits);
174 if (sc.isFailure())
175 {
176 ATH_MSG_FATAL("Algorithm " << strAlgoMD << " for the pot " << m_pGeometryReader->GetRPotLabel(eRPName) << " failure!");
177 return sc;
178 }
179 }
180 }
181
182 std::string strAlgoOD;
183 for(auto & i : m_vecListAlgoOD)
184 {
185 strAlgoOD = i;
186 for(iterRPName=m_ListExistingRPots.begin();iterRPName!=m_ListExistingRPots.end();++iterRPName)
187 {
188 eRPName = *iterRPName;
189
190 // cout << "eRPName = " << eRPName << endl;
191 //execute OD algorithm
192 sc = ExecuteRecoMethod(strAlgoOD, eRPName, ListMDHits, ListODHits);
193 if (sc.isFailure())
194 {
195 ATH_MSG_FATAL("Algorithm " << strAlgoOD << " for the pot " << m_pGeometryReader->GetRPotLabel(eRPName) << " failure!");
196 return sc;
197 }
198 }
199 }
200
201
202
203
204// // local reconstruction process for all existing pots, MD & OD
205// for(iterRPName=m_ListExistingRPots.begin();iterRPName!=m_ListExistingRPots.end();iterRPName++)
206// {
207// eRPName = *iterRPName;
208
209// //execute MD reconstruction method
210// if (!m_strAlgoMD.empty())
211// {
212// sc = ExecuteRecoMethod(m_strAlgoMD, eRPName, ListMDHits, ListODHits);
213// if (sc.isFailure())
214// {
215// ATH_MSG_ERROR("Algorithm " << m_strAlgoMD << " for pot " << m_pGeometryReader->GetRPotLabel(eRPName) << " failure!");
216// // return sc;
217// }
218// }
219
220// //execute OD reconstruction method
221// if (!m_strAlgoOD.empty())
222// {
223// sc = ExecuteRecoMethod(m_strAlgoOD, eRPName, ListMDHits, ListODHits);
224// if (sc.isFailure())
225// {
226// ATH_MSG_ERROR("Algorithm " << m_strAlgoOD << " for pot " << m_pGeometryReader->GetRPotLabel(eRPName) << " failure!");
227// // return sc;
228// }
229// }
230// }
231 }
232
233 m_iEvent++;
234 ATH_MSG_DEBUG("end ALFA_LocRec::execute()");
235 return StatusCode::SUCCESS;
236}
#define ATH_MSG_ERROR(x,...)
#define ATH_MSG_WARNING(x,...)
#define ATH_MSG_FATAL(x,...)
Gaudi::Property< std::vector< std::string > > m_vecListAlgoMD
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
StatusCode ExecuteRecoMethod(const std::string &strAlgo, const eRPotName eRPName, const std::list< MDHIT > &ListMDHits, const std::list< ODHIT > &ListODHits)
StatusCode ALFACollectionReading(std::list< MDHIT > &ListMDHits, std::list< ODHIT > &ListODHits)
Gaudi::Property< std::vector< std::string > > m_vecListAlgoOD
StatusCode RecordODCollection()
StatusCode RecordCollection()
ALFA_GeometryReader * m_pGeometryReader
Definition ALFA_LocRec.h:52
std::list< eRPotName > m_ListExistingRPots

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

579{
580 ATH_MSG_DEBUG("begin ALFA_LocRec::ExecuteRecoMethod()");
581 if (eRPName < 1){
582 ATH_MSG_ERROR("ALFA_LocRec::ExecuteRecoMethod called with invalid detector enum");
583 return StatusCode::FAILURE;
584 }
585 StatusCode sc = StatusCode::SUCCESS;
586 ODRESULT ODResults;
587 std::list<ODRESULT> listODResults;
588 listODResults.clear();
589 Float_t fRecPosX = -9999.0;
590 Float_t fRecPosY = -9999.0;
591
592 std::map<string, int> mapRecoMethods;
593 mapRecoMethods.clear();
594 mapRecoMethods.insert(std::pair<string, int>("ODTracking", 1));
595 mapRecoMethods.insert(std::pair<string, int>("MDTracking", 2));
596 mapRecoMethods.insert(std::pair<string, int>("MDOverlap", 3));
597 mapRecoMethods.insert(std::pair<string, int>("CenterGravity", 4));
598 mapRecoMethods.insert(std::pair<string, int>("MDMultiple", 5));
599 mapRecoMethods.insert(std::pair<string, int>("HalfReco", 6));
600 mapRecoMethods.insert(std::pair<string, int>("MDGap", 7));
601 mapRecoMethods.insert(std::pair<string, int>("EdgeMethod", 8));
602
603 std::vector<int> vecFibSel;
604 vecFibSel.clear();
605
606 switch(mapRecoMethods[strAlgo])
607 {
608 case 1:
609 {
610 ALFA_ODTracking* pODTracking = new ALFA_ODTracking();
611
613 sc = pODTracking->Execute(eRPName-1, ListODHits, m_faOD, m_fbOD);
614 sc = pODTracking->Finalize(&listODResults);
615
616 std::list<ODRESULT>::const_iterator iter;
617 for(iter=listODResults.begin(); iter!=listODResults.end(); ++iter)
618 {
619 ODResults.iSide = (*iter).iSide;
620 ODResults.fRecPos = (*iter).fRecPos;
621 ODResults.fOverY = (*iter).fOverY;
622 ODResults.iNumY = (*iter).iNumY;
623
624 if ((ODResults.fRecPos != -9999.0))
625 {
626 Int_t iFibSel[ODSIDESCNT][ODPLATESCNT];
627 std::fill_n(&iFibSel[0][0], sizeof(iFibSel)/sizeof(Int_t), -9999);
628
629 pODTracking->GetData(iFibSel);
630 vecFibSel.clear();
631 for (int iPlate=0; iPlate<ODPLATESCNT; iPlate++)
632 {
633 vecFibSel.push_back(iFibSel[ODResults.iSide][iPlate]);
634 }
635
636 m_pLocRecODEvCollection->push_back(new ALFA_LocRecODEvent(1, eRPName-1, ODResults.iSide, ODResults.fRecPos, ODResults.fOverY, ODResults.iNumY, vecFibSel));
637 }
638 }
639
640 delete pODTracking;
641 break;
642 }
643 case 2:
644 {
645 ALFA_MDTracking* pMDTracking = new ALFA_MDTracking();
647 sc = pMDTracking->Execute(eRPName-1, ListMDHits);
648 sc = pMDTracking->Finalize(fRecPosX, fRecPosY);
649
650 if (fRecPosX!=-9999.0 && fRecPosY!=-9999.0)
651 {
652 Int_t iFibSel[ALFALAYERSCNT*ALFAPLATESCNT];
653 Int_t iNumU = 0, iNumV = 0;
654 Float_t fOverlapU = -9999.0, fOverlapV = -9999.0;
655 std::fill_n(&iFibSel[0], sizeof(iFibSel)/sizeof(Int_t), -9999);
656
657 pMDTracking->GetData(iNumU, iNumV, fOverlapU, fOverlapV, iFibSel);
658 vecFibSel.clear();
659 for (int & iLayer : iFibSel)
660 {
661 vecFibSel.push_back(iLayer);
662 }
663
664 m_pLocRecEvCollection->push_back(new ALFA_LocRecEvent(2, eRPName-1, fRecPosX, fRecPosY, fOverlapU, fOverlapV, iNumU, iNumV, std::move(vecFibSel)));
665 }
666
667 delete pMDTracking;
668 break;
669 }
670 case 3:
671 {
672 ALFA_MDOverlap* pMDOverlap = new ALFA_MDOverlap();
673
674 sc = pMDOverlap->Initialize(eRPName, ListMDHits, m_faMD, m_fbMD, m_fzMD);
675 sc = pMDOverlap->Execute();
676 sc = pMDOverlap->Finalize(fRecPosX, fRecPosY);
677
678 Int_t iFibSel[ALFALAYERSCNT*ALFAPLATESCNT];
679 Int_t iNumU = 0, iNumV = 0;
680 Float_t fOverlapU = -9999.0, fOverlapV = -9999.0;
681 std::fill_n(&iFibSel[0], sizeof(iFibSel)/sizeof(Int_t), -9999);
682
683 pMDOverlap->GetData(iFibSel);
684 if (fRecPosX!=-9999 && fRecPosY!=-9999)
685 {
686 vecFibSel.clear();
687 for (int & iLayer : iFibSel)
688 {
689 vecFibSel.push_back(iLayer);
690 }
691
692 m_pLocRecEvCollection->push_back(new ALFA_LocRecEvent(3, eRPName-1, fRecPosX, fRecPosY, fOverlapU, fOverlapV, iNumU, iNumV, std::move(vecFibSel)));
693 }
694
695 delete pMDOverlap;
696 break;
697 }
698 case 4:
699 {
700 ALFA_CenterGravity* pCenterGravity = new ALFA_CenterGravity();
701
702 sc = pCenterGravity->Initialize(eRPName, ListMDHits, m_faMD, m_fbMD, m_fzMD);
703 sc = pCenterGravity->Execute();
704 sc = pCenterGravity->Finalize(fRecPosX, fRecPosY);
705
706 Int_t iFibSel[ALFALAYERSCNT*ALFAPLATESCNT];
707 Int_t iNumU = 0, iNumV = 0;
708 Float_t fOverlapU = -9999.0, fOverlapV = -9999.0;
709 std::fill_n(&iFibSel[0], sizeof(iFibSel)/sizeof(Int_t), -9999);
710
711 pCenterGravity->GetData(iFibSel);
712 if (fRecPosX!=-9999 && fRecPosY!=-9999)
713 {
714 vecFibSel.clear();
715 for (int & iLayer : iFibSel)
716 {
717 vecFibSel.push_back(iLayer);
718 }
719
720 m_pLocRecEvCollection->push_back(new ALFA_LocRecEvent(4, eRPName-1, fRecPosX, fRecPosY, fOverlapU, fOverlapV, iNumU, iNumV, std::move(vecFibSel)));
721 }
722
723 delete pCenterGravity;
724 break;
725 }
726 case 5:
727 {
728 // MDMultiple algorihm ------------------------------------------------------
729 Float_t fRecPosX[NTRACK];
730 Float_t fRecPosY[NTRACK];
731 ALFA_MDMultiple* pMDMultiple = new ALFA_MDMultiple();
732
734 sc = pMDMultiple->Execute(ListMDHits);
735 sc = pMDMultiple->Finalize(fRecPosX, fRecPosY);
736
737 Int_t iNumU[NTRACK], iNumV[NTRACK], iFibSel[NTRACK][ALFALAYERSCNT*ALFAPLATESCNT];
738 Float_t fOverU[NTRACK], fOverV[NTRACK];
739 std::fill_n(&iFibSel[0][0], sizeof(iFibSel)/sizeof(Int_t), -9999);
740 std::fill_n(&fOverU[0], sizeof(fOverU)/sizeof(Float_t), -9999.0);
741 std::fill_n(&fOverV[0], sizeof(fOverV)/sizeof(Float_t), -9999.0);
742 memset(&iNumU, 0, sizeof(iNumU));
743 memset(&iNumV, 0, sizeof(iNumV));
744
745 pMDMultiple->GetData(iNumU, iNumV, fOverU, fOverV, iFibSel);
746 for (Int_t iTrack=0; iTrack<NTRACK; iTrack++)
747 {
748 if (fRecPosX[iTrack] != -9999.0 && fRecPosY[iTrack] != -9999.0)
749 {
750 vecFibSel.clear();
751 for (Int_t iLayer=0; iLayer<ALFALAYERSCNT*ALFAPLATESCNT; iLayer++)
752 {
753 vecFibSel.push_back(iFibSel[iTrack][iLayer]);
754 }
755
756 m_pLocRecEvCollection->push_back(new ALFA_LocRecEvent(5, eRPName-1, fRecPosX[iTrack], fRecPosY[iTrack], fOverU[iTrack], fOverV[iTrack], iNumU[iTrack], iNumV[iTrack], vecFibSel));
757 }
758 }
759
760 delete pMDMultiple;
761 break;
762 }
763 case 6:
764 {
765 //TODO - cele prepracovat
766 ALFA_HalfReco* pHalfReco = new ALFA_HalfReco();
767
768 Int_t iNumU[2] = {0, 0};
769 Int_t iNumV[2] = {0, 0};
770 Int_t iHalfFirst=0;
771 Int_t iHalfSecond=1;
772 Float_t fOverlapU[2] = {-9999, -9999};
773 Float_t fOverlapV[2] = {-9999, -9999};
774 Float_t fRecPosX[2] = {-9999, -9999};
775 Float_t fRecPosY[2] = {-9999, -9999};
776
777 Int_t iFibSel[ALFALAYERSCNT*ALFAPLATESCNT];
778 std::fill_n(&iFibSel[0], sizeof(iFibSel)/sizeof(Int_t), -9999);
779
780 std::vector<int> vecFibSel0;
781 std::vector<int> vecFibSel1;
782 vecFibSel0.clear();
783 vecFibSel1.clear();
784
785 if (eRPName==1 || eRPName==3 || eRPName==6 || eRPName==8)
786 {
787 iHalfFirst = 0;
788 iHalfSecond = 1;
789 }
790 else
791 {
792 iHalfFirst = 1;
793 iHalfSecond = 0;
794 }
795
797 sc = pHalfReco->Execute(eRPName-1, ListMDHits);
798 sc = pHalfReco->Finalize(fRecPosX[0], fRecPosY[0]);
799
800 pHalfReco->GetData(iNumU[0], iNumV[0], fOverlapU[0], fOverlapV[0], iFibSel);
801 vecFibSel0.clear();
802 for (int & iLayer : iFibSel)
803 {
804 vecFibSel0.push_back(iLayer);
805 }
806
808 sc = pHalfReco->Execute(eRPName-1, ListMDHits);
809 sc = pHalfReco->Finalize(fRecPosX[1], fRecPosY[1]);
810
811 pHalfReco->GetData(iNumU[1], iNumV[1], fOverlapU[1], fOverlapV[1], iFibSel);
812 vecFibSel1.clear();
813 for (int & iLayer : iFibSel)
814 {
815 vecFibSel1.push_back(iLayer);
816 }
817
818 if (fRecPosX[0]!=-9999.0 && fRecPosY[0]!=-9999.0 && fRecPosX[1]!=-9999.0 && fRecPosY[1]!=-9999.0)
819 {
820 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)));
821 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)));
822 }
823
824 delete pHalfReco;
825 break;
826 }
827 case 7:
828 {
829 Float_t fRecPosX[NTRACK];
830 Float_t fRecPosY[NTRACK];
831 ALFA_MDGap* pMDGap = new ALFA_MDGap();
832
833 sc = pMDGap->Initialize(eRPName-1, m_faMD, m_fbMD, m_iUVCutMD, m_fOverlapCutMD);
834 sc = pMDGap->Execute(ListMDHits);
835 sc = pMDGap->Finalize(fRecPosX, fRecPosY);
836
837 Int_t iNumU[NTRACK], iNumV[NTRACK];
838 Int_t iFibSel[ALFALAYERSCNT*ALFAPLATESCNT];
839 Float_t fOverU[NTRACK], fOverV[NTRACK];
840
841 std::fill_n(&iFibSel[0], sizeof(iFibSel)/sizeof(Int_t), -9999);
842 std::fill_n(&fOverU[0], sizeof(fOverU)/sizeof(Float_t), -9999.0);
843 std::fill_n(&fOverV[0], sizeof(fOverV)/sizeof(Float_t), -9999.0);
844
845 pMDGap->GetData(iNumU, iNumV, fOverU, fOverV, iFibSel);
846 for (Int_t iTrack=0; iTrack<NTRACK; iTrack++)
847 {
848 if (fRecPosX[iTrack] != -9999.0 && fRecPosY[iTrack] != -9999.0)
849 {
850 vecFibSel.clear();
851 for (int & iLayer : iFibSel)
852 {
853 vecFibSel.push_back(iLayer);
854 }
855
856 m_pLocRecEvCollection->push_back(new ALFA_LocRecEvent(7, eRPName-1, fRecPosX[iTrack], fRecPosY[iTrack], fOverU[iTrack], fOverV[iTrack], iNumU[iTrack], iNumV[iTrack], vecFibSel));
857 }
858 }
859
860 delete pMDGap;
861 break;
862 }
863 case 8:
864 {
865 Float_t fRecPosX[NTRACK];
866 Float_t fRecPosY[NTRACK];
867 ALFA_EdgeMethod* pEdgeMethod = new ALFA_EdgeMethod(m_bEdgeMethod_Opt_Sisters, m_bEdgeMethod_Opt_UseGaps);
868 pEdgeMethod->Initialize(eRPName-1, m_faMD, m_fbMD, ListMDHits);
869
870 Int_t iNumU[NTRACK], iNumV[NTRACK];
871 Int_t iFibSel[ALFALAYERSCNT*ALFAPLATESCNT];
872 Float_t fOverU[NTRACK], fOverV[NTRACK];
873
874 std::fill_n(&iFibSel[0], sizeof(iFibSel)/sizeof(Int_t), -9999);
875 std::fill_n(&fOverU[0], sizeof(fOverU)/sizeof(Float_t), -9999.0);
876 std::fill_n(&fOverV[0], sizeof(fOverV)/sizeof(Float_t), -9999.0);
877
878
879 std::vector<ALFA_EdgeMethod::Track> tracks;
880 pEdgeMethod->EdgeMethod(eRPName - 1, tracks);
881
882 for (UInt_t iTrack=0; iTrack<tracks.size(); iTrack++)
883 {
884 pEdgeMethod->selectedFibers(eRPName - 1, tracks.at(iTrack), iFibSel);
885
886 iNumU[iTrack] = tracks.at(iTrack).first.second;
887 iNumV[iTrack] = tracks.at(iTrack).second.second;
888 fOverU[iTrack] = tracks.at(iTrack).first.first.second;
889 fOverV[iTrack] = tracks.at(iTrack).second.first.second;
890 fRecPosX[iTrack] = 0.5*TMath::Sqrt2()*(-tracks.at(iTrack).first.first.first-tracks.at(iTrack).second.first.first);
891 fRecPosY[iTrack] = 0.5*TMath::Sqrt2()*(-tracks.at(iTrack).first.first.first+tracks.at(iTrack).second.first.first);
892
893 if (fRecPosX[iTrack] != -9999.0 && fRecPosY[iTrack] != -9999.0)
894 {
895 vecFibSel.clear();
896 for (int & iLayer : iFibSel)
897 {
898 vecFibSel.push_back(iLayer);
899 }
900
901 m_pLocRecEvCollection->push_back(new ALFA_LocRecEvent(8, eRPName-1, fRecPosX[iTrack], fRecPosY[iTrack], fOverU[iTrack], fOverV[iTrack], iNumU[iTrack], iNumV[iTrack], vecFibSel));
902 }
903 }
904
905 delete pEdgeMethod;
906 sc = StatusCode::SUCCESS;
907 break;
908 }
909 default:
910 {
911 ATH_MSG_ERROR("Unable to recognize selected algorithm");
912 std::cout << "strAlgo: " << strAlgo << std::endl;
913 return StatusCode::SUCCESS;
914 }
915 }
916
917 ATH_MSG_DEBUG("end ALFA_LocRec::ExecuteRecoMethod()");
918
919 return sc;
920}
#define ODPLATESCNT
struct _ODRESULT ODRESULT
#define NTRACK
Definition ALFA_LocRec.h:37
#define ALFALAYERSCNT
#define ALFAPLATESCNT
#define ODSIDESCNT
void GetData(Int_t(&iFibSel)[ALFALAYERSCNT *ALFAPLATESCNT])
StatusCode Finalize(Float_t &fRecXPos, Float_t &fRecYPos)
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])
void selectedFibers(UInt_t no_Detector, Track &track, Int_t *selectedFib)
void Initialize(Int_t iRPot, Float_t faMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT], Float_t fbMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT], const std::list< MDHIT > &ListMDHits)
Bool_t EdgeMethod(UInt_t no_Detector, std::vector< Track > &tracks)
StatusCode Finalize(Float_t &fRecXPos, Float_t &fRecYPos)
StatusCode Execute(Int_t iRPot, const std::list< MDHIT > &ListMDHits)
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)
void GetData(Int_t &iNumU, Int_t &iNumV, Float_t &fOvU, Float_t &fOvV, Int_t(&iFibSel)[ALFALAYERSCNT *ALFAPLATESCNT])
Gaudi::Property< Int_t > m_iUVCutMDHalfReco
Gaudi::Property< Float_t > m_fOverlapCutMD
ALFA_LocRecODEvCollection * m_pLocRecODEvCollection
Definition ALFA_LocRec.h:55
Gaudi::Property< Int_t > m_iNumLayerCutMD
Gaudi::Property< Float_t > m_iLayerCutOD
ALFA_LocRecEvCollection * m_pLocRecEvCollection
Definition ALFA_LocRec.h:54
Gaudi::Property< Int_t > m_iMultiplicityCutMD
Gaudi::Property< Float_t > m_fDistanceCutOD
Gaudi::Property< Int_t > m_iDataType
Gaudi::Property< Bool_t > m_bEdgeMethod_Opt_Sisters
Gaudi::Property< Int_t > m_iUVCutMD
Gaudi::Property< Int_t > m_iMultiplicityCutOD
Gaudi::Property< Bool_t > m_bEdgeMethod_Opt_UseGaps
StatusCode Finalize(Float_t(&fRecXPos)[MAXTRACKNUM], Float_t(&fRecYPos)[MAXTRACKNUM])
void GetData(Int_t(&iNumU)[MAXTRACKNUM], Int_t(&iNumV)[MAXTRACKNUM], Float_t(&fOvU)[MAXTRACKNUM], Float_t(&fOvV)[MAXTRACKNUM], Int_t(&iFibSel)[ALFALAYERSCNT *ALFAPLATESCNT])
StatusCode Initialize(Int_t iRPot, Float_t faMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT], Float_t fbMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT], Int_t iUVCut, Float_t fOverlapCut)
StatusCode Execute(const std::list< MDHIT > &ListMDHits)
StatusCode Initialize(Int_t iRPot, Float_t faMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT], Float_t fbMD[RPOTSCNT][ALFALAYERSCNT *ALFAPLATESCNT][ALFAFIBERSCNT], Int_t iMultiplicityCut, Int_t iNumLayerCut, Int_t iUVCut, Float_t fOverlapCut)
StatusCode Execute(const std::list< MDHIT > &ListMDHits)
StatusCode Finalize(Float_t(&fRecXPos)[MAXTRACKNUM], Float_t(&fRecYPos)[MAXTRACKNUM])
void GetData(Int_t(&iNumU)[MAXTRACKNUM], Int_t(&iNumV)[MAXTRACKNUM], Float_t(&fOvU)[MAXTRACKNUM], Float_t(&fOvV)[MAXTRACKNUM], Int_t(&iFibSel)[MAXTRACKNUM][ALFALAYERSCNT *ALFAPLATESCNT])
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])
StatusCode Execute()
StatusCode Finalize(Float_t &fRecXPos, Float_t &fRecYPos)
void GetData(Int_t(&iFibSel)[ALFALAYERSCNT *ALFAPLATESCNT])
StatusCode Finalize(Float_t &fRecXPos, Float_t &fRecYPos)
StatusCode Execute(Int_t iRPot, const std::list< MDHIT > &ListMDHits)
void GetData(Int_t &NumU, Int_t &NumV, Float_t &OL_U, Float_t &OL_V, Int_t(&iFibSel)[ALFALAYERSCNT *ALFAPLATESCNT])
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)
void GetData(Int_t(&iFibSel)[ODSIDESCNT][ODPLATESCNT])
StatusCode Finalize(std::list< ODRESULT > *pListResults)
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])
StatusCode Initialize(Int_t fMultiplicityCut, Float_t fDistanceCut, Int_t iLayerCut, Int_t iDataType)
bool first
Definition DeMoScan.py:534

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::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 & AthCommonAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 89 of file AthCommonAlgorithm.cxx.

54{
55 // If we didn't find any symlinks to add, just return the collection
56 // from the base class. Otherwise, return the extended collection.
57 if (!m_extendedExtraObjects.empty()) {
59 }
61}
Common base class for algorithms.

◆ filterPassed()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx) const
inlinevirtualinherited

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

93 {
94 return execState( ctx ).filterPassed();
95 }
virtual bool filterPassed(const EventContext &ctx) const
Get filter decision:

◆ finalize()

StatusCode ALFA_LocRec::finalize ( )

Definition at line 238 of file ALFA_LocRec.cxx.

239{
240 ATH_MSG_DEBUG("begin ALFA_LocRec::finalize()");
241
242
243
244 ATH_MSG_DEBUG("end ALFA_LocRec::finalize()");
245 return StatusCode::SUCCESS;
246}

◆ initialize()

StatusCode ALFA_LocRec::initialize ( )

Definition at line 44 of file ALFA_LocRec.cxx.

45{
46 ATH_MSG_DEBUG("begin ALFA_LocRec::initialize()");
47
49
50 m_Config.clear();
51 m_Config.eRPMetrologyGeoType = m_metrologyType;
52 m_Config.strRPMetrologyConnString = m_metrologySource;
53 m_Config.bShiftToX97Pos = m_shiftToX97Pos;
54 for (int i = 0; i < RPOTSCNT; ++i) {
55 m_Config.CfgRPosParams[i].eRPPosType = m_rpPosType[i];
56 m_Config.CfgRPosParams[i].eMDGeoType = m_mdGeoType[i];
57 m_Config.CfgRPosParams[i].eODGeoType = m_odGeoType[i];
58 m_Config.CfgRPosParams[i].strMDConnString = m_mdConnString[i];
59 m_Config.CfgRPosParams[i].strODConnString = m_odConnString[i];
60 }
61
63
64// sc = service("StoreGateSvc",m_storeGate);
65// if(sc.isFailure())
66// {
67// ATH_MSG_ERROR("reconstruction: unable to retrieve pointer to StoreGateSvc");
68// return sc;
69// }
70
71 //read geometry
73 {
74 ATH_MSG_DEBUG("Geometry loaded successfully");
75 }
76 else
77 {
78 ATH_MSG_FATAL("Could not load geometry");
79 return StatusCode::FAILURE;
80 }
81
82 //write ALFA_GeometryReader to StoreGate
83// if (StatusCode::SUCCESS!=service("DetectorStore",m_pDetStore))
84// {
85// ATH_MSG_ERROR("Detector store not found");
86// return StatusCode::FAILURE;
87// }
89 if(sc.isFailure())
90 {
91 ATH_MSG_ERROR("m_pGeometryReader: unable to record to StoreGate");
92 return sc;
93 }
94
95// if (!detStore()->contains<ALFA_GeometryReader>(m_strKeyGeometryForReco))
96// {
97// ATH_MSG_ERROR("m_pGeometryReader is not in StoreGate");
98// }
99// else
100// {
101// ATH_MSG_DEBUG("m_pGeometryReader is in StoreGate");
102// }
103
104 ATH_CHECK(m_eventInfoKey.initialize());
105
106 m_iEvent = 0;
107
108 ATH_MSG_DEBUG("end ALFA_LocRec::initialize()");
109 return StatusCode::SUCCESS;
110}
#define RPOTSCNT
#define ATH_CHECK
Evaluate an expression and check for errors.
Gaudi::Property< std::string > m_odConnString[RPOTSCNT]
Gaudi::Property< std::string > m_metrologySource
Definition ALFA_LocRec.h:59
Gaudi::Property< std::string > m_mdConnString[RPOTSCNT]
Definition ALFA_LocRec.h:93
std::string m_strKeyGeometryForReco
Gaudi::Property< int > m_odGeoType[RPOTSCNT]
Definition ALFA_LocRec.h:83
Gaudi::Property< int > m_mdGeoType[RPOTSCNT]
Definition ALFA_LocRec.h:73
GEOMETRYCONFIGURATION m_Config
Definition ALFA_LocRec.h:51
void ClearGeometry()
Gaudi::Property< int > m_rpPosType[RPOTSCNT]
Definition ALFA_LocRec.h:63
bool ReadGeometryDetCS()
Gaudi::Property< bool > m_shiftToX97Pos
Definition ALFA_LocRec.h:60
Gaudi::Property< int > m_metrologyType
Definition ALFA_LocRec.h:58
const ServiceHandle< StoreGateSvc > & detStore() const

◆ inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::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.

◆ isClonable()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::isClonable ( ) const
inlineoverridevirtualinherited

Specify if the algorithm is clonable.

Only relevant for non-reentrant algorithms. Actual number of clones needs to be set via the "Cardinality" property.

Reimplemented in AFP_DigiTop, AlgB, AlgT, BCM_Digitization, CscDigitBuilder, CscDigitToCscRDO, G4AtlasAlg, G4RunAlg, HGTD_Digitization, HiveAlgBase, InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ISF::SimKernelMT, ITk::StripDigitization, ITkPixelCablingAlg, ITkStripCablingAlg, LArHitEMapMaker, LArTTL1Maker, LUCID_DigiTop, LVL1::L1TopoSimulation, MergeCalibHits, MergeGenericMuonSimHitColl, MergeHijingPars, MergeMcEventCollection, MergeTrackRecordCollection, MergeTruthJets, MergeTruthParticles, MuonDigitizer, PileUpMTAlg, PixelDigitization, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_Digitization, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, SGInputLoader, Simulation::BeamEffectsAlg, TileHitVecToCnt, TileMuonFitter, TilePulseForTileMuonReceiver, TileRawChannelMaker, TRTDigitization, and ZDC_DigiTop.

Definition at line 68 of file AthCommonAlgorithm.h.

68 {
69 return true;
70 }

◆ isReEntrant()

virtual bool AthAlgorithm::isReEntrant ( ) const
inlinefinaloverrideprotectedvirtualinherited

Legacy algorithms are not thread-safe.

Definition at line 47 of file AthAlgorithm.h.

47{ return false; }

◆ msg()

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msgLvl()

bool AthCommonMsg< Gaudi::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< Gaudi::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 322 of file ALFA_LocRec.cxx.

323{
324 ATH_MSG_DEBUG("begin ALFA_LocRec::ReadGeometryDetCS()");
325
326 Int_t nPlateID, nFiberID;
327 FIBERPARAMS FiberParams;
328 eRPotName eRPName;
329
330 bool bRes=false;
331 std::list<eRPotName>::const_iterator iterRPName;
332
333 if((bRes=m_pGeometryReader->Initialize(&m_Config,EFCS_ATLAS))==true)
334 {
335 ATH_MSG_DEBUG("Geometry successfully initialized");
336 m_pGeometryReader->GetListOfExistingRPotIDs(&m_ListExistingRPots);
337 }
338 else
339 {
340 ATH_MSG_FATAL("Cannot initialize geometry");
341 return bRes;
342 }
343
344 for(iterRPName=m_ListExistingRPots.begin();iterRPName!=m_ListExistingRPots.end();++iterRPName)
345 {
346 eRPName = *iterRPName;
347
348 //for MD-fibers
349 for (nPlateID = 0; nPlateID < ALFAPLATESCNT; nPlateID++)
350 {
351 for (nFiberID = 0; nFiberID < ALFAFIBERSCNT; nFiberID++)
352 {
353 //for V-fibers
354 if (m_pGeometryReader->GetVFiberParams(&FiberParams, eRPName, nPlateID+1, nFiberID+1))
355 {
356 m_faMD[eRPName-1][2*nPlateID+1][nFiberID] = FiberParams.fSlope;
357 m_fbMD[eRPName-1][2*nPlateID+1][nFiberID] = FiberParams.fOffset;
358 m_fzMD[eRPName-1][2*nPlateID+1][nFiberID] = FiberParams.fZPos;
359 }
360 else
361 {
362 ATH_MSG_ERROR("Unable to get FiberV parameters");
363 return false;
364 }
365
366 //for U-fibers
367 if (m_pGeometryReader->GetUFiberParams(&FiberParams, eRPName, nPlateID+1, nFiberID+1))
368 {
369 m_faMD[eRPName-1][2*nPlateID][nFiberID] = FiberParams.fSlope;
370 m_fbMD[eRPName-1][2*nPlateID][nFiberID] = FiberParams.fOffset;
371 m_fzMD[eRPName-1][2*nPlateID][nFiberID] = FiberParams.fZPos;
372 }
373 else
374 {
375 ATH_MSG_ERROR("Unable to get FiberU parameters");
376 return false;
377 }
378 }
379 }
380
381 //m_ODfiber = (m_ODside==0)? m_ODfiber : 29-m_ODfiber;
382 //for OD-fibers
383 for (nPlateID = 0; nPlateID < ODPLATESCNT; nPlateID++)
384 {
385 for (nFiberID = 0; nFiberID < ODFIBERSCNT; nFiberID++)
386 {
387 //(+16 because U0-nFiberID is indexed from 16 to 30 in Geometry package)
388 if (m_pGeometryReader->GetODFiberParams(&FiberParams, EFT_ODFIBERU0, eRPName, nPlateID+1, nFiberID+16))
389 {
390 m_faOD[eRPName-1][nPlateID][0][nFiberID+15] = FiberParams.fSlope;
391 m_fbOD[eRPName-1][nPlateID][0][nFiberID+15] = FiberParams.fOffset;
392 m_fzOD[eRPName-1][nPlateID][0][nFiberID+15] = FiberParams.fZPos;
393 }
394 else
395 {
396 ATH_MSG_ERROR("Unable to get ODFiberU0 parameters");
397 return false;
398 }
399
400 if (m_pGeometryReader->GetODFiberParams(&FiberParams, EFT_ODFIBERV0, eRPName, nPlateID+1, nFiberID+1))
401 {
402 m_faOD[eRPName-1][nPlateID][0][nFiberID] = FiberParams.fSlope;
403 m_fbOD[eRPName-1][nPlateID][0][nFiberID] = FiberParams.fOffset;
404 m_fzOD[eRPName-1][nPlateID][0][nFiberID] = FiberParams.fZPos;
405 }
406 else
407 {
408 ATH_MSG_ERROR("Unable to get ODFiberV0 parameters");
409 return false;
410 }
411
412 if (m_pGeometryReader->GetODFiberParams(&FiberParams, EFT_ODFIBERU1, eRPName, nPlateID+1, nFiberID+16))
413 {
414 if (m_iDataType==1) //for the tunnel and testbeam data
415 {
416 m_faOD[eRPName-1][nPlateID][1][14-nFiberID] = FiberParams.fSlope;
417 m_fbOD[eRPName-1][nPlateID][1][14-nFiberID] = FiberParams.fOffset;
418 m_fzOD[eRPName-1][nPlateID][1][14-nFiberID] = FiberParams.fZPos;
419 }
420 else //simulation
421 {
422 m_faOD[eRPName-1][nPlateID][1][nFiberID+15] = FiberParams.fSlope;
423 m_fbOD[eRPName-1][nPlateID][1][nFiberID+15] = FiberParams.fOffset;
424 m_fzOD[eRPName-1][nPlateID][1][nFiberID+15] = FiberParams.fZPos;
425 }
426 }
427 else
428 {
429 ATH_MSG_ERROR("Unable to get ODFiberU1 parameters");
430 return false;
431 }
432 //(+16 because V1-nFiberID is indexed from 16 to 30 in Geometry package)
433 if (m_pGeometryReader->GetODFiberParams(&FiberParams, EFT_ODFIBERV1, eRPName, nPlateID+1, nFiberID+1))
434 {
435 if (m_iDataType==1) //for the tunnel and testbeam data
436 {
437 m_faOD[eRPName-1][nPlateID][1][29-nFiberID] = FiberParams.fSlope;
438 m_fbOD[eRPName-1][nPlateID][1][29-nFiberID] = FiberParams.fOffset;
439 m_fzOD[eRPName-1][nPlateID][1][29-nFiberID] = FiberParams.fZPos;
440 }
441 else //simulation
442 {
443 m_faOD[eRPName-1][nPlateID][1][nFiberID] = FiberParams.fSlope;
444 m_fbOD[eRPName-1][nPlateID][1][nFiberID] = FiberParams.fOffset;
445 m_fzOD[eRPName-1][nPlateID][1][nFiberID] = FiberParams.fZPos;
446 }
447 }
448 else
449 {
450 ATH_MSG_ERROR("Unable to get ODFiberV1 parameters");
451 return false;
452 }
453 }
454 }
455 }
456
457// SaveGeometry();
458
459 ATH_MSG_DEBUG("end ALFA_LocRec::ReadGeometryDetCS()");
460
461 return bRes;
462}
#define ODFIBERSCNT
@ EFCS_ATLAS
@ EFT_ODFIBERV0
@ EFT_ODFIBERV1
@ EFT_ODFIBERU0
@ EFT_ODFIBERU1
#define ALFAFIBERSCNT

◆ RecordCollection()

StatusCode ALFA_LocRec::RecordCollection ( )
private

Definition at line 922 of file ALFA_LocRec.cxx.

923{
924 ATH_MSG_DEBUG("begin ALFA_LocRec::RecordCollection()");
925
926 StatusCode sc = StatusCode::SUCCESS;
927
928 m_pLocRecEvCollection = new ALFA_LocRecEvCollection();
930
931 if (sc.isFailure())
932 {
933 ATH_MSG_ERROR(m_strAlgoMD.value() << "MD - Could not record the empty LocRecEv collection in StoreGate");
934 return sc;
935 }
936 else
937 {
938 ATH_MSG_DEBUG("MD - LocRecEv collection was recorded in StoreGate");
939 }
940
941 ATH_MSG_DEBUG("end ALFA_LocRec::RecordCollection()");
942
943 return sc;
944}
Gaudi::Property< std::string > m_strAlgoMD
std::string m_strKeyLocRecEvCollection

◆ RecordODCollection()

StatusCode ALFA_LocRec::RecordODCollection ( )
private

Definition at line 946 of file ALFA_LocRec.cxx.

947{
948 ATH_MSG_DEBUG("begin ALFA_LocRec::RecordODCollection()");
949
950 StatusCode sc = StatusCode::SUCCESS;
951
952 m_pLocRecODEvCollection = new ALFA_LocRecODEvCollection();
954
955 if (sc.isFailure())
956 {
957 ATH_MSG_ERROR(m_strAlgoOD.value() << "OD - Could not record the empty LocRecEv collection in StoreGate");
958
959 return sc;
960 }
961 else
962 {
963 ATH_MSG_DEBUG("OD - LocRecEv collection is recorded in StoreGate");
964 }
965
966 ATH_MSG_DEBUG("end ALFA_LocRec::RecordODCollection()");
967
968 return sc;
969}
Gaudi::Property< std::string > m_strAlgoOD
std::string m_strKeyLocRecODEvCollection

◆ 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< Gaudi::Algorithm > >::renounce ( T & h)
inlineprotectedinherited

Definition at line 368 of file AthCommonDataStore.h.

369 {
370 h.renounce();
372 }
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)

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 352 of file AthCommonDataStore.h.

352 {
354 }

◆ SaveGeometry()

void ALFA_LocRec::SaveGeometry ( )
private

Definition at line 515 of file ALFA_LocRec.cxx.

516{
517 ATH_MSG_DEBUG("begin ALFA_LocRec::SaveGeometry()");
518
519
520 eGeoSourceType eGeoType;
521 char szFilename[64];
522 std::list<eRPotName>::const_iterator iterRPName;
523
524 for(iterRPName=m_ListExistingRPots.begin();iterRPName!=m_ListExistingRPots.end();++iterRPName)
525 {
526 eGeoType=m_pGeometryReader->GetRPGeometryType(*iterRPName, EFT_FIBERMD);
527 switch(eGeoType)
528 {
530 sprintf(szFilename,"ALFA_LocRec_Idealgeometry_RP-%s.txt",m_pGeometryReader->GetRPotLabel(*iterRPName));
531 StoreReconstructionGeometry(*iterRPName, EFT_FIBERMD, szFilename);
532 ATH_MSG_DEBUG("The ALFA Fiber geometry was stored in the "<<szFilename<<" file");
533 break;
534 case EGST_FILE:
535 sprintf(szFilename,"ALFA_LocRec_Realgeometry_RP-%s.txt",m_pGeometryReader->GetRPotLabel(*iterRPName));
536 StoreReconstructionGeometry(*iterRPName, EFT_FIBERMD, szFilename);
537 ATH_MSG_DEBUG("The ALFA Fiber geometry was stored in the "<<szFilename<<" file");
538 break;
539 case EGST_DATABASE:
540 sprintf(szFilename,"ALFA_LocRec_Realdbgeometry_RP-%s.txt",m_pGeometryReader->GetRPotLabel(*iterRPName));
541 StoreReconstructionGeometry(*iterRPName, EFT_FIBERMD, szFilename);
542 ATH_MSG_DEBUG("The ALFA Fiber geometry was stored in the "<<szFilename<<" file");
543 break;
544 default:
545 ATH_MSG_DEBUG("Unrecognized MD geometry!");
546 return;
547 break;
548 }
549
550 eGeoType=m_pGeometryReader->GetRPGeometryType(*iterRPName, EFT_FIBEROD);
551 switch(eGeoType)
552 {
554 sprintf(szFilename,"ALFA_LocRec_Idealgeometry_OD_RP-%s.txt",m_pGeometryReader->GetRPotLabel(*iterRPName));
555 StoreReconstructionGeometry(*iterRPName, EFT_FIBEROD, szFilename);
556 ATH_MSG_DEBUG("The ODFiber geometry was stored in the "<<szFilename<<" file");
557 break;
558 case EGST_FILE:
559 sprintf(szFilename,"ALFA_LocRec_Realgeometry_OD_RP-%s.txt",m_pGeometryReader->GetRPotLabel(*iterRPName));
560 StoreReconstructionGeometry(*iterRPName, EFT_FIBEROD, szFilename);
561 ATH_MSG_DEBUG("The ODFiber geometry was stored in the "<<szFilename<<" file");
562 break;
563 case EGST_DATABASE:
564 sprintf(szFilename,"ALFA_LocRec_Realdbgeometry_OD_RP-%s.txt",m_pGeometryReader->GetRPotLabel(*iterRPName));
565 StoreReconstructionGeometry(*iterRPName, EFT_FIBEROD, szFilename);
566 ATH_MSG_DEBUG("The ODFiber geometry was stored in the "<<szFilename<<" file");
567 break;
568 default:
569 ATH_MSG_DEBUG("Unrecognized OD geometry!");
570 return;
571 break;
572 }
573 }
574
575 ATH_MSG_DEBUG("end ALFA_LocRec::SaveGeometry()");
576}
@ EGST_IDEALGEOMETRY
@ EGST_DATABASE
@ EGST_FILE
@ EFT_FIBERMD
@ EFT_FIBEROD
bool StoreReconstructionGeometry(const eRPotName eRPName, const eFiberType eFType, const char *szDataDestination)

◆ setFilterPassed()

virtual void AthCommonAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state,
const EventContext & ctx ) const
inlinevirtualinherited

Set filter decision:

Definition at line 99 of file AthCommonAlgorithm.h.

99 {
101 }
virtual void setFilterPassed(bool state, const EventContext &ctx) const
Set filter decision:

◆ StoreReconstructionGeometry()

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

Definition at line 464 of file ALFA_LocRec.cxx.

465{
466 ATH_MSG_DEBUG("begin ALFA_LocRec::StoreReconstructionGeometry()");
467
468 Int_t iLayer, iFiber, iPlate, iSide;
469 Float_t fParamB, fZ, fSlope;
470 FILE * pFile;
471
472 pFile = fopen(szDataDestination, "w");
473 if(pFile==NULL) return false;
474 fprintf(pFile, "xxxxxxxxxxxxxxxxxxx\n");
475 if (eFType==EFT_FIBERMD)
476 {
477 fprintf(pFile, "20\n");
478 for(iLayer=0; iLayer<2*ALFAPLATESCNT; iLayer++)
479 {
480 for(iFiber=0; iFiber<ALFAFIBERSCNT; iFiber++)
481 {
482 fSlope=m_faMD[eRPName-1][iLayer][iFiber];
483 fParamB=m_fbMD[eRPName-1][iLayer][iFiber];
484 fZ=m_fzMD[eRPName-1][iLayer][iFiber];
485
486 fprintf(pFile, " %2d %2d %7.5f %7.4f %7.3f\n", iLayer+1, iFiber+1, fSlope, fParamB, fZ);
487 }
488 }
489 }
490 else if (eFType==EFT_FIBEROD)
491 {
492 fprintf(pFile, "6\n");
493 for(iPlate=0; iPlate<ODPLATESCNT; iPlate++)
494 {
495 for (iSide=0; iSide<ODSIDESCNT; iSide++)
496 {
497 for(iFiber=0; iFiber<ODLAYERSCNT*ODFIBERSCNT; iFiber++)
498 {
499 fSlope=m_faOD[eRPName-1][iPlate][iSide][iFiber];
500 fParamB=m_fbOD[eRPName-1][iPlate][iSide][iFiber];
501 fZ=m_fzOD[eRPName-1][iPlate][iSide][iFiber];
502
503 fprintf(pFile, " %2d %2d %7.5f %7.4f %7.3f\n", (2*iPlate+iSide+1), iFiber+1, fSlope, fParamB, fZ);
504 }
505 }
506 }
507 }
508 fclose(pFile);
509
510 ATH_MSG_DEBUG("end ALFA_LocRec::StoreReconstructionGeometry()");
511
512 return true;
513}
#define ODLAYERSCNT

◆ sysExecute()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx)
overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

41{
42 return BaseAlg::sysExecute (ctx);
43}

◆ sysInitialize()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::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< Gaudi::Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthHistogramAlgorithm, HypoBase, InputMakerBase, and PyAthena::Alg.

Definition at line 60 of file AthCommonAlgorithm.cxx.

71 {
73
74 if (sc.isFailure()) {
75 return sc;
76 }
77
78 ServiceHandle<ICondSvc> cs("CondSvc",name());
79 for (auto h : outputHandles()) {
80 if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
81 // do this inside the loop so we don't create the CondSvc until needed
82 if ( cs.retrieve().isFailure() ) {
83 ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
85 }
86 if (cs->regHandle(this,*h).isFailure()) {
88 ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
89 << " with CondSvc");
90 }
91 }
92 }
93 return sc;
94}
virtual StatusCode sysInitialize() override
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::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< Gaudi::Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )
inlineinherited

Definition at line 298 of file AthCommonDataStore.h.

298 {
299 for (auto &a : m_vhka) {
301 for (auto k : keys) {
302 k->setOwner(this);
303 }
304 }
305 }

Member Data Documentation

◆ m_bEdgeMethod_Opt_Sisters

Gaudi::Property<Bool_t> ALFA_LocRec::m_bEdgeMethod_Opt_Sisters {this, "EdgeMethod_Opt_Sisters", false}
private

Definition at line 130 of file ALFA_LocRec.h.

130{this, "EdgeMethod_Opt_Sisters", false}; // for EdgeMethod

◆ m_bEdgeMethod_Opt_UseGaps

Gaudi::Property<Bool_t> ALFA_LocRec::m_bEdgeMethod_Opt_UseGaps {this, "EdgeMethod_Opt_UseGaps", false}
private

Definition at line 131 of file ALFA_LocRec.h.

131{this, "EdgeMethod_Opt_UseGaps", false}; // for EdgeMethod

◆ m_Config

GEOMETRYCONFIGURATION ALFA_LocRec::m_Config
private

Definition at line 51 of file ALFA_LocRec.h.

◆ m_detStore

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

Pointer to StoreGate (detector store by default).

Definition at line 381 of file AthCommonDataStore.h.

◆ m_eventInfoKey

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

Definition at line 114 of file ALFA_LocRec.h.

114{this, "EvtInfo", "EventInfo", "EventInfo name"};

◆ m_eventNum

UInt_t ALFA_LocRec::m_eventNum {0}
private

Definition at line 119 of file ALFA_LocRec.h.

119{0}; // real event number

◆ m_evtStore

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

Pointer to StoreGate (event store by default).

Definition at line 378 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthCommonAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

◆ m_faMD

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

Definition at line 134 of file ALFA_LocRec.h.

◆ m_faOD

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

Definition at line 139 of file ALFA_LocRec.h.

◆ m_fbMD

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

Definition at line 135 of file ALFA_LocRec.h.

◆ m_fbOD

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

Definition at line 140 of file ALFA_LocRec.h.

◆ m_fDistanceCutOD

Gaudi::Property<Float_t> ALFA_LocRec::m_fDistanceCutOD {this, "DistanceCutOD", 0.5}
private

Definition at line 128 of file ALFA_LocRec.h.

128{this, "DistanceCutOD", 0.5}; // for Overlap Detector

◆ m_fOverlapCutMD

Gaudi::Property<Float_t> ALFA_LocRec::m_fOverlapCutMD {this, "OverlapCutMD", 0.5}
private

Definition at line 127 of file ALFA_LocRec.h.

127{this, "OverlapCutMD", 0.5}; // for Main Detector

◆ m_fzMD

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

Definition at line 136 of file ALFA_LocRec.h.

◆ m_fzOD

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

Definition at line 141 of file ALFA_LocRec.h.

◆ m_iDataType

Gaudi::Property<Int_t> ALFA_LocRec::m_iDataType {this, "DataType", 1, "data type using in the local reconstruction"}
private

Definition at line 120 of file ALFA_LocRec.h.

120{this, "DataType", 1, "data type using in the local reconstruction"}; // data type (simulation or real data) using in the local reconstruction

◆ m_iEvent

Int_t ALFA_LocRec::m_iEvent {0}
private

Definition at line 121 of file ALFA_LocRec.h.

121{0}; // event number from zero value

◆ m_iLayerCutOD

Gaudi::Property<Float_t> ALFA_LocRec::m_iLayerCutOD {this, "LayerCutOD", 3}
private

Definition at line 129 of file ALFA_LocRec.h.

129{this, "LayerCutOD", 3}; // for Overlap Detector

◆ m_iMultiplicityCutMD

Gaudi::Property<Int_t> ALFA_LocRec::m_iMultiplicityCutMD {this, "MultiplicityCutMD", 5}
private

Definition at line 122 of file ALFA_LocRec.h.

122{this, "MultiplicityCutMD", 5}; // for Main Detector

◆ m_iMultiplicityCutOD

Gaudi::Property<Int_t> ALFA_LocRec::m_iMultiplicityCutOD {this, "MultiplicityCutOD", 30}
private

Definition at line 126 of file ALFA_LocRec.h.

126{this, "MultiplicityCutOD", 30}; // for Overlap Detector

◆ m_iNumLayerCutMD

Gaudi::Property<Int_t> ALFA_LocRec::m_iNumLayerCutMD {this, "NumLayerCutMD", 3}
private

Definition at line 123 of file ALFA_LocRec.h.

123{this, "NumLayerCutMD", 3}; // for Main Detector

◆ m_iUVCutMD

Gaudi::Property<Int_t> ALFA_LocRec::m_iUVCutMD {this, "UVCutMD", 3}
private

Definition at line 124 of file ALFA_LocRec.h.

124{this, "UVCutMD", 3}; // for Main Detector

◆ m_iUVCutMDHalfReco

Gaudi::Property<Int_t> ALFA_LocRec::m_iUVCutMDHalfReco {this, "UVCutMDHalfReco", 3}
private

Definition at line 125 of file ALFA_LocRec.h.

125{this, "UVCutMDHalfReco", 3}; // for Main Detector HalfReco algorithm

◆ m_ListExistingRPots

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

Definition at line 117 of file ALFA_LocRec.h.

◆ m_mdConnString

Gaudi::Property<std::string> ALFA_LocRec::m_mdConnString[RPOTSCNT]
private
Initial value:
{
{this, "B7L1U_MDSource", ""},
{this, "B7L1L_MDSource", ""},
{this, "A7L1U_MDSource", ""},
{this, "A7L1L_MDSource", ""},
{this, "A7R1U_MDSource", ""},
{this, "A7R1L_MDSource", ""},
{this, "B7R1U_MDSource", ""},
{this, "B7R1L_MDSource", ""}
}

Definition at line 93 of file ALFA_LocRec.h.

93 {
94 {this, "B7L1U_MDSource", ""},
95 {this, "B7L1L_MDSource", ""},
96 {this, "A7L1U_MDSource", ""},
97 {this, "A7L1L_MDSource", ""},
98 {this, "A7R1U_MDSource", ""},
99 {this, "A7R1L_MDSource", ""},
100 {this, "B7R1U_MDSource", ""},
101 {this, "B7R1L_MDSource", ""}
102 };

◆ m_mdGeoType

Gaudi::Property<int> ALFA_LocRec::m_mdGeoType[RPOTSCNT]
private
Initial value:
{
{this, "B7L1U_MDGeometryType", EGST_IDEALGEOMETRY},
{this, "B7L1L_MDGeometryType", EGST_IDEALGEOMETRY},
{this, "A7L1U_MDGeometryType", EGST_IDEALGEOMETRY},
{this, "A7L1L_MDGeometryType", EGST_IDEALGEOMETRY},
{this, "A7R1U_MDGeometryType", EGST_IDEALGEOMETRY},
{this, "A7R1L_MDGeometryType", EGST_IDEALGEOMETRY},
{this, "B7R1U_MDGeometryType", EGST_IDEALGEOMETRY},
{this, "B7R1L_MDGeometryType", EGST_IDEALGEOMETRY}
}

Definition at line 73 of file ALFA_LocRec.h.

73 {
74 {this, "B7L1U_MDGeometryType", EGST_IDEALGEOMETRY},
75 {this, "B7L1L_MDGeometryType", EGST_IDEALGEOMETRY},
76 {this, "A7L1U_MDGeometryType", EGST_IDEALGEOMETRY},
77 {this, "A7L1L_MDGeometryType", EGST_IDEALGEOMETRY},
78 {this, "A7R1U_MDGeometryType", EGST_IDEALGEOMETRY},
79 {this, "A7R1L_MDGeometryType", EGST_IDEALGEOMETRY},
80 {this, "B7R1U_MDGeometryType", EGST_IDEALGEOMETRY},
81 {this, "B7R1L_MDGeometryType", EGST_IDEALGEOMETRY}
82 };

◆ m_metrologySource

Gaudi::Property<std::string> ALFA_LocRec::m_metrologySource {this, "MetrologySource", ""}
private

Definition at line 59 of file ALFA_LocRec.h.

59{this, "MetrologySource", ""};//"rpmetrology.dat"

◆ m_metrologyType

Gaudi::Property<int> ALFA_LocRec::m_metrologyType {this, "MetrologyType", EMT_NOMINAL}
private

Definition at line 58 of file ALFA_LocRec.h.

58{this, "MetrologyType", EMT_NOMINAL};//EGST_FILE
@ EMT_NOMINAL

◆ m_odConnString

Gaudi::Property<std::string> ALFA_LocRec::m_odConnString[RPOTSCNT]
private
Initial value:
{
{this, "B7L1U_ODSource", ""},
{this, "B7L1L_ODSource", ""},
{this, "A7L1U_ODSource", ""},
{this, "A7L1L_ODSource", ""},
{this, "A7R1U_ODSource", ""},
{this, "A7R1L_ODSource", ""},
{this, "B7R1U_ODSource", ""},
{this, "B7R1L_ODSource", ""}
}

Definition at line 103 of file ALFA_LocRec.h.

103 {
104 {this, "B7L1U_ODSource", ""},
105 {this, "B7L1L_ODSource", ""},
106 {this, "A7L1U_ODSource", ""},
107 {this, "A7L1L_ODSource", ""},
108 {this, "A7R1U_ODSource", ""},
109 {this, "A7R1L_ODSource", ""},
110 {this, "B7R1U_ODSource", ""},
111 {this, "B7R1L_ODSource", ""}
112 };

◆ m_odGeoType

Gaudi::Property<int> ALFA_LocRec::m_odGeoType[RPOTSCNT]
private
Initial value:
{
{this, "B7L1U_ODGeometryType", EGST_IDEALGEOMETRY},
{this, "B7L1L_ODGeometryType", EGST_IDEALGEOMETRY},
{this, "A7L1U_ODGeometryType", EGST_IDEALGEOMETRY},
{this, "A7L1L_ODGeometryType", EGST_IDEALGEOMETRY},
{this, "A7R1U_ODGeometryType", EGST_IDEALGEOMETRY},
{this, "A7R1L_ODGeometryType", EGST_IDEALGEOMETRY},
{this, "B7R1U_ODGeometryType", EGST_IDEALGEOMETRY},
{this, "B7R1L_ODGeometryType", EGST_IDEALGEOMETRY}
}

Definition at line 83 of file ALFA_LocRec.h.

83 {
84 {this, "B7L1U_ODGeometryType", EGST_IDEALGEOMETRY},
85 {this, "B7L1L_ODGeometryType", EGST_IDEALGEOMETRY},
86 {this, "A7L1U_ODGeometryType", EGST_IDEALGEOMETRY},
87 {this, "A7L1L_ODGeometryType", EGST_IDEALGEOMETRY},
88 {this, "A7R1U_ODGeometryType", EGST_IDEALGEOMETRY},
89 {this, "A7R1L_ODGeometryType", EGST_IDEALGEOMETRY},
90 {this, "B7R1U_ODGeometryType", EGST_IDEALGEOMETRY},
91 {this, "B7R1L_ODGeometryType", EGST_IDEALGEOMETRY}
92 };

◆ m_pGeometryReader

ALFA_GeometryReader* ALFA_LocRec::m_pGeometryReader {new ALFA_GeometryReader()}
private

Definition at line 52 of file ALFA_LocRec.h.

52{new ALFA_GeometryReader()};

◆ m_pLocRecEvCollection

ALFA_LocRecEvCollection* ALFA_LocRec::m_pLocRecEvCollection {nullptr}
private

Definition at line 54 of file ALFA_LocRec.h.

54{nullptr};

◆ m_pLocRecODEvCollection

ALFA_LocRecODEvCollection* ALFA_LocRec::m_pLocRecODEvCollection {nullptr}
private

Definition at line 55 of file ALFA_LocRec.h.

55{nullptr};

◆ m_rpPosType

Gaudi::Property<int> ALFA_LocRec::m_rpPosType[RPOTSCNT]
private
Initial value:
{
{this, "B7L1U_PosType", ERPPT_ACTIVE},
{this, "B7L1L_PosType", ERPPT_ACTIVE},
{this, "A7L1U_PosType", ERPPT_ACTIVE},
{this, "A7L1L_PosType", ERPPT_ACTIVE},
{this, "A7R1U_PosType", ERPPT_ACTIVE},
{this, "A7R1L_PosType", ERPPT_ACTIVE},
{this, "B7R1U_PosType", ERPPT_ACTIVE},
{this, "B7R1L_PosType", ERPPT_ACTIVE}
}
@ ERPPT_ACTIVE

Definition at line 63 of file ALFA_LocRec.h.

63 {
64 {this, "B7L1U_PosType", ERPPT_ACTIVE},
65 {this, "B7L1L_PosType", ERPPT_ACTIVE},
66 {this, "A7L1U_PosType", ERPPT_ACTIVE},
67 {this, "A7L1L_PosType", ERPPT_ACTIVE},
68 {this, "A7R1U_PosType", ERPPT_ACTIVE},
69 {this, "A7R1L_PosType", ERPPT_ACTIVE},
70 {this, "B7R1U_PosType", ERPPT_ACTIVE},
71 {this, "B7R1L_PosType", ERPPT_ACTIVE}
72 };

◆ m_shiftToX97Pos

Gaudi::Property<bool> ALFA_LocRec::m_shiftToX97Pos {this, "ShiftToX97Pos", false}
private

Definition at line 60 of file ALFA_LocRec.h.

60{this, "ShiftToX97Pos", false};

◆ m_strAlgoMD

Gaudi::Property<std::string> ALFA_LocRec::m_strAlgoMD {this, "AlgoMD", "MDTracking"}
private

Definition at line 147 of file ALFA_LocRec.h.

147{this, "AlgoMD", "MDTracking"};

◆ m_strAlgoOD

Gaudi::Property<std::string> ALFA_LocRec::m_strAlgoOD {this, "AlgoOD", "ODTracking"}
private

Definition at line 146 of file ALFA_LocRec.h.

146{this, "AlgoOD", "ODTracking"};

◆ m_strCollectionName

std::string ALFA_LocRec::m_strCollectionName {"ALFA_DigitCollection"}
private

Definition at line 150 of file ALFA_LocRec.h.

150{"ALFA_DigitCollection"};

◆ m_strKeyGeometryForReco

std::string ALFA_LocRec::m_strKeyGeometryForReco {"ALFA_GeometryForReco"}
private

Definition at line 143 of file ALFA_LocRec.h.

143{"ALFA_GeometryForReco"};

◆ m_strKeyLocRecEvCollection

std::string ALFA_LocRec::m_strKeyLocRecEvCollection {"ALFA_LocRecEvCollection"}
private

Definition at line 148 of file ALFA_LocRec.h.

148{"ALFA_LocRecEvCollection"};

◆ m_strKeyLocRecODEvCollection

std::string ALFA_LocRec::m_strKeyLocRecODEvCollection {"ALFA_LocRecODEvCollection"}
private

Definition at line 149 of file ALFA_LocRec.h.

149{"ALFA_LocRecODEvCollection"};

◆ m_strODCollectionName

std::string ALFA_LocRec::m_strODCollectionName {"ALFA_ODDigitCollection"}
private

Definition at line 151 of file ALFA_LocRec.h.

151{"ALFA_ODDigitCollection"};

◆ m_varHandleArraysDeclared

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

Definition at line 387 of file AthCommonDataStore.h.

◆ m_vecListAlgoMD

Gaudi::Property<std::vector<std::string> > ALFA_LocRec::m_vecListAlgoMD {this, "ListAlgoMD", {}}
private

Definition at line 144 of file ALFA_LocRec.h.

144{this, "ListAlgoMD", {}};

◆ m_vecListAlgoOD

Gaudi::Property<std::vector<std::string> > ALFA_LocRec::m_vecListAlgoOD {this, "ListAlgoOD", {}}
private

Definition at line 145 of file ALFA_LocRec.h.

145{this, "ListAlgoOD", {}};

◆ m_vhka

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

Definition at line 386 of file AthCommonDataStore.h.


The documentation for this class was generated from the following files: