ATLAS Offline Software
Public Member Functions | Static Public Member Functions | Private Member Functions | Private Attributes | Friends | List of all members
VP1Trig::VP1TriggerHandleEF Class Reference

#include <VP1TriggerHandleEF.h>

Inheritance diagram for VP1Trig::VP1TriggerHandleEF:
Collaboration diagram for VP1Trig::VP1TriggerHandleEF:

Public Member Functions

 VP1TriggerHandleEF (const TrigMuonEFInfo *containerEF, QString trigID, QList< QString > chainIDs)
 
void log_info (const QString &msg)
 
void log_warning (const QString &msg)
 
void log_verbose (const QString &msg)
 
void log_error (const QString &msg)
 
void log_fatal (const QString &msg)
 
void log_debug (const QString &msg)
 
std::string prefix (std::string str)
 
QString qstr (char c)
 
QString qstr (std::string str)
 

Static Public Member Functions

static const QString pfx1 ()
 
static const QString pfx2 ()
 
static const QString pfx3 ()
 

Private Member Functions

bool processQTrigItem ()
 
bool processVTrigItem ()
 
bool loadTrackContainer ()
 
void loadMuonTrack (int trackNo, QString type)
 
double muonTrackData (QString type, int id)
 

Private Attributes

const TrigMuonEFInfo * m_containerEF
 
QString m_trigID
 
QList< QString > m_chainIDs
 
QTreeWidgetItem * m_qtrigData
 
std::vector< std::vector< QString > > m_trigData
 
bool m_qtrigstatus
 
bool m_vtrigstatus
 
std::string m_name
 
int m_lvl
 

Friends

class VP1TriggerProcessor
 

Detailed Description

Definition at line 30 of file VP1TriggerHandleEF.h.

Constructor & Destructor Documentation

◆ VP1TriggerHandleEF()

VP1Trig::VP1TriggerHandleEF::VP1TriggerHandleEF ( const TrigMuonEFInfo *  containerEF,
QString  trigID,
QList< QString >  chainIDs 
)
inline

Definition at line 33 of file VP1TriggerHandleEF.h.

34  : Logger("TriggerHandleEF"),
35  m_containerEF(containerEF),
36  m_trigID(trigID),
37  m_chainIDs(chainIDs),
38  m_qtrigData(0),
39  m_trigData(0),
40  m_qtrigstatus(false),
41  m_vtrigstatus(false) {};

Member Function Documentation

◆ loadMuonTrack()

void VP1Trig::VP1TriggerHandleEF::loadMuonTrack ( int  trackNo,
QString  type 
)
private

Definition at line 235 of file VP1TriggerHandleEF.cxx.

236 {
237  //PROCESS TRACK DATA AND STORE IN TEMP. VECTOR ---------------------------->
238  std::vector<QString> data;
239 
240  for(int i=0; i < int(sizeof muonTrackName/sizeof(std::string)); ++i) {
241  if(trackNo==0) h_id.push_back(QString::fromStdString(muonTrackName[i]));
242  if(muonTrackName[i]=="Theta") {
243  double cotTh = muonTrackData(type,i);
244  if(cotTh!=0) data.push_back(QString::number((M_PI_2)-std::atan(1/cotTh)));
245  else data.push_back(QString::number((M_PI_2)-std::atan(10^10)));
246  }
247  else {
248  data.push_back(QString::number(muonTrackData(type,i)));
249  }
250  }
251  //-------------------------------------------------------------------------<
252 
253  //LOAD HEADER TYPE, SOURCE AND DATA TO TEMP. VECTORS ---------------------->
254  if(int(data.size())!=0) {
255  if(type=="s_mef") { //SpectrometerTrack - MuonEF
256  //Header Update
257  h_type.push_back("MuonEF");
258  h_source.push_back("SpectrometerTrack");
259  //Track Update
260  t_data.push_back(data);
261  ++count_mef;
262  }
263  else if(type=="s_mg") { //SpectrometerTrack - MuGirl
264  //Header Update
265  h_type.push_back("MuGirl");
266  h_source.push_back("SpectrometerTrack");
267  //Track Update
268  t_data.push_back(data);
269  ++count_mg;
270  }
271  else if(type=="e_mef") { //ExtrapolatedTrack - MuonEF
272  //Header Update
273  h_type.push_back("MuonEF");
274  h_source.push_back("ExtrapolatedTrack");
275  //Track Update
276  t_data.push_back(data);
277  ++count_mef;
278  }
279  else if(type=="e_mg") { //ExtrapolatedTrack - MuGirl
280  //Header Update
281  h_type.push_back("MuGirl");
282  h_source.push_back("ExtrapolatedTrack");
283  //Track Update
284  t_data.push_back(data);
285  ++count_mg;
286  }
287  else if(type=="c_mef") { //CombinedTrack - MuonEF
288  //Header Update
289  h_type.push_back("MuonEF");
290  h_source.push_back("CombinedTrack");
291  //Track Update
292  t_data.push_back(data);
293  ++count_mef;
294  }
295  else if(type=="c_mg") { //CombinedTrack - MuGirl
296  //Header Update
297  h_type.push_back("MuGirl");
298  h_source.push_back("CombinedTrack");
299  //Track Update
300  t_data.push_back(data);
301  ++count_mg;
302  }
303  else
304  log_error("loadMuonTrack(): invalid type!");
305  }//data available
306  else
307  log_error("loadMuonTrack(): no data available!");
308  //-------------------------------------------------------------------------<
309 }//END: loadMuonTrack

◆ loadTrackContainer()

bool VP1Trig::VP1TriggerHandleEF::loadTrackContainer ( )
private

Definition at line 139 of file VP1TriggerHandleEF.cxx.

140 {
141  //VARs
142  int mt=0; //muon flag: type id
143  QString type="_"; //muon flag: type name
144  int trackNo=0;
145 
146  //Resets
147  h_type.clear();
148  h_source.clear();
149  h_id.clear();
150  t_data.clear();
151  m_trigData.clear();
152  count_mef=0;
153  count_mg=0;
154 
155  if(m_containerEF->hasTrack()) { //Muon in RoI
156  const TrigMuonEFInfoTrackContainer *tc = m_containerEF->TrackContainer(); //TrackContainer: more than one muon in RoI
157  TrigMuonEFInfoTrackContainer::const_iterator TrackItr;
158 
159  for(TrackItr = tc->begin(); TrackItr!=tc->end(); ++TrackItr) {
160  const TrigMuonEFInfoTrack* muonInfo = (*TrackItr);
161  mt = int(muonInfo->MuonType()); //<1> MuonEF, <2> MuGirl
162 
163  //Safety check
164  if(mt!=1 && mt!=2) {
165  log_error("loadTrackContainer(): invalid muon type flag found: "+VP1String::str(mt));
166  return false;
167  }
168 
169  //-----------------------------------------------------------------------
170  muonEFTrack = muonInfo->SpectrometerTrack();
171  if(mt==1) type="s_mef"; //-> (S)pec. (M)uon(EF)
172  else if(mt==2) type="s_mg"; //-> (S)pec. (M)u(G)irl
173 
174  if(muonEFTrack)
175  loadMuonTrack(trackNo++,type);
176  else
177  log_info("loadTrackContainer(): no SpectrometerTrack found");
178 
179  //-----------------------------------------------------------------------
180  muonEFTrack = muonInfo->ExtrapolatedTrack();
181  if(mt==1) type="e_mef"; //-> (E)xtra. (M)uon(EF)
182  else if(mt==2) type="e_mg"; //-> (E)xtra. (M)u(G)irl
183 
184  if(muonEFTrack)
185  loadMuonTrack(trackNo++,type);
186  else
187  log_info("loadTrackContainer(): no ExtrapolatedTrack found");
188 
189  //-----------------------------------------------------------------------
190  muonEFCbTrack = muonInfo->CombinedTrack();
191  if(mt==1) type="c_mef"; //-> (C)omb. (M)uon(EF)
192  else if(mt==2) type="c_mg"; //-> (C)omb. (M)u(G)irl
193 
194  if(muonEFCbTrack)
195  loadMuonTrack(trackNo++,type);
196  else
197  log_info("loadTrackContainer(): no CombinedTrack found");
198  }//loop
199 
200  //ASSIGN DATA STRUCTURE AND EXPORT TO EF TRIGGER HANDLE DATA VECTOR ------->
201  /*************************************************************
202  < HEADER > < TRACK DATA ... >
203  | | | | |
204  TYPE SOURCE ID DATA - DATA - ...
205 
206  TYPE: MuonEF, MuGirl
207  [y-y correspondence to SOURCE]
208  SOURCE: SpectrometerTrack, ExtrapolatedTrack, CombinedTrack
209  [y-x correspondence to DATA]
210  ID: Charge, iPT, etc.
211  [y-y correspondence to DATA]
212  DATA: values corresponding to ID
213  *************************************************************/
214  if(int(h_type.size())!=0 && int(h_source.size())!=0 && int(h_id.size())!=0 && int(t_data.size())!=0 && int(m_trigData.size())==0) {
215  if(int(h_type.size())==int(h_source.size()) && int(h_source.size())==int(t_data.size())) {
216  m_trigData.push_back(h_type);
217  m_trigData.push_back(h_source);
218  m_trigData.push_back(h_id);
219  for(int q=0; q<int(t_data.size()); ++q)
220  m_trigData.push_back(t_data[q]);
221  return true;
222  }//size match
223  }//data available
224  //-------------------------------------------------------------------------<
225  return false;
226  }//hasTrack
227  else
228  log_warning("loadTrackContainer(): no tracks found in EF container.");
229  return false;
230 }//END: loadTrackContainer

◆ log_debug()

void VP1Trig::Logger::log_debug ( const QString &  msg)
inherited

Definition at line 54 of file graphics/VP1/VP1Systems/VP1TriggerSystems/src/Logger.cxx.

54  {
55  std::cout<<prefix(m_name)<<"DEBUG "<<msg.toStdString()<<std::endl;
56 }

◆ log_error()

void VP1Trig::Logger::log_error ( const QString &  msg)
inherited

Definition at line 46 of file graphics/VP1/VP1Systems/VP1TriggerSystems/src/Logger.cxx.

46  {
47  std::cout<<prefix(m_name)<<"ERROR "<<msg.toStdString()<<std::endl;
48 }

◆ log_fatal()

void VP1Trig::Logger::log_fatal ( const QString &  msg)
inherited

Definition at line 49 of file graphics/VP1/VP1Systems/VP1TriggerSystems/src/Logger.cxx.

49  {
50  std::cout<<prefix(m_name)<<"FATAL "<<msg.toStdString()<<std::endl;
51 }

◆ log_info()

void VP1Trig::Logger::log_info ( const QString &  msg)
inherited

Definition at line 32 of file graphics/VP1/VP1Systems/VP1TriggerSystems/src/Logger.cxx.

32  {
33  if(m_lvl>=1)
34  std::cout<<prefix(m_name)<<"INFO "<<msg.toStdString()<<std::endl;
35 }

◆ log_verbose()

void VP1Trig::Logger::log_verbose ( const QString &  msg)
inherited

Definition at line 40 of file graphics/VP1/VP1Systems/VP1TriggerSystems/src/Logger.cxx.

40  {
41  if(m_lvl>=3)
42  std::cout<<prefix(m_name)<<"VERBOSE "<<msg.toStdString()<<std::endl;
43 }

◆ log_warning()

void VP1Trig::Logger::log_warning ( const QString &  msg)
inherited

Definition at line 36 of file graphics/VP1/VP1Systems/VP1TriggerSystems/src/Logger.cxx.

36  {
37  if(m_lvl>=2)
38  std::cout<<prefix(m_name)<<"WARNING "<<msg.toStdString()<<std::endl;
39 }

◆ muonTrackData()

double VP1Trig::VP1TriggerHandleEF::muonTrackData ( QString  type,
int  id 
)
private

Definition at line 79 of file VP1TriggerHandleEF.cxx.

80 {
81  double data=-101;
82 
83  if(type=="s_mef" || type=="s_mg" || type=="e_mef" || type=="e_mg") {
84  switch(id)
85  {
86  case 0: data = muonEFTrack->Charge(); break;
87  case 1: data = muonEFTrack->iPt(); break;
88  case 2: data = muonEFTrack->cotTh(); break;
89  case 3: data = muonEFTrack->phi(); break;
90  case 4: data = muonEFTrack->m(); break;
91  case 5: data = muonEFTrack->chi2(); break;
92  case 6: data = muonEFTrack->chi2prob(); break;
93  case 7: data = muonEFTrack->posX(); break;
94  case 8: data = muonEFTrack->posY(); break;
95  case 9: data = muonEFTrack->posZ(); break;
96  case 10: data = muonEFTrack->NCscHitsEta(); break;
97  case 11: data = muonEFTrack->NCscHitsPhi(); break;
98  case 12: data = muonEFTrack->NTgcHitsEta(); break;
99  case 13: data = muonEFTrack->NTgcHitsPhi(); break;
100  case 14: data = muonEFTrack->NRpcHitsEta(); break;
101  case 15: data = muonEFTrack->NRpcHitsPhi(); break;
102  case 16: data = muonEFTrack->d0(); break;
103  case 17: data = muonEFTrack->z0(); break;
104  default: data = -102;
105  }
106  } else if(type=="c_mef" || type=="c_mg") {
107  switch(id)
108  {
109  case 0: data = muonEFCbTrack->Charge(); break;
110  case 1: data = muonEFCbTrack->iPt(); break;
111  case 2: data = muonEFCbTrack->cotTh(); break;
112  case 3: data = muonEFCbTrack->phi(); break;
113  case 4: data = muonEFCbTrack->m(); break;
114  case 5: data = muonEFCbTrack->chi2(); break;
115  case 6: data = muonEFCbTrack->chi2prob(); break;
116  case 7: data = muonEFCbTrack->posX(); break;
117  case 8: data = muonEFCbTrack->posY(); break;
118  case 9: data = muonEFCbTrack->posZ(); break;
119  case 10: data = muonEFCbTrack->NCscHitsEta(); break;
120  case 11: data = muonEFCbTrack->NCscHitsPhi(); break;
121  case 12: data = muonEFCbTrack->NTgcHitsEta(); break;
122  case 13: data = muonEFCbTrack->NTgcHitsPhi(); break;
123  case 14: data = muonEFCbTrack->NRpcHitsEta(); break;
124  case 15: data = muonEFCbTrack->NRpcHitsPhi(); break;
125  case 16: data = muonEFCbTrack->d0(); break;
126  case 17: data = muonEFCbTrack->z0(); break;
127  default: data = -103;
128  }
129  }
130  else
131  log_error("muonTrackData(): invalid type!");
132 
133  return data;
134 }//END: muonTrackData

◆ pfx1()

static const QString VP1Trig::Logger::pfx1 ( )
inlinestaticinherited

Definition at line 65 of file graphics/VP1/VP1Systems/VP1TriggerSystems/VP1TriggerSystems/Logger.h.

◆ pfx2()

static const QString VP1Trig::Logger::pfx2 ( )
inlinestaticinherited

Definition at line 66 of file graphics/VP1/VP1Systems/VP1TriggerSystems/VP1TriggerSystems/Logger.h.

◆ pfx3()

static const QString VP1Trig::Logger::pfx3 ( )
inlinestaticinherited

Definition at line 67 of file graphics/VP1/VP1Systems/VP1TriggerSystems/VP1TriggerSystems/Logger.h.

◆ prefix()

std::string VP1Trig::Logger::prefix ( std::string  str)
inherited

Definition at line 61 of file graphics/VP1/VP1Systems/VP1TriggerSystems/src/Logger.cxx.

62 {
63  //15 character prefix standard
64  if(int(str.size())>15) {
65  str=str.substr(0,15);
66  str=str+std::string("... ");
67  return str;
68  }
69  else if(int(str.size())==15) {
70  str=str+std::string(" ");
71  return str;
72  }
73  int q=21-int(str.size());
74  for(int i=0;i<q;++i)
75  str=str+std::string(" ");
76  return str;
77 }

◆ processQTrigItem()

bool VP1Trig::VP1TriggerHandleEF::processQTrigItem ( )
private

Definition at line 314 of file VP1TriggerHandleEF.cxx.

315 {
316  //Query TrackContainer and store
317  //data to corresponding vectors
318  bool status = loadTrackContainer();
319 
320  if(status) {
321  //VARs
322  m_qtrigData = new QTreeWidgetItem(0);
323  m_qtrigData->setText(0, QString(m_trigID));
324  int avail=0;
325 
326  //DEFs
327  QString sep = " = ";
328  int TWIDTH = int(m_trigData.size())-HWIDTH;
329 
330  if(int(m_trigData.size())>HWIDTH) {
331  if(int(m_trigData[TYPIDX].size())==int(m_trigData[SRCIDX].size()) && int(m_trigData[SRCIDX].size())==TWIDTH) {
332 
333  //### chainIDs ### >>>
334  if(!(m_chainIDs.isEmpty())) {
335  QTreeWidgetItem* chain = new QTreeWidgetItem(m_qtrigData);
336  chain->setText(0, QString("Passed Triggers"));
337  QList<QTreeWidgetItem *> chainItems;
338  for(int i=0; i < int(m_chainIDs.size()); ++i)
339  chainItems.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(m_chainIDs[i])));
340  chain->insertChildren(0, chainItems);
341  }//chain data available
342 
343  //### EF ### >>>>
344  if(count_mef!=0) {
345  QTreeWidgetItem* eftree = new QTreeWidgetItem(m_qtrigData);
346  eftree->setText(0, QString("Muon Type 1 -> EF"));
347 
348  for(int i=0; i<TWIDTH; ++i) {
349  if(m_trigData[TYPIDX][i].contains("MuonEF") && m_trigData[SRCIDX][i].contains("Spectrometer")) {
350  QTreeWidgetItem* eftree_s = new QTreeWidgetItem(eftree);
351  eftree_s->setText(0, QString("Spectrometer Track-")+QString::number(i+1));
352  QList<QTreeWidgetItem *> efitem_s;
353  for(int j=0; j < int(m_trigData[i+HWIDTH].size()); ++j) {
354  efitem_s.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(m_trigData[TIDIDX][j]+sep+m_trigData[i+HWIDTH][j])));
355  }
356  eftree_s->insertChildren(0, efitem_s);
357  }
358  }//loop
359 
360  for(int i=0; i<TWIDTH; ++i) {
361  if(m_trigData[TYPIDX][i].contains("MuonEF") && m_trigData[SRCIDX][i].contains("Extrapolated")) {
362  QTreeWidgetItem* eftree_e = new QTreeWidgetItem(eftree);
363  eftree_e->setText(0, QString("Extrapolated Track-")+QString::number(i+1));
364  QList<QTreeWidgetItem *> efitem_e;
365  for(int j=0; j < int(m_trigData[i+HWIDTH].size()); ++j) {
366  efitem_e.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(m_trigData[TIDIDX][j]+sep+m_trigData[i+HWIDTH][j])));
367  }
368  eftree_e->insertChildren(0, efitem_e);
369  }
370  }//loop
371 
372  for(int i=0; i<TWIDTH; ++i) {
373  if(m_trigData[TYPIDX][i].contains("MuonEF") && m_trigData[SRCIDX][i].contains("Combined")) {
374  QTreeWidgetItem* eftree_c = new QTreeWidgetItem(eftree);
375  eftree_c->setText(0, QString("Combined Track-")+QString::number(i+1));
376  QList<QTreeWidgetItem *> efitem_c;
377  for(int j=0; j < int(m_trigData[i+HWIDTH].size()); ++j) {
378  efitem_c.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(m_trigData[TIDIDX][j]+sep+m_trigData[i+HWIDTH][j])));
379  }
380  eftree_c->insertChildren(0, efitem_c);
381  }
382  }//loop
383  ++avail;
384  }//mef data available
385 
386  //### MuonGirl ### >>>
387  if(count_mg!=0) {
388  QTreeWidgetItem* mgtree = new QTreeWidgetItem(m_qtrigData);
389  mgtree->setText(0, QString("Muon Type 2 -> MuGirl"));
390 
391  for(int i=0; i<TWIDTH; ++i) {
392  if(m_trigData[TYPIDX][i].contains("MuGirl") && m_trigData[SRCIDX][i].contains("Spectrometer")) {
393  QTreeWidgetItem* mgtree_s = new QTreeWidgetItem(mgtree);
394  mgtree_s->setText(0, QString("Spectrometer Track-")+QString::number(i+1));
395  QList<QTreeWidgetItem *> mgitem_s;
396  for(int j=0; j < int(m_trigData[i+HWIDTH].size()); ++j) {
397  mgitem_s.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(m_trigData[TIDIDX][j]+sep+m_trigData[i+HWIDTH][j])));
398  }
399  mgtree_s->insertChildren(0, mgitem_s);
400  }
401  }//loop
402 
403  for(int i=0; i<TWIDTH; ++i) {
404  if(m_trigData[TYPIDX][i].contains("MuGirl") && m_trigData[SRCIDX][i].contains("Extrapolated")) {
405  QTreeWidgetItem* mgtree_e = new QTreeWidgetItem(mgtree);
406  mgtree_e->setText(0, QString("Extrapolated Track-")+QString::number(i+1));
407  QList<QTreeWidgetItem *> mgitem_e;
408  for(int j=0; j < int(m_trigData[i+HWIDTH].size()); ++j) {
409  mgitem_e.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(m_trigData[TIDIDX][j]+sep+m_trigData[i+HWIDTH][j])));
410  }
411  mgtree_e->insertChildren(0, mgitem_e);
412  }
413  }//loop
414 
415  for(int i=0; i<TWIDTH; ++i) {
416  if(m_trigData[TYPIDX][i].contains("MuGirl") && m_trigData[SRCIDX][i].contains("Combined")) {
417  QTreeWidgetItem* mgtree_c = new QTreeWidgetItem(mgtree);
418  mgtree_c->setText(0, QString("Combined Track-")+QString::number(i+1));
419  QList<QTreeWidgetItem *> mgitem_c;
420  for(int j=0; j < int(m_trigData[i+HWIDTH].size()); ++j) {
421  mgitem_c.append(new QTreeWidgetItem((QTreeWidget*)0, QStringList(m_trigData[TIDIDX][j]+sep+m_trigData[i+HWIDTH][j])));
422  }
423  mgtree_c->insertChildren(0, mgitem_c);
424  }
425  }//loop
426  ++avail;
427  }// mg data available
428 
429  }//size match check
430  }//simple size check
431 
432  //Data available
433  if(avail>0) m_qtrigstatus=true;
434  else {
435  log_error("processQTrigItem(): EF data not available!");
436  m_qtrigstatus=false;
437  }
438 
439  }//status
440  else
441  m_qtrigstatus=false;
442 
443  return m_qtrigstatus;
444 }//END: processQTrigItem

◆ processVTrigItem()

bool VP1Trig::VP1TriggerHandleEF::processVTrigItem ( )
private

Definition at line 449 of file VP1TriggerHandleEF.cxx.

450 {
451  //Query TrackContainer and store
452  //data to corresponding vectors
453  bool status = loadTrackContainer();
454 
455  if(status) {
456  if(int(m_trigData.size())>3 && int(m_trigData[0].size())==int(m_trigData[1].size()) && int(m_trigData[1].size())==(int(m_trigData.size())-3))
457  m_vtrigstatus=true;
458  }
459  else
460  m_vtrigstatus=false;
461 
462  return m_vtrigstatus;
463 }//END: processVTrigItem

◆ qstr() [1/2]

QString VP1Trig::Logger::qstr ( char  c)
inherited

Definition at line 82 of file graphics/VP1/VP1Systems/VP1TriggerSystems/src/Logger.cxx.

83 {
84  std::stringstream ss; ss<<c;
85  std::string cStr=ss.str();
86  ss.str(std::string()); ss.clear();
87  return QString::fromStdString(cStr);
88 }

◆ qstr() [2/2]

QString VP1Trig::Logger::qstr ( std::string  str)
inherited

Definition at line 93 of file graphics/VP1/VP1Systems/VP1TriggerSystems/src/Logger.cxx.

94 {
95  return QString::fromStdString(str);
96 }

Friends And Related Function Documentation

◆ VP1TriggerProcessor

friend class VP1TriggerProcessor
friend

Definition at line 45 of file VP1TriggerHandleEF.h.

Member Data Documentation

◆ m_chainIDs

QList<QString> VP1Trig::VP1TriggerHandleEF::m_chainIDs
private

Definition at line 51 of file VP1TriggerHandleEF.h.

◆ m_containerEF

const TrigMuonEFInfo* VP1Trig::VP1TriggerHandleEF::m_containerEF
private

Definition at line 49 of file VP1TriggerHandleEF.h.

◆ m_lvl

int VP1Trig::Logger::m_lvl
privateinherited

Definition at line 71 of file graphics/VP1/VP1Systems/VP1TriggerSystems/VP1TriggerSystems/Logger.h.

◆ m_name

std::string VP1Trig::Logger::m_name
privateinherited

Definition at line 70 of file graphics/VP1/VP1Systems/VP1TriggerSystems/VP1TriggerSystems/Logger.h.

◆ m_qtrigData

QTreeWidgetItem* VP1Trig::VP1TriggerHandleEF::m_qtrigData
private

Definition at line 65 of file VP1TriggerHandleEF.h.

◆ m_qtrigstatus

bool VP1Trig::VP1TriggerHandleEF::m_qtrigstatus
private

Definition at line 71 of file VP1TriggerHandleEF.h.

◆ m_trigData

std::vector<std::vector<QString> > VP1Trig::VP1TriggerHandleEF::m_trigData
private

Definition at line 68 of file VP1TriggerHandleEF.h.

◆ m_trigID

QString VP1Trig::VP1TriggerHandleEF::m_trigID
private

Definition at line 50 of file VP1TriggerHandleEF.h.

◆ m_vtrigstatus

bool VP1Trig::VP1TriggerHandleEF::m_vtrigstatus
private

Definition at line 72 of file VP1TriggerHandleEF.h.

The documentation for this class was generated from the following files:
TrigMuonEFTrack::NRpcHitsEta
unsigned short int NRpcHitsEta() const
Definition: TrigMuonEFTrack.h:159
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
TrigMuonEFTrack::posX
double posX() const
Definition: TrigMuonEFTrack.h:98
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
VP1Trig::Logger::m_name
std::string m_name
Definition: graphics/VP1/VP1Systems/VP1TriggerSystems/VP1TriggerSystems/Logger.h:70
runLayerRecalibration.chain
chain
Definition: runLayerRecalibration.py:175
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
count_mef
int count_mef
Definition: VP1TriggerHandleEF.cxx:47
t_data
std::vector< std::vector< QString > > t_data
Definition: VP1TriggerHandleEF.cxx:36
h_source
std::vector< QString > h_source
Definition: VP1TriggerHandleEF.cxx:35
VP1Trig::VP1TriggerHandleEF::m_trigID
QString m_trigID
Definition: VP1TriggerHandleEF.h:50
TrigMuonEFTrack::Charge
double Charge() const
Definition: TrigMuonEFTrack.h:51
TrigMuonEFTrack::d0
double d0() const
Definition: TrigMuonEFTrack.h:59
TYPIDX
const int TYPIDX
Definition: VP1TriggerHandleEF.cxx:42
muonTrackName
std::string muonTrackName[18]
Definition: VP1TriggerHandleEF.cxx:54
h_id
std::vector< QString > h_id
Definition: VP1TriggerHandleEF.cxx:35
VP1String::str
static QString str(const QString &s)
Definition: VP1String.h:49
SRCIDX
const int SRCIDX
Definition: VP1TriggerHandleEF.cxx:43
muonEFTrack
const TrigMuonEFTrack * muonEFTrack
Definition: VP1TriggerHandleEF.cxx:50
drawFromPickle.atan
atan
Definition: drawFromPickle.py:36
VP1Trig::VP1TriggerHandleEF::m_trigData
std::vector< std::vector< QString > > m_trigData
Definition: VP1TriggerHandleEF.h:68
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
TrigMuonEFTrack::posY
double posY() const
Definition: TrigMuonEFTrack.h:108
VP1Trig::VP1TriggerHandleEF::m_qtrigstatus
bool m_qtrigstatus
Definition: VP1TriggerHandleEF.h:71
VP1Trig::Logger::log_warning
void log_warning(const QString &msg)
Definition: graphics/VP1/VP1Systems/VP1TriggerSystems/src/Logger.cxx:36
VP1Trig::Logger::m_lvl
int m_lvl
Definition: graphics/VP1/VP1Systems/VP1TriggerSystems/VP1TriggerSystems/Logger.h:71
count_mg
int count_mg
Definition: VP1TriggerHandleEF.cxx:47
TrigMuonEFInfoTrack::CombinedTrack
TrigMuonEFCbTrack * CombinedTrack()
Definition: TrigMuonEFInfoTrack.h:52
VP1Trig::VP1TriggerHandleEF::m_containerEF
const TrigMuonEFInfo * m_containerEF
Definition: VP1TriggerHandleEF.h:49
lumiFormat.i
int i
Definition: lumiFormat.py:85
TrigMuonEFInfoTrack::SpectrometerTrack
TrigMuonEFTrack * SpectrometerTrack()
Definition: TrigMuonEFInfoTrack.h:50
muonEFCbTrack
const TrigMuonEFCbTrack * muonEFCbTrack
Definition: VP1TriggerHandleEF.cxx:51
TrigMuonEFTrack::NRpcHitsPhi
unsigned short int NRpcHitsPhi() const
Definition: TrigMuonEFTrack.h:129
contains
bool contains(const std::string &s, const std::string &regx)
does a string contain the substring
Definition: hcg.cxx:111
TrigMuonEFTrack::NTgcHitsEta
unsigned short int NTgcHitsEta() const
Definition: TrigMuonEFTrack.h:169
TrigMuonEFInfo::hasTrack
bool hasTrack() const
Definition: TrigMuonEFInfo.cxx:341
TrigMuonEFInfoTrackContainer
Definition: TrigMuonEFInfoTrackContainer.h:27
VP1Trig::VP1TriggerHandleEF::loadTrackContainer
bool loadTrackContainer()
Definition: VP1TriggerHandleEF.cxx:139
VP1Trig::Logger::log_error
void log_error(const QString &msg)
Definition: graphics/VP1/VP1Systems/VP1TriggerSystems/src/Logger.cxx:46
h_type
std::vector< QString > h_type
Definition: VP1TriggerHandleEF.cxx:35
P4IPtCotThPhiM::phi
virtual double phi() const
get phi data member
Definition: P4IPtCotThPhiM.h:106
TrigMuonEFTrack::NTgcHitsPhi
unsigned short int NTgcHitsPhi() const
Definition: TrigMuonEFTrack.h:139
TrigMuonEFInfoTrack::ExtrapolatedTrack
TrigMuonEFTrack * ExtrapolatedTrack()
Definition: TrigMuonEFInfoTrack.h:51
VP1Trig::VP1TriggerHandleEF::muonTrackData
double muonTrackData(QString type, int id)
Definition: VP1TriggerHandleEF.cxx:79
grepfile.sep
sep
Definition: grepfile.py:38
VP1Trig::VP1TriggerHandleEF::m_vtrigstatus
bool m_vtrigstatus
Definition: VP1TriggerHandleEF.h:72
TrigMuonEFTrack::NCscHitsEta
unsigned short int NCscHitsEta() const
Definition: TrigMuonEFTrack.h:179
python.selection.number
number
Definition: selection.py:20
TrigMuonEFInfoTrack::MuonType
unsigned short int MuonType() const
Definition: TrigMuonEFInfoTrack.h:58
TrigMuonEFTrack::posZ
double posZ() const
Definition: TrigMuonEFTrack.h:118
TrigMuonEFTrack::chi2
double chi2() const
Definition: TrigMuonEFTrack.h:79
TrigMuonEFTrack::chi2prob
double chi2prob() const
Definition: TrigMuonEFTrack.h:89
TIDIDX
const int TIDIDX
Definition: VP1TriggerHandleEF.cxx:44
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
TrigMuonEFInfoTrack
Definition: TrigMuonEFInfoTrack.h:22
TrigMuonEFTrack::z0
double z0() const
Definition: TrigMuonEFTrack.h:69
VP1Trig::Logger::log_info
void log_info(const QString &msg)
Definition: graphics/VP1/VP1Systems/VP1TriggerSystems/src/Logger.cxx:32
VP1Trig::Logger::prefix
std::string prefix(std::string str)
Definition: graphics/VP1/VP1Systems/VP1TriggerSystems/src/Logger.cxx:61
python.CaloScaleNoiseConfig.str
str
Definition: CaloScaleNoiseConfig.py:78
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
P4IPtCotThPhiM::m
virtual double m() const
get m data member
Definition: P4IPtCotThPhiM.h:109
HWIDTH
const int HWIDTH
Definition: VP1TriggerHandleEF.cxx:41
extractSporadic.q
list q
Definition: extractSporadic.py:98
TrigMuonEFInfo::TrackContainer
const TrigMuonEFInfoTrackContainer * TrackContainer() const
Definition: TrigMuonEFInfo.h:94
P4IPtCotThPhiM::iPt
virtual double iPt() const
get inverse pT data member
Definition: P4IPtCotThPhiM.h:100
str
Definition: BTagTrackIpAccessor.cxx:11
merge.status
status
Definition: merge.py:17
VP1Trig::VP1TriggerHandleEF::m_chainIDs
QList< QString > m_chainIDs
Definition: VP1TriggerHandleEF.h:51
VP1Trig::Logger::Logger
Logger()
Definition: graphics/VP1/VP1Systems/VP1TriggerSystems/src/Logger.cxx:19
VP1Trig::VP1TriggerHandleEF::m_qtrigData
QTreeWidgetItem * m_qtrigData
Definition: VP1TriggerHandleEF.h:65
python.compressB64.c
def c
Definition: compressB64.py:93
TrigMuonEFTrack::NCscHitsPhi
unsigned short int NCscHitsPhi() const
Definition: TrigMuonEFTrack.h:149
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
VP1Trig::VP1TriggerHandleEF::loadMuonTrack
void loadMuonTrack(int trackNo, QString type)
Definition: VP1TriggerHandleEF.cxx:235
P4IPtCotThPhiM::cotTh
virtual double cotTh() const
get cot(theta) data member
Definition: P4IPtCotThPhiM.h:103
Generated on Thu Nov 7 2024 22:29:57 for ATLAS Offline Software by   doxygen 1.8.18