StRoot  1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
StMtdTrackingMaskMaker.cxx
1 #include <iostream>
2 #include <math.h>
3 #include <vector>
4 #include <stdlib.h>
5 #include <iterator>
6 #include <bitset>
7 
8 #include "TH1F.h"
9 
10 #include "PhysicalConstants.h"
11 #include "StMessMgr.h"
12 
13 #include "StEvent.h"
14 #include "StTriggerData.h"
15 #include "StTrack.h"
16 #include "StMtdCollection.h"
17 #include "StMtdHit.h"
18 
19 #include "StMuDSTMaker/COMMON/StMuDstMaker.h"
20 #include "StMuDSTMaker/COMMON/StMuDst.h"
21 #include "StMuDSTMaker/COMMON/StMuEvent.h"
22 #include "StMuDSTMaker/COMMON/StMuMtdHit.h"
23 
24 #include "tables/St_mtdModuleToQTmap_Table.h"
25 #include "tables/St_mtdQTSlewingCorr_Table.h"
26 #include "tables/St_trgOfflineFilter_Table.h"
27 #include "StMtdTrackingMaskMaker.h"
28 
29 ClassImp(StMtdTrackingMaskMaker)
30 
31 //_____________________________________________________________________________
32 StMtdTrackingMaskMaker::StMtdTrackingMaskMaker(const Char_t *name) : StMaker(name),
33  mStEvent(NULL), mMuDst(NULL), mIsDiMuon(kFALSE), mTrigData(NULL),
34  mTpcSectorsForTracking(0)
35 {
36  // default constructor
37 
38  mSaveHistos = false;
39  mhEventStat = NULL;
40  mhNQTsignals = NULL;
41  mhNMIXsignals = NULL;
42  mhNMuons = NULL;
43  mhNMtdHits = NULL;
44  mhNTrigMtdHits = NULL;
45  mhNTpcSectorForTracking = NULL;
46 }
47 
48 //_____________________________________________________________________________
49 StMtdTrackingMaskMaker::~StMtdTrackingMaskMaker()
50 {
51  // default destructor
52 }
53 
54 //_____________________________________________________________________________
55 Int_t StMtdTrackingMaskMaker::Init()
56 {
57  // book histograms
58  bookHistos();
59 
60  return kStOK;
61 }
62 
63 //_____________________________________________________________________________
64 Int_t StMtdTrackingMaskMaker::InitRun(const Int_t runNumber)
65 {
66  // initialize trigger Ids for di-muon triggers
67  LOG_INFO << "Retrieving trigger ID from database ..." << endm;
68  St_trgOfflineFilter* flaggedTrgs =
69  (St_trgOfflineFilter *) GetDataBase("Calibrations/trg/trgOfflineFilter");
70  if (!flaggedTrgs)
71  {
72  LOG_ERROR << "Could not find Calibrations/trg/trgOfflineFilter in database" << endm;
73  return kStErr;
74  }
75 
76  trgOfflineFilter_st* flaggedTrg = flaggedTrgs->GetTable();
77  for (long j = 0;j < flaggedTrgs->GetNRows(); j++, flaggedTrg++)
78  {
79  int trigid = flaggedTrg->trigid;
80  if (0<trigid && trigid<1e9) mTriggerIDs.push_back(trigid);
81  }
82 
83  // initialize maps
84  memset(mModuleToQT,-1,sizeof(mModuleToQT));
85  memset(mModuleToQTPos,-1,sizeof(mModuleToQTPos));
86  memset(mQTtoModule,-1,sizeof(mQTtoModule));
87 
88  // obtain maps from DB
89  LOG_INFO << "Retrieving mtdModuleToQTmap table from database ..." << endm;
90  TDataSet *dataset = GetDataBase("Geometry/mtd/mtdModuleToQTmap");
91  St_mtdModuleToQTmap *mtdModuleToQTmap = static_cast<St_mtdModuleToQTmap*>(dataset->Find("mtdModuleToQTmap"));
92  if(!mtdModuleToQTmap)
93  {
94  LOG_ERROR << "No mtdModuleToQTmap table found in database" << endm;
95  return kStErr;
96  }
97  mtdModuleToQTmap_st *mtdModuleToQTtable = static_cast<mtdModuleToQTmap_st*>(mtdModuleToQTmap->GetTable());
98 
99  for(int i=0; i<gMtdNBacklegs; i++)
100  {
101  for(int j=0; j<gMtdNModules; j++)
102  {
103  int index = i*5 + j;
104  int qt = mtdModuleToQTtable->qtBoardId[index];
105  int channel = mtdModuleToQTtable->qtChannelId[index];
106  mModuleToQT[i][j] = qt;
107  if(channel<0)
108  {
109  mModuleToQTPos[i][j] = channel;
110  }
111  else
112  {
113  if(channel%8==1) mModuleToQTPos[i][j] = 1 + channel/8 * 2;
114  else mModuleToQTPos[i][j] = 2 + channel/8 * 2;
115  }
116 
117  if(mModuleToQT[i][j]>0 && mModuleToQTPos[i][j]>0)
118  mQTtoModule[mModuleToQT[i][j]-1][mModuleToQTPos[i][j]-1] = j + 1;
119  }
120  }
121 
122  // online slewing correction for QT board
123  memset(mQTSlewBinEdge,-1,sizeof(mQTSlewBinEdge));
124  memset(mQTSlewCorr,-1,sizeof(mQTSlewCorr));
125  LOG_INFO << "Retrieving mtdQTSlewingCorr table from database ..." << endm;
126  dataset = GetDataBase("Calibrations/mtd/mtdQTSlewingCorr");
127  St_mtdQTSlewingCorr *mtdQTSlewingCorr = static_cast<St_mtdQTSlewingCorr*>(dataset->Find("mtdQTSlewingCorr"));
128  if(!mtdQTSlewingCorr)
129  {
130  LOG_ERROR << "No mtdQTSlewingCorr table found in database" << endm;
131  return kStErr;
132  }
133  mtdQTSlewingCorr_st *mtdQTSlewingCorrtable = static_cast<mtdQTSlewingCorr_st*>(mtdQTSlewingCorr->GetTable());
134  for(int j=0; j<4; j++)
135  {
136  for(int i=0; i<16; i++)
137  {
138  for(Int_t k=0; k<8; k++)
139  {
140  Int_t index = j*16*8 + i*8 + k;
141  mQTSlewBinEdge[j][i][k] = (int) mtdQTSlewingCorrtable->slewingBinEdge[index];
142  mQTSlewCorr[j][i][k] = (int) mtdQTSlewingCorrtable->slewingCorr[index];
143  }
144  }
145  }
146 
147  return kStOK;
148 }
149 
150 //_____________________________________________________________________________
151 void StMtdTrackingMaskMaker::Clear(Option_t *option)
152 {
153  // initialize output bit to 0 for each event
154  mTpcSectorsForTracking = 0;
155  mFiredSectors.clear();
156 
157  memset(mTrigQTpos,-1, sizeof(mTrigQTpos));
158  mIsDiMuon = kFALSE;
159 
160  SetAttr("TpcSectorsByMtd",mTpcSectorsForTracking);
161 }
162 
163 //_____________________________________________________________________________
164 Int_t StMtdTrackingMaskMaker::Make()
165 {
166 
167  // Check the availability of input data
168  Int_t iret = -1;
169  mStEvent = (StEvent*) GetInputDS("StEvent");
170  if(mStEvent)
171  {
172  LOG_DEBUG << "Running on StEvent ..." << endm;
173  iret = processStEvent();
174  }
175  else
176  {
177  StMuDstMaker *muDstMaker = (StMuDstMaker*) GetMaker("MuDst");
178  if(muDstMaker)
179  {
180  mMuDst = muDstMaker->muDst();
181  iret = processMuDst();
182  }
183  else
184  {
185  LOG_ERROR << "No muDST is available ... "<< endm;
186  iret = kStErr;
187  }
188  }
189 
190  SetAttr("TpcSectorsByMtd",mTpcSectorsForTracking);
191 
192 
193  if(mStEvent)
194  {
195  LOG_INFO << "Is di-muon event: " << mIsDiMuon << endm;
196  LOG_INFO << "Tracking mask by MTD: " << (bitset<24>)mTpcSectorsForTracking << endm;
197  }
198 
199  return iret;
200 }
201 
202 //_____________________________________________________________________________
203 Int_t StMtdTrackingMaskMaker::processStEvent()
204 {
205  mhEventStat->Fill(0.5);
206 
207  // check trigger id
208  for(unsigned int j=0; j<mTriggerIDs.size(); j++)
209  {
210  if(mStEvent->triggerIdCollection()->nominal()->isTrigger(mTriggerIDs[j]))
211  {
212  mIsDiMuon = kTRUE;
213  break;
214  }
215  }
216  if(!mIsDiMuon) return kStOK;
217  mhEventStat->Fill(1.5);
218 
219  // trigger data
220  mTrigData = (StTriggerData*)mStEvent->triggerData();
221  if(!mTrigData) return kStWarn;
222  processTriggerData();
223 
224  // MTD hits
225  StMtdCollection *mtdCollection = mStEvent->mtdCollection();
226  if(!mtdCollection)
227  {
228  LOG_WARN << "No mtd collection available in StEvent ... " << endm;
229  return kStWarn;
230  }
231  StSPtrVecMtdHit& mtdHits = mtdCollection->mtdHits();
232  int nMtdHits = mtdHits.size();
233  mhNMtdHits->Fill(nMtdHits);
234  int nTrigMtdHits = 0;
235 
236  for(int i=0; i<nMtdHits; i++)
237  {
238  StMtdHit *hit = mtdHits[i];
239  if(!hit) continue;
240  if(!isMtdHitFiredTrigger(hit)) continue;
241  nTrigMtdHits++;
242 
243  // depending on the hit position, find the two or four TPC
244  // sectors that most likely hosts the corresponding tracks
245  int backleg = hit->backleg();
246  int module = hit->module();
247  int cell = hit->cell();
248  double hit_phi = getMtdHitGlobalPhi(backleg, module, cell);
249  findTpcSectorsForTracking(hit_phi, module);
250  }
251  determineTpcTrackingMask();
252  mhNTrigMtdHits->Fill(nTrigMtdHits);
253  return kStOK;
254 }
255 
256 
257 //_____________________________________________________________________________
258 Int_t StMtdTrackingMaskMaker::processMuDst()
259 {
260  mhEventStat->Fill(0.5);
261 
262  // check trigger id
263  for(unsigned int j=0; j<mTriggerIDs.size(); j++)
264  {
265  if(mMuDst->event()->triggerIdCollection().nominal().isTrigger(mTriggerIDs[j]))
266  {
267  mIsDiMuon = kTRUE;
268  break;
269  }
270  }
271  if(!mIsDiMuon) return kStOK;
272  mhEventStat->Fill(1.5);
273 
274  // trigger data
275  mTrigData = const_cast<StTriggerData*>(mMuDst->event()->triggerData());
276  if(!mTrigData) return kStWarn;
277  processTriggerData();
278 
279  // MTD hits
280  int nMtdHits = mMuDst->numberOfMTDHit();
281  mhNMtdHits->Fill(nMtdHits);
282  int nTrigMtdHits = 0;
283 
284  for(int i=0; i<nMtdHits; i++)
285  {
286  StMuMtdHit *hit = mMuDst->mtdHit(i);
287  if(!hit) continue;
288  if(!isMtdHitFiredTrigger(hit)) continue;
289  nTrigMtdHits++;
290 
291  // depending on the hit position, find the two or four TPC
292  // sectors that most likely hosts the corresponding tracks
293  int backleg = hit->backleg();
294  int module = hit->module();
295  int cell = hit->cell();
296  double hit_phi = getMtdHitGlobalPhi(backleg, module, cell);
297  findTpcSectorsForTracking(hit_phi, module);
298  }
299  determineTpcTrackingMask();
300  mhNTrigMtdHits->Fill(nTrigMtdHits);
301  return kStOK;
302 }
303 
304 //_____________________________________________________________________________
305 void StMtdTrackingMaskMaker::processTriggerData()
306 {
311 
312  // TF201 decision
313  unsigned short decision = mTrigData->dsmTF201Ch(0);
314 
315  // MT101 informaiton (QA purpose)
316  int mix_tacsum[4][2];
317  int mix_id[4][2];
318  int nMixSignal = 0;
319  for(int i = 0; i < 4; i++)
320  {
321  mix_tacsum[i][0] = (mTrigData->mtdDsmAtCh(3*i,0)) + ((mTrigData->mtdDsmAtCh(3*i+1,0)&0x3)<<8);
322  mix_id[i][0] = (mTrigData->mtdDsmAtCh(3*i+1,0)&0xc)>>2;
323  mix_tacsum[i][1] = (mTrigData->mtdDsmAtCh(3*i+1,0)>>4) + ((mTrigData->mtdDsmAtCh(3*i+2,0)&0x3f)<<4);
324  mix_id[i][1] = (mTrigData->mtdDsmAtCh(3*i+2,0)&0xc0)>>6;
325 
326  for(int j=0; j<2; j++)
327  {
328  if(mix_tacsum[i][j]>0) nMixSignal ++;
329  }
330  }
331  mhNMIXsignals->Fill(nMixSignal);
332 
333  // QT
334  int mxq_tacsum[4][2];
335  int mxq_tacsum_pos[4][2];
336  for(int i=0; i<4; i++)
337  {
338  for(int j=0; j<2; j++)
339  {
340  mxq_tacsum[i][j] = 0;
341  mxq_tacsum_pos[i][j] = -1;
342  }
343  }
344 
345  // extract tac information for each QT board
346  int mtdQTtac[4][16];
347  int mtdQTadc[4][16];
348  for(int i=0; i<32; i++)
349  {
350  int type = (i/4)%2;
351  if(type==1)
352  {
353  mtdQTtac[0][i-i/4*2-2] = mTrigData->mtdAtAddress(i,0);
354  mtdQTtac[1][i-i/4*2-2] = mTrigData->mtdgemAtAddress(i,0);
355  mtdQTtac[2][i-i/4*2-2] = mTrigData->mtd3AtAddress(i,0);
356  mtdQTtac[3][i-i/4*2-2] = mTrigData->mtd4AtAddress(i,0);
357  }
358  else
359  {
360  mtdQTadc[0][i-i/4*2] = mTrigData->mtdAtAddress(i,0);
361  mtdQTadc[1][i-i/4*2] = mTrigData->mtdgemAtAddress(i,0);
362  mtdQTadc[2][i-i/4*2] = mTrigData->mtd3AtAddress(i,0);
363  mtdQTadc[3][i-i/4*2] = mTrigData->mtd4AtAddress(i,0);
364  }
365  }
366 
367  // In each QT board, find the two signals with
368  // largest TacSum values
369  int nQtSignal = 0;
370  int j[2], a[2];
371  for(int im=0; im<4; im++)
372  {
373  for(int i=0; i<8; i++)
374  {
375  // slewing correction
376  for(int k=0; k<2; k++)
377  {
378  j[k] = mtdQTtac[im][i*2+k];
379  a[k] = mtdQTadc[im][i*2+k];
380 
381  int slew_bin = -1;
382  if(a[k]>=0 && a[k]<=mQTSlewBinEdge[im][i*2+k][0]) slew_bin = 0;
383  else
384  {
385  for(int l=1; l<8; l++)
386  {
387  if(a[k]>mQTSlewBinEdge[im][i*2+k][l-1] && a[k]<=mQTSlewBinEdge[im][i*2+k][l])
388  {
389  slew_bin = l;
390  break;
391  }
392  }
393  }
394  if(slew_bin>=0)
395  j[k] += mQTSlewCorr[im][i*2+k][slew_bin];
396  }
397 
398  if(j[0]<100 || j[1]<100) continue;
399  if(abs(j[0]-j[1])>600) continue;
400  nQtSignal++;
401 
402  // position correction
403  int module = mQTtoModule[im][i];
404  int sumTac = int( j[0] + j[1] + abs(module-3)*1./8 * (j[0]-j[1]) );
405 
406  if(mxq_tacsum[im][0] < sumTac)
407  {
408  mxq_tacsum[im][1] = mxq_tacsum[im][0];
409  mxq_tacsum[im][0] = sumTac;
410 
411  mxq_tacsum_pos[im][1] = mxq_tacsum_pos[im][0];
412  mxq_tacsum_pos[im][0] = i+1;
413  }
414  else if (mxq_tacsum[im][1] < sumTac)
415  {
416  mxq_tacsum[im][1] = sumTac;
417  mxq_tacsum_pos[im][1] = i+1;
418  }
419  }
420  }
421  mhNQTsignals->Fill(nQtSignal);
422 
423  int nMuon = 0;
424  for(int i = 0; i < 4; i++)
425  {
426  for(int j=0; j<2; j++)
427  {
428  if((decision>>(i*2+j+4))&0x1)
429  {
430  nMuon ++;
431  mTrigQTpos[i][j] = mxq_tacsum_pos[i][j];
432  }
433  }
434  }
435  mhNMuons->Fill(nMuon);
436 
437  LOG_DEBUG << "# of muon candidates = " << nMuon << endm;
438 }
439 
440 //_____________________________________________________________________________
441 bool StMtdTrackingMaskMaker::isMtdHitFiredTrigger(const StMtdHit *hit)
442 {
448 
449  return isQTFiredTrigger( mModuleToQT[hit->backleg()-1][hit->module()-1], mModuleToQTPos[hit->backleg()-1][hit->module()-1]);
450 }
451 
452 //_____________________________________________________________________________
453 bool StMtdTrackingMaskMaker::isMtdHitFiredTrigger(const StMuMtdHit *hit)
454 {
460 
461  return isQTFiredTrigger( mModuleToQT[hit->backleg()-1][hit->module()-1], mModuleToQTPos[hit->backleg()-1][hit->module()-1]);
462 }
463 
464 //_____________________________________________________________________________
465 bool StMtdTrackingMaskMaker::isQTFiredTrigger(const int qt, const int pos)
466 {
470 
471  return (pos==mTrigQTpos[qt-1][0] || pos==mTrigQTpos[qt-1][1]);
472 }
473 
474 //_____________________________________________________________________________
475 void StMtdTrackingMaskMaker::determineTpcTrackingMask()
476 {
477  // remove duplicated TPC sectors
478  sort(mFiredSectors.begin(),mFiredSectors.end());
479  mFiredSectors.erase(unique(mFiredSectors.begin(),mFiredSectors.end()),mFiredSectors.end());
480 
481  mhNTpcSectorForTracking->Fill(mFiredSectors.size());
482 
483  // 24-bit mask for TPC tracking
484  for(unsigned int i=0; i<mFiredSectors.size(); i++)
485  {
486  int bit = mFiredSectors[i] - 1;
487  mTpcSectorsForTracking |= (1U << bit);
488  }
489  LOG_DEBUG << "Output TPC mask = " << (bitset<24>) mTpcSectorsForTracking << endm;
490 }
491 
492 //_____________________________________________________________________________
493 void StMtdTrackingMaskMaker::findTpcSectorsForTracking(const double hit_phi, const int hit_module)
494 {
501 
502  IntVec westTpc, eastTpc;
503  westTpc.clear();
504  eastTpc.clear();
505 
506  if(hit_module<5) eastTpc = findEastTpcSectors(hit_phi);
507  if(hit_module>1) westTpc = findWestTpcSectors(hit_phi);
508 
509  for(unsigned int i=0; i<eastTpc.size(); i++)
510  mFiredSectors.push_back(eastTpc[i]);
511 
512  for(unsigned int i=0; i<westTpc.size(); i++)
513  mFiredSectors.push_back(westTpc[i]);
514 }
515 
516 //_____________________________________________________________________________
517 vector<int> StMtdTrackingMaskMaker::findWestTpcSectors(const double hit_phi)
518 {
523 
524  IntVec sectors;
525  sectors.clear();
526 
527  double tpc_sector_width = pi/6.;
528 
529  int tpc_sector_1 = 3 - int(floor(hit_phi/tpc_sector_width));
530  if(tpc_sector_1<1) tpc_sector_1 += 12;
531 
532  int tpc_sector_2 = tpc_sector_1 - 1;
533  if(tpc_sector_2<1) tpc_sector_2 += 12;
534 
535  sectors.push_back(tpc_sector_1);
536  sectors.push_back(tpc_sector_2);
537 
538  LOG_DEBUG << "For hit at phi = " << hit_phi/pi*180 << ", west TPC sectors are "
539  << tpc_sector_1 << " and " << tpc_sector_2 << endm;
540  return sectors;
541 }
542 
543 //_____________________________________________________________________________
544 vector<int> StMtdTrackingMaskMaker::findEastTpcSectors(const double hit_phi)
545 {
550 
551  IntVec sectors;
552  sectors.clear();
553 
554  double tpc_sector_width = pi/6.;
555 
556  int tpc_sector_1 = int(floor(hit_phi/tpc_sector_width))+21;
557  if(tpc_sector_1>24) tpc_sector_1 -= 12;
558 
559  int tpc_sector_2 = tpc_sector_1 + 1;
560  if(tpc_sector_2>24) tpc_sector_2 -= 12;
561 
562  sectors.push_back(tpc_sector_1);
563  sectors.push_back(tpc_sector_2);
564 
565  LOG_DEBUG << "For hit at phi = " << hit_phi/pi*180 << ", east TPC sectors are "
566  << tpc_sector_1 << " and " << tpc_sector_2 << endm;
567 
568  return sectors;
569 }
570 
571 //_____________________________________________________________________________
572 double StMtdTrackingMaskMaker::getMtdHitGlobalPhi(const int backleg, const int module, const int cell)
573 {
577 
578  double backlegPhiCen = gMtdFirstBacklegPhiCenter + (backleg-1) * (gMtdBacklegPhiWidth+gMtdBacklegPhiGap);
579  if(backlegPhiCen>2*pi) backlegPhiCen -= 2*pi;
580  double stripPhiCen = 0;
581  if(module>0 && module<4)
582  {
583  stripPhiCen = backlegPhiCen - (gMtdNChannels/4.-0.5-cell)*(gMtdCellWidth+gMtdCellGap)/gMtdMinRadius;
584  }
585  else
586  {
587  stripPhiCen = backlegPhiCen + (gMtdNChannels/4.-0.5-cell)*(gMtdCellWidth+gMtdCellGap)/gMtdMinRadius;
588  }
589  return rotatePhi(stripPhiCen);
590 }
591 
592 //_____________________________________________________________________________
593 double StMtdTrackingMaskMaker::rotatePhi(const double phi)
594 {
595  double outPhi = phi;
596  while(outPhi<0) outPhi += 2*pi;
597  while(outPhi>2*pi) outPhi -= 2*pi;
598  return outPhi;
599 }
600 
601 
602 //_____________________________________________________________________________
603 void StMtdTrackingMaskMaker::bookHistos()
604 {
605 
606  mhEventStat = new TH1F("hEventStat","Event statistics",5,0,5);
607  mhEventStat->GetXaxis()->SetBinLabel(1,"All events");
608  mhEventStat->GetXaxis()->SetBinLabel(2,"Good trigger");
609 
610  mhNQTsignals = new TH1F("hNQTsignals","Number of QT signals per event;N",10,0,10);
611 
612  mhNMIXsignals = new TH1F("hNMIXsignals","Number of MT101 signals per event;N",10,0,10);
613 
614  mhNMuons = new TH1F("hNMuons","Number of TF201 signals per event;N",10,0,10);
615 
616  mhNMtdHits = new TH1F("hNMtdHits","Number of MTD hits per event;N",50,0,50);
617 
618  mhNTrigMtdHits = new TH1F("hNTrigMtdHits","Number of triggering MTD hits per event;N",10,0,10);
619 
620  mhNTpcSectorForTracking = new TH1F("hNTpcSectorForTracking","Number of TPC sectors for tracking per event;N",20,0,20);
621 
622  if(mSaveHistos)
623  {
624  AddHist(mhEventStat);
625  AddHist(mhNQTsignals);
626  AddHist(mhNMIXsignals);
627  AddHist(mhNMuons);
628  AddHist(mhNMtdHits);
629  AddHist(mhNTrigMtdHits);
630  AddHist(mhNTpcSectorForTracking);
631  }
632 }
633 
634 
635 // $Id: StMtdTrackingMaskMaker.cxx,v 1.4 2016/07/27 15:24:30 marr Exp $
636 // $Log: StMtdTrackingMaskMaker.cxx,v $
637 // Revision 1.4 2016/07/27 15:24:30 marr
638 // Fix coverity check: initialization of data members
639 //
640 // Revision 1.3 2015/05/01 21:37:20 marr
641 // Apply online slewing correction and position correction to QT data to make
642 // sure the correct trigger patches are found offline.
643 //
644 // Revision 1.2 2015/04/23 21:09:12 marr
645 // Add print-out in reconstruction
646 //
647 // Revision 1.1 2015/04/07 14:10:37 jeromel
648 // First version of StMtdEvtFilterMaker - R.Ma - review closed 2015/04/06
649 //
650 //
StMtdTrackingMaskMaker::findEastTpcSectors
IntVec findEastTpcSectors(const double hit_phi)
Definition: StMtdTrackingMaskMaker.cxx:544
StMuDstMaker::muDst
StMuDst * muDst()
Definition: StMuDstMaker.h:425
StMtdTrackingMaskMaker
This class finds the MTD hits that actually fire the trigger, and mask the correponding TPC sectors f...
Definition: StMtdTrackingMaskMaker.h:26
StMtdTrackingMaskMaker::findTpcSectorsForTracking
void findTpcSectorsForTracking(const double hit_phi, const int hit_module)
Definition: StMtdTrackingMaskMaker.cxx:493
StMtdTrackingMaskMaker::isMtdHitFiredTrigger
bool isMtdHitFiredTrigger(const StMtdHit *hit)
Definition: StMtdTrackingMaskMaker.cxx:441
StMtdTrackingMaskMaker::isQTFiredTrigger
bool isQTFiredTrigger(const int qt, const int pos)
Definition: StMtdTrackingMaskMaker.cxx:465
StMtdTrackingMaskMaker::findWestTpcSectors
IntVec findWestTpcSectors(const double hit_phi)
Definition: StMtdTrackingMaskMaker.cxx:517
StMuDst::event
static StMuEvent * event()
returns pointer to current StMuEvent (class holding the event wise information, e.g. event number, run number)
Definition: StMuDst.h:320
kStWarn
Definition: Stypes.h:42
kStOK
Definition: Stypes.h:40
StMtdTrackingMaskMaker::Clear
void Clear(Option_t *option="")
User defined functions.
Definition: StMtdTrackingMaskMaker.cxx:151
kStErr
Definition: Stypes.h:44
TDataSet::Find
virtual TDataSet * Find(const char *path) const
Definition: TDataSet.cxx:362
Generated by   doxygen 1.8.5