ATLAS Offline Software
PadTdsOfflineTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "GaudiKernel/ConcurrencyFlags.h"
6 
8 
9 namespace NSWL1 {
10 
11  class PadHits {
12  public:
14  std::shared_ptr<PadOfflineData> t_pad;
16 
17  PadHits(Identifier id, std::shared_ptr<PadOfflineData> p, int c)
18  : t_id (id),
19  t_pad (std::move(p)),
21  { }
22  };
23 
24 
25  bool order_padHits_with_increasing_time(const PadHits& i, const PadHits& j) { return i.t_pad->time() < j.t_pad->time(); }
26 
27  using PAD_MAP=std::map < Identifier,std::vector<PadHits> >;
28  using PAD_MAP_IT=std::map < Identifier,std::vector<PadHits> >::iterator;
29  using PAD_MAP_ITEM=std::pair< Identifier,std::vector<PadHits> >;
30 
31  //------------------------------------------------------------------------------
32  PadTdsOfflineTool::PadTdsOfflineTool( const std::string& type, const std::string& name, const IInterface* parent) :
34  {
35  declareInterface<NSWL1::IPadTdsTool>(this);
36  }
37  //------------------------------------------------------------------------------
39  ATH_MSG_DEBUG( "initializing " << name() );
40 
41  ATH_MSG_DEBUG( name() << " configuration:");
42  ATH_MSG_DEBUG(" " << std::setw(32) << std::setfill('.') << std::setiosflags(std::ios::left) << m_rndmEngineName.name() << m_rndmEngineName.value());
43  ATH_MSG_DEBUG(" " << std::setw(32) << std::setfill('.') << std::setiosflags(std::ios::left) << m_triggerCaptureWindow.name() << m_triggerCaptureWindow.value());
44  ATH_MSG_DEBUG(" " << std::setw(32) << std::setfill('.') << std::setiosflags(std::ios::left) << m_timeJitter.name() << m_timeJitter.value());
45  ATH_MSG_DEBUG(" " << std::setw(32) << std::setfill('.') << std::setiosflags(std::ios::left) << m_vmmTimeOverThreshold.name() << m_vmmTimeOverThreshold.value());
46  ATH_MSG_DEBUG(" " << std::setw(32) << std::setfill('.') << std::setiosflags(std::ios::left) << m_vmmShapingTime.name() << m_vmmShapingTime.value());
47  ATH_MSG_DEBUG(" " << std::setw(32) << std::setfill('.') << std::setiosflags(std::ios::left) << m_vmmDeadTime.name() << m_vmmDeadTime.value());
48 
51 
52  // retrieve the MuonDetectormanager
54 
55  // retrieve the Random Service
56  ATH_CHECK( m_rndmSvc.retrieve() );
57 
58  // retrieve the idHelper Service
59  ATH_CHECK(m_idHelperSvc.retrieve());
60 
61  return StatusCode::SUCCESS;
62  }
63 
64  StatusCode PadTdsOfflineTool::gather_pad_data(std::vector<std::shared_ptr<PadData>>& pads, int side, int sector) const {
65  ATH_MSG_DEBUG( "gather_pad_data: start gathering the PAD hits for side " << side << ", sector " << sector );
66  // check side and sector parameters
67  if ( side <-1 || side >1 ) {
68  ATH_MSG_ERROR( "requested side " << side << " is out of range: [-1==All, 0==side C, 1==side A]");
69  return StatusCode::FAILURE;
70  }
71 
72  if ( sector <-1 || sector >15 ) {
73  ATH_MSG_ERROR( "requested sector " << sector << " is out of range: [-1==All, 0 - 15]");
74  return StatusCode::FAILURE;
75  }
76 
77  std::vector< std::vector<std::shared_ptr<PadData>> > pad_cache(PadTdsOfflineTool::numberOfSectors());
78  ATH_CHECK(fill_pad_cache(pad_cache));
79 
80  // delivering the required collection
81  const bool anySide = (side==-1);
82  const bool anySector = (sector==-1);
83  if (anySide && anySector) {
84  //return the full set
85  ATH_MSG_DEBUG( "copying the full PAD hit set" );
87  std::vector<std::shared_ptr<PadData>>& pad_sec = pad_cache.at(i);
88  pads.insert( pads.end(), std::make_move_iterator(pad_sec.begin()), std::make_move_iterator(pad_sec.end()));
89  }
90  }
91  else if (anySector and not anySide) {
92  //return all the trigger sectors for the given side
93  ATH_MSG_DEBUG( "copying the PAD hit set of all trigger sector in side " << PadTdsOfflineTool::sideLabel(side) );
95  unsigned int stop = PadTdsOfflineTool::lastSector(side);
96  for (size_t i=start; i<stop; i++) {
97  std::vector<std::shared_ptr<PadData>>& pad_sec = pad_cache.at(i);
98  pads.insert( pads.end(), std::make_move_iterator(pad_sec.begin()), std::make_move_iterator(pad_sec.end()));
99  }
100  }
101  else if (anySide and not anySector) {
102  // return the required trigger sectors
103  ATH_MSG_DEBUG( "copying the PAD hit set of all trigger sector " << sector << " in both side" );
104  size_t sectorA = sector+PadTdsOfflineTool::firstSectorAside();
105  std::vector<std::shared_ptr<PadData>>& pad_secA = pad_cache.at(sectorA);
106  pads.insert( pads.end(), std::make_move_iterator(pad_secA.begin()), std::make_move_iterator(pad_secA.end()));
107 
108  size_t sectorC = sector+PadTdsOfflineTool::firstSectorCside();
109  std::vector<std::shared_ptr<PadData>>& pad_secC = pad_cache.at(sectorC);
110  pads.insert( pads.end(), std::make_move_iterator(pad_secC.begin()), std::make_move_iterator(pad_secC.end()));
111  }
112  else {
113  // return the required trigger sector
114  ATH_MSG_DEBUG("copying the PAD hit set of all trigger sector "<<sector
115  <<" in side "<<PadTdsOfflineTool::sideLabel(side));
116  size_t sectorAorC = PadTdsOfflineTool::sectorIndex(side, sector);
117  std::vector<std::shared_ptr<PadData>>& pad_secAorC = pad_cache.at(sectorAorC);
118  pads.insert( pads.end(), std::make_move_iterator(pad_secAorC.begin()), std::make_move_iterator(pad_secAorC.end()));
119  }
120  ATH_MSG_DEBUG( "delivered n. " << pads.size() << " PAD hits." );
121  pad_cache.clear();
122  return StatusCode::SUCCESS;
123  }
124  //------------------------------------------------------------------------------
125  StatusCode PadTdsOfflineTool::fill_pad_cache(std::vector< std::vector<std::shared_ptr<PadData>> > &pad_cache) const {
126  SG::ReadCondHandle<MuonGM::MuonDetectorManager> detManager{m_detManagerKey, Gaudi::Hive::currentContext()};
128  if(!digit_container.isValid()){
129  ATH_MSG_ERROR("could not retrieve the sTGC Digit container: cannot return the STRIP hits");
130  return StatusCode::FAILURE;
131  }
132 
133  sTgcDigitContainer::const_iterator it = digit_container->begin();
134  sTgcDigitContainer::const_iterator it_e = digit_container->end();
135  ATH_MSG_DEBUG("retrieved sTGC Digit Container with size "<<digit_container->digit_size());
136 
137  //int pad_hit_number = 0;
138  std::vector<PadHits> pad_hits;
139  uint16_t BC0 = 0, BCP1 = 1, BCP2 = 2, BCP3 = 3, BCP4 = 4, BCM1 = ~BCP1, BCM2 = ~BCP2, BCM3 = ~BCP3;
140  std::vector<uint16_t> bcWindow={BC0, BCP1, BCP2, BCP3, BCP4, BCM1, BCM2, BCM3};
141 
142  for(; it!=it_e; ++it) {
143  const sTgcDigitCollection* coll = *it;
144  ATH_MSG_DEBUG( "processing collection with size " << coll->size() );
145  for (unsigned int item=0; item<coll->size(); item++) {
146  const sTgcDigit* digit = coll->at(item);
147  if(digit) {
148  if(is_pad_digit(digit)) {
149  Identifier Id = digit->identify();
150  if (std::find(bcWindow.begin(), bcWindow.end(), digit->bcTag()) != bcWindow.end()){
152  //PadOfflineData* pad = new PadOfflineData(Id, digit->time(), digit->bcTag(), m_sTgcIdHelper);
153  //S.I
154  //std::shared_ptr<PadOfflineData> pad(new PadOfflineData(Id, digit->time(), digit->bcTag(), m_sTgcIdHelper));
155  auto pad=std::make_shared<PadOfflineData>(Id, digit->time(), digit->bcTag(), *detManager);
156  //pad_hits.push_back(PadHits(Id, pad, cache_index(digit)));
157  pad_hits.emplace_back(Id, pad, cache_index(digit));//avoids extra copy
158  //S.I
159  }
160  }
161  }
162  } //for(item)
163  } // for(it)
164 
165  store_pads(pad_hits, pad_cache);
166  print_pad_cache(pad_cache);
167  ATH_MSG_DEBUG( "fill_pad_cache: end of processing" );
168  return StatusCode::SUCCESS;
169  }
170  //------------------------------------------------------------------------------
172  SG::ReadCondHandle<MuonGM::MuonDetectorManager> detManager{m_detManagerKey, Gaudi::Hive::currentContext()};
173  Identifier Id = digit->identify();
174  const MuonGM::sTgcReadoutElement* rdoEl = detManager->getsTgcReadoutElement(Id);
175  Amg::Vector2D pad_lpos;
176  rdoEl->stripPosition(Id,pad_lpos);
177  Amg::Vector3D pad_gpos;
178  rdoEl->surface(Id).localToGlobal(pad_lpos, pad_gpos, pad_gpos);
179 
180  double distance = std::sqrt( pad_gpos.x()*pad_gpos.x() +
181  pad_gpos.y()*pad_gpos.y() +
182  pad_gpos.z()*pad_gpos.z() );
183  return distance * c_inverse;
184  }
185  //------------------------------------------------------------------------------
187  ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this, m_rndmEngineName);
188  CLHEP::HepRandomEngine * engine = rngWrapper->getEngine(Gaudi::Hive::currentContext());
189  return CLHEP::RandGauss::shoot(engine, 0, m_timeJitter);
190  }
191  //------------------------------------------------------------------------------
192  void PadTdsOfflineTool::simulateDeadTime(std::vector<PadHits>& h) const {
193 
194  // create a channel map and fill it
195  PAD_MAP channel_map;
196  for (unsigned int i=0; i<h.size(); i++) {
197  Identifier pad_id = h[i].t_id;
198  PAD_MAP_IT it = channel_map.find( pad_id );
199  if ( it!=channel_map.end() ) {
200  (*it).second.push_back(h[i]);
201  } else {
202  std::vector<PadHits> tmp;
203  tmp.push_back(h[i]);
204  channel_map.insert( PAD_MAP_ITEM(pad_id,tmp) );
205  }
206  }
207 
208  // vector are already ordered in time so check for dead time overlap.
209  PAD_MAP_IT it = channel_map.begin();
210  while ( it!=channel_map.end() ) {
211  std::vector<PadHits>& hits = (*it).second;
212  std::vector<PadHits>::iterator p_next = hits.begin();
214  while ( p_next!=hits.end() ) {
215  if (std::fabs((*p_next).t_pad->time()-(*p).t_pad->time())<=m_vmmDeadTime){
216  p_next = hits.erase(p_next);
217  }else{
218  p=p_next++;
219  }
220  }
221  }
222  //once cleared the overlapping PAD hits, refill the PAD hit vector
223  h.clear();
224  it = channel_map.begin();
225  while ( it!=channel_map.end() ) {
226  std::vector<PadHits> hits = (*it).second;
227  h.insert(h.end(),hits.begin(),hits.end());
228  ++it;
229  }
230  }
231  //------------------------------------------------------------------------------
233  {
234  return (digit && m_idHelperSvc->stgcIdHelper().channelType(digit->identify())==0);
235  }
236  //------------------------------------------------------------------------------
238  {
239  Identifier Id = digit->identify();
240  int stationEta = m_idHelperSvc->stgcIdHelper().stationEta(Id);
241  int stationPhi = m_idHelperSvc->stgcIdHelper().stationPhi(Id);
242  std::string stName = m_idHelperSvc->stgcIdHelper().stationNameString(m_idHelperSvc->stgcIdHelper().stationName(Id));
243  int isSmall = stName[2] == 'S';
244  int trigger_sector = (isSmall)? stationPhi*2-1 : stationPhi*2-2;
245  return (stationEta>0)? trigger_sector + 16 : trigger_sector;
246  }
247 
248  // FIXME: method not used anywhere, drop it?
249  //------------------------------------------------------------------------------
250  bool PadTdsOfflineTool::determine_delay_and_bc(const sTgcDigit* digit, const int pad_hit_number,
251  double &delayed_time, uint16_t &BCtag) const
252  {
253  bool success = false;
254  if(!digit) return success;
255  if(!is_pad_digit(digit)) return success;
256  double arrival_time = digit->time();
257  delayed_time = arrival_time;
258  if(m_applyTDS_TofSubtraction) delayed_time -= computeTof(digit);
260  double capture_time = delayed_time + m_triggerCaptureWindow;
261  if((delayed_time>200 || delayed_time<-200) ||
262  (capture_time>200 || capture_time<-200) ){
263  ATH_MSG_WARNING("sTGC Pad hit "<<pad_hit_number<<" time outside of the range -200 ns / +200 ns,"
264  " skipping it!");
265  ATH_MSG_WARNING("sTGC Pad hit "<<pad_hit_number<<": delayed time ["<<delayed_time<<" ns]"
266  " capture time ["<<capture_time<<" ns]");
267  return success;
268  }
269  for (unsigned int i=0; i<16; i++) {
270  double bunch_start = i*25;
271  double bunch_stop = (i+1)*25;
272  double signal_start = delayed_time + 200;
273  double signal_stop = capture_time + 200;
274  if ((signal_start>=bunch_start && signal_start<bunch_stop) ||
275  (signal_stop>=bunch_start && signal_stop<bunch_stop) ){
276  BCtag = BCtag | (0x1<<i);
277  continue;
278  }
279  if(bunch_start>=signal_start && bunch_stop<signal_stop){
280  BCtag = BCtag | (0x1<<i);
281  }
282  }
283  std::string bctag = "";
284  uint16_t last_bit = 0x8000;
285  for(unsigned int i=0; i<16; i++) {
286  if(BCtag & (last_bit>>i)) bctag += "1";
287  else bctag += "0";
288  }
289  ATH_MSG_DEBUG("sTGC Pad hit " << pad_hit_number << ": arrival time [" << arrival_time << " ns]"
290  << " delayed time [" << delayed_time << " ns]"
291  << " capture time [" << capture_time << " ns]"
292  << " BC tag [" << bctag << "]" );
293  success = true;
294  return success;
295  }
296  //------------------------------------------------------------------------------
297  bool PadTdsOfflineTool::get_truth_hits_this_pad(const Identifier &pad_id, std::vector<MuonSimData::Deposit> &deposits) const
298  {
299  bool success=false;
300  const MuonSimDataCollection* ptrMuonSimDataCollection = nullptr;
301  if(m_isMC) {
303  if(!sdo_container.isValid()) {
304  ATH_MSG_WARNING("could not retrieve the sTGC SDO container: it will not be possible to associate the MC truth");
305  return success;
306  }
307  ptrMuonSimDataCollection = sdo_container.cptr();
308  const MuonSimData pad_sdo = (ptrMuonSimDataCollection->find(pad_id))->second;
309  pad_sdo.deposits(deposits);
310  success = true;
311  }
312  return success;
313  }
314  //------------------------------------------------------------------------------
315  void PadTdsOfflineTool::store_pads(const std::vector<PadHits> &pad_hits, std::vector< std::vector<std::shared_ptr<PadData>> > &pad_cache) const
316  {
317  for (unsigned int i=0; i<pad_hits.size(); i++) {
318  const std::vector<std::shared_ptr<PadData>>& pads = pad_cache.at(pad_hits[i].t_cache_index);
319  bool fill = pads.empty();
320  for(unsigned int p=0; p<pads.size(); p++) {
321  Identifier Id(pads.at(p)->id());
322  if(Id==pad_hits[i].t_id) {
323  fill = false;
324  ATH_MSG_WARNING( "Pad Hits entered multiple times Discarding!!! Id:" << Id );
325  } else fill = true;
326  }
327  if( fill ) pad_cache.at(pad_hits[i].t_cache_index).push_back(pad_hits[i].t_pad);
328  }
329  }
330  //------------------------------------------------------------------------------
332  {
333  if(!is_pad_digit(digit)) return;
334  Identifier Id = digit->identify();
335  std::string stName = m_idHelperSvc->stgcIdHelper().stationNameString(m_idHelperSvc->stgcIdHelper().stationName(Id));
336  int stationEta = m_idHelperSvc->stgcIdHelper().stationEta(Id);
337  int stationPhi = m_idHelperSvc->stgcIdHelper().stationPhi(Id);
338  int multiplet = m_idHelperSvc->stgcIdHelper().multilayer(Id);
339  int gas_gap = m_idHelperSvc->stgcIdHelper().gasGap(Id);
340  int channel_type = m_idHelperSvc->stgcIdHelper().channelType(Id);
341  int channel = m_idHelperSvc->stgcIdHelper().channel(Id);
342  int pad_eta = m_idHelperSvc->stgcIdHelper().padEta(Id);
343  int pad_phi = m_idHelperSvc->stgcIdHelper().padPhi(Id);
344 
345  ATH_MSG_DEBUG("sTGC Pad hit:"
346  <<" cache index ["<<cache_index(digit)<<"]"
347  <<" Station Name [" <<stName <<"]"
348  <<" Station Eta [" <<stationEta <<"]"
349  <<" Station Phi [" <<stationPhi <<"]"
350  <<" Multiplet [" <<multiplet <<"]"
351  <<" GasGap [" <<gas_gap <<"]"
352  <<" Type [" <<channel_type <<"]"
353  <<" ChNr [" <<channel <<"]"
354  <<" Pad Eta [" <<pad_eta <<"]"
355  <<" Pad Phi [" <<pad_phi <<"]"
356  <<" BCTag [" <<digit->bcTag() <<"]"
357  <<" Id Hash [" <<Id <<"]");
358  }
359  //------------------------------------------------------------------------------
360  void PadTdsOfflineTool::print_pad_time(const std::vector<PadHits> &pad_hits) const
361  {
362  for (const auto &hit : pad_hits) ATH_MSG_DEBUG("pad hit has time "<< hit.t_pad->time());
363  }
364 
365  void PadTdsOfflineTool::print_pad_cache(std::vector< std::vector<std::shared_ptr<PadData>> > &pad_cache) const
366  {
367  for (const std::vector<std::shared_ptr<PadData>>& pad : pad_cache) {
368  for (const auto &padhit : pad)
369  ATH_MSG_DEBUG("PAD hit cache: hit at side " << ( (padhit->sideId())? "A":"C")
370  << ", trigger sector " << padhit->sectorId()
371  << ", module " << padhit->moduleId()
372  << ", multiplet " << padhit->multipletId()
373  << ", gas gap " << padhit->gasGapId()
374  << ", pad eta " << padhit->padEtaId()
375  << ", pad phi " << padhit->padPhiId());
376  }
377  }
378 
379 } // NSWL1
NSWL1::PadTdsOfflineTool::sideLabel
static char sideLabel(const int &side)
Definition: PadTdsOfflineTool.h:108
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
NSWL1::PadTdsOfflineTool::m_applyTDS_TimeJitterSubtraction
Gaudi::Property< bool > m_applyTDS_TimeJitterSubtraction
Definition: PadTdsOfflineTool.h:152
NSWL1::PadTdsOfflineTool::print_pad_time
void print_pad_time(const std::vector< PadHits > &pad_hits) const
Print time for each pad.
Definition: PadTdsOfflineTool.cxx:360
TRTCalib_Extractor.hits
hits
Definition: TRTCalib_Extractor.py:35
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:24
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
NSWL1::PadTdsOfflineTool::numberOfSectors
static size_t numberOfSectors()
Definition: PadTdsOfflineTool.h:98
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
SG::ReadHandle::cptr
const_pointer_type cptr()
Dereference the pointer.
NSWL1::PadTdsOfflineTool::computeTimeJitter
double computeTimeJitter() const
extract the time jitter t subtract from the PAD hit time
Definition: PadTdsOfflineTool.cxx:186
Amg::Vector2D
Eigen::Matrix< double, 2, 1 > Vector2D
Definition: GeoPrimitives.h:48
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
NSWL1::PadHits::PadHits
PadHits(Identifier id, std::shared_ptr< PadOfflineData > p, int c)
Definition: PadTdsOfflineTool.cxx:17
NSWL1::PadTdsOfflineTool::determine_delay_and_bc
bool determine_delay_and_bc(const sTgcDigit *digit, const int pad_hit_number, double &delayed_time, uint16_t &BCtag) const
Definition: PadTdsOfflineTool.cxx:250
NSWL1::PadTdsOfflineTool::lastSector
static size_t lastSector()
Definition: PadTdsOfflineTool.h:97
mergePhysValFiles.start
start
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:13
NSWL1::PAD_MAP
std::map< Identifier, std::vector< PadHits > > PAD_MAP
Definition: PadTdsOfflineTool.cxx:27
Muon::MuonStationIndex::stName
const std::string & stName(StIndex index)
convert StIndex into a string
Definition: MuonStationIndex.cxx:104
skel.it
it
Definition: skel.GENtoEVGEN.py:407
python.SystemOfUnits.second
float second
Definition: SystemOfUnits.py:135
NSWL1::PadTdsOfflineTool::m_triggerCaptureWindow
Gaudi::Property< float > m_triggerCaptureWindow
Definition: PadTdsOfflineTool.h:148
NSWL1::PadTdsOfflineTool::firstSectorAside
static size_t firstSectorAside()
Definition: PadTdsOfflineTool.h:100
PixelModuleFeMask_create_db.stop
int stop
Definition: PixelModuleFeMask_create_db.py:76
NSWL1::PadHits
Definition: PadTdsOfflineTool.cxx:11
checkRpcDigits.digit
digit
Definition: checkRpcDigits.py:186
NSWL1::order_padHits_with_increasing_time
bool order_padHits_with_increasing_time(const PadHits &i, const PadHits &j)
Definition: PadTdsOfflineTool.cxx:25
NSWL1::PadTdsOfflineTool::get_truth_hits_this_pad
bool get_truth_hits_this_pad(const Identifier &pad_id, std::vector< MuonSimData::Deposit > &deposits) const
Definition: PadTdsOfflineTool.cxx:297
MuonGM::MuonClusterReadoutElement::surface
virtual const Trk::PlaneSurface & surface() const override
access to chamber surface (phi orientation), uses the first gas gap
Definition: MuonClusterReadoutElement.h:123
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
NSWL1::PadTdsOfflineTool::cache_index
int cache_index(const sTgcDigit *digit) const
Definition: PadTdsOfflineTool.cxx:237
NSWL1::PadHits::t_id
Identifier t_id
Definition: PadTdsOfflineTool.cxx:13
NSWL1::PadTdsOfflineTool::m_vmmShapingTime
Gaudi::Property< float > m_vmmShapingTime
Definition: PadTdsOfflineTool.h:146
MuonGM::sTgcReadoutElement::stripPosition
virtual bool stripPosition(const Identifier &id, Amg::Vector2D &pos) const override final
strip position - should be renamed to channel position If the strip number is outside the range of va...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/sTgcReadoutElement.h:321
NSWL1::PadTdsOfflineTool::fill_pad_cache
StatusCode fill_pad_cache(std::vector< std::vector< std::shared_ptr< PadData >> > &pad_cache) const
Apply the additional processing then fill the cache, locally.
Definition: PadTdsOfflineTool.cxx:125
TRT::Hit::side
@ side
Definition: HitInfo.h:83
NSWL1::PadTdsOfflineTool::computeTof
double computeTof(const sTgcDigit *digit) const
compute the time of flight of particle giving the PAD hit
Definition: PadTdsOfflineTool.cxx:171
NSWL1::PadTdsOfflineTool::m_sTgcSdoContainer
SG::ReadHandleKey< MuonSimDataCollection > m_sTgcSdoContainer
Definition: PadTdsOfflineTool.h:158
sTgcDigit
Definition: sTgcDigit.h:20
NSWL1::PadTdsOfflineTool::gather_pad_data
virtual StatusCode gather_pad_data(std::vector< std::shared_ptr< PadData >> &pads, int side=-1, int sector=-1) const override
Definition: PadTdsOfflineTool.cxx:64
NSWL1::PadTdsOfflineTool::m_vmmDeadTime
Gaudi::Property< float > m_vmmDeadTime
Definition: PadTdsOfflineTool.h:147
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
MuonSimData::deposits
void deposits(std::vector< Deposit > &deposits) const
Definition: MuonSimData.h:99
NSWL1::PadTdsOfflineTool::firstSector
static size_t firstSector()
Definition: PadTdsOfflineTool.h:96
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
xAOD::uint16_t
setWord1 uint16_t
Definition: eFexEMRoI_v1.cxx:93
lumiFormat.i
int i
Definition: lumiFormat.py:85
sTgcDigitCollection
Definition: sTgcDigitCollection.h:18
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
NSWL1::PadTdsOfflineTool::m_sTgcDigitContainer
SG::ReadHandleKey< sTgcDigitContainer > m_sTgcDigitContainer
Definition: PadTdsOfflineTool.h:157
NSWL1::PadTdsOfflineTool::m_isMC
Gaudi::Property< bool > m_isMC
Definition: PadTdsOfflineTool.h:143
MuonGM::sTgcReadoutElement
An sTgcReadoutElement corresponds to a single STGC module; therefore typicaly a barrel muon station c...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/sTgcReadoutElement.h:30
MuonSimDataCollection
Definition: MuonSimDataCollection.h:21
NSWL1::PadHits::t_pad
std::shared_ptr< PadOfflineData > t_pad
Definition: PadTdsOfflineTool.cxx:14
NSWL1::PadTdsOfflineTool::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: PadTdsOfflineTool.h:139
NSWL1::PadTdsOfflineTool::m_rndmSvc
ServiceHandle< IAthRNGSvc > m_rndmSvc
Random number generator engine to use.
Definition: PadTdsOfflineTool.h:138
test_pyathena.parent
parent
Definition: test_pyathena.py:15
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
IdentifiableContainerMT::end
const_iterator end() const
return const_iterator for end of container
Definition: IdentifiableContainerMT.h:239
NSWL1::PadTdsOfflineTool::sectorIndex
static size_t sectorIndex(const int &side, const int &sector)
internal index.
Definition: PadTdsOfflineTool.h:111
NSWL1::PAD_MAP_ITEM
std::pair< Identifier, std::vector< PadHits > > PAD_MAP_ITEM
Definition: PadTdsOfflineTool.cxx:29
IdentifiableContainerMT::const_iterator
Definition: IdentifiableContainerMT.h:79
sTgcDigitContainer::digit_size
size_type digit_size() const
Definition: sTgcDigitContainer.cxx:55
IdentifiableContainerMT::begin
const_iterator begin() const
return const_iterator for first entry
Definition: IdentifiableContainerMT.h:233
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
DeMoUpdate.tmp
string tmp
Definition: DeMoUpdate.py:1167
NSWL1::PadTdsOfflineTool::PadTdsOfflineTool
PadTdsOfflineTool(const std::string &type, const std::string &name, const IInterface *parent)
Definition: PadTdsOfflineTool.cxx:32
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
PadTdsOfflineTool.h
NSWL1::PadTdsOfflineTool::m_applyTDS_TofSubtraction
Gaudi::Property< bool > m_applyTDS_TofSubtraction
Definition: PadTdsOfflineTool.h:151
padhit
Definition: MuonFeatureDetails_p2.h:16
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:239
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
NSWL1::PadTdsOfflineTool::m_timeJitter
Gaudi::Property< float > m_timeJitter
Definition: PadTdsOfflineTool.h:149
ATHRNG::RNGWrapper
A wrapper class for event-slot-local random engines.
Definition: RNGWrapper.h:56
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
NSWL1::PadTdsOfflineTool::print_pad_cache
void print_pad_cache(std::vector< std::vector< std::shared_ptr< PadData >> > &pad_cache) const
Print all info stored in the pad cache.
Definition: PadTdsOfflineTool.cxx:365
MuonSimData
Definition: MuonSimData.h:62
item
Definition: ItemListSvc.h:43
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
ATHRNG::RNGWrapper::getEngine
CLHEP::HepRandomEngine * getEngine(const EventContext &ctx) const
Retrieve the random engine corresponding to the provided EventContext.
Definition: RNGWrapper.h:134
Muon::nsw::channel_type
channel_type
Definition: NSWDecodeHelper.h:21
NSWL1::PAD_MAP_IT
std::map< Identifier, std::vector< PadHits > >::iterator PAD_MAP_IT
Definition: PadTdsOfflineTool.cxx:28
h
lumiFormat.fill
fill
Definition: lumiFormat.py:104
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
NSWL1::PadTdsOfflineTool::m_detManagerKey
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager > m_detManagerKey
Definition: PadTdsOfflineTool.h:140
NSWL1::PadHits::t_cache_index
int t_cache_index
Definition: PadTdsOfflineTool.cxx:15
NSWL1::PadTdsOfflineTool::initialize
virtual StatusCode initialize() override
Definition: PadTdsOfflineTool.cxx:38
NSWL1::c_inverse
const double c_inverse
Definition: tdr_compat_enum.h:13
NSWL1::PadTdsOfflineTool::m_vmmTimeOverThreshold
Gaudi::Property< float > m_vmmTimeOverThreshold
Definition: PadTdsOfflineTool.h:145
DataVector::at
const T * at(size_type n) const
Access an element, as an rvalue.
AthAlgTool
Definition: AthAlgTool.h:26
Trk::PlaneSurface::localToGlobal
virtual void localToGlobal(const Amg::Vector2D &locp, const Amg::Vector3D &mom, Amg::Vector3D &glob) const override final
Specified for PlaneSurface: LocalToGlobal method without dynamic memory allocation.
Definition: PlaneSurface.cxx:198
NSWL1::PadTdsOfflineTool::m_rndmEngineName
Gaudi::Property< std::string > m_rndmEngineName
Definition: PadTdsOfflineTool.h:144
NSWL1::PadTdsOfflineTool::store_pads
void store_pads(const std::vector< PadHits > &pad_hits, std::vector< std::vector< std::shared_ptr< PadData >> > &pad_cache) const
Store pad data in the cache.
Definition: PadTdsOfflineTool.cxx:315
NSWL1::PadTdsOfflineTool::is_pad_digit
bool is_pad_digit(const sTgcDigit *digit) const
Definition: PadTdsOfflineTool.cxx:232
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54
NSWL1
A trigger trigger candidate for a stgc sector.
Definition: NSWL1Simulation.cxx:7
python.compressB64.c
def c
Definition: compressB64.py:93
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
NSWL1::PadTdsOfflineTool::firstSectorCside
static size_t firstSectorCside()
Definition: PadTdsOfflineTool.h:102
NSWL1::PadTdsOfflineTool::print_digit
void print_digit(const sTgcDigit *digit) const
Definition: PadTdsOfflineTool.cxx:331
Muon::MuonStationIndex::isSmall
bool isSmall(const ChIndex index)
Returns true if the chamber index is in a small sector.
NSWL1::PadTdsOfflineTool::simulateDeadTime
void simulateDeadTime(std::vector< PadHits > &h) const
simulate the dead time of the VMM
Definition: PadTdsOfflineTool.cxx:192
Identifier
Definition: IdentifierFieldParser.cxx:14