StRoot  1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
StEEmcPi0Analysis.cxx
1 
16 #include "StEEmcPi0Analysis.h"
17 #include "StEEmcMixMaker.h"
18 #include "StEEmcPool/StEEmcPointMaker/StEEmcPointMaker.h"
19 #include "TH1F.h"
20 #include "TH2F.h"
21 #include "TTree.h"
22 #include "TFile.h"
23 #include <stdio.h>
24 #include <iostream>
25 #include "SpinCuts.h"
26 #include "StEEmcPool/StEEmcPointMaker/EEmcSectorFit.h"
27 #include "StEEmcUtil/StEEmcSmd/EEmcSmdGeom.h"
28 #include "StEEmcUtil/EEmcGeom/EEmcGeomSimple.h"
29 #include "StEEmcPool/StRFEmcTrigger/StRFEmcTrigMaker.h"
30 #include "StEEmcPool/StEEmcA2EMaker/StEEmcA2EMaker.h"
31 
32 ClassImp(StEEmcPi0Analysis);
33 
34 // ----------------------------------------------------------------------------
35 StEEmcPi0Analysis::StEEmcPi0Analysis(const Char_t *name):StMaker(name)
36 {
37  mCuts=new SpinCuts();
38  mTrigSim = 0;
39  mTrigSimThreshold = 0;
40  mEEgeom=new EEmcGeomSimple();
41  mSpinSort = true;
42 
43 }
44 
45 // ----------------------------------------------------------------------------
46 Int_t StEEmcPi0Analysis::Init()
47 {
48 
49  // book histograms for pi0 analysis
50  mHistograms[ kAny ] = new SpinHistos("Any", "Pi0 spectra, unsorted");
51  // book histograms for pi0 analysis
52  mBackgrounds[ kAny ] = new SpinHistos("AnyB", "combinatoric spectra, unsorted");
53 
54  mHistograms[1]=new SpinHistos("PP","Pi0 spectra, PP, spin4=dec5");
55  mHistograms[2]=new SpinHistos("PN","Pi0 spectra, PN, spin4=dec6");
56  mHistograms[3]=new SpinHistos("NP","Pi0 spectra, NP, spin4=dec9");
57  mHistograms[4]=new SpinHistos("NN","Pi0 spectra, NN, spin4=dec10");
58 
59  mHistograms[5]=new SpinHistos("Upper","Pi0 spectra, upper sectors 1-2, 8-12");
60  mHistograms[6]=new SpinHistos("Lower","Pi0 spectra, lower sectors 3-7");
61 
62  hEventCounter=new TH1F("hEventCounter","Event counts",10,0.,10.);
63  hEventCounter -> GetXaxis() -> SetBinLabel(1,"raw");
64  hEventCounter -> GetXaxis() -> SetBinLabel(2,"minb");
65  hEventCounter -> GetXaxis() -> SetBinLabel(3,"hw trg");
66  hEventCounter -> GetXaxis() -> SetBinLabel(5,"sw trg");
67  hEventCounter -> GetXaxis() -> SetBinLabel(5,"sw trg[3,6]");
68  hEventCounter -> GetXaxis() -> SetBinLabel(6,"vertex");
69  hPairCounter = new TH1F("hPairCounter","Pair counts",10,0.,10.);
70  hFillPatternI = new TH1F("hFillPatternI","Intended fill pattern:bunch X-ing @ STAR IP:n runs",120,0.,120.);
71  hSpin4 = new TH1F("hSpin4","Spin 4:spin4 state",11,0.,11.);
72  hSpin4mb = new TH1F("hSpin4mb","Spin 4:spin4 state",11,0.,11.);
73  hBx7 = new TH1F("hBx7","7-bit bunch crossing:bx7",120,0.,120.);
74  hBx48 = new TH1F("hBx48","48-bit bunch crossing:bx48",120,0.,120.);
75  hBx7diffBx48 = new TH2F("hBx7diffBx48","bx1=(bx7-off7)%120, bx2=(bx48-off48)%120;bx7;bx1-bx2",120,0.,120.,21,-10.5,10.5);
76  hBxStar = new TH1F("hBxStar","Beam x-ing at STAR IP;star bunch x-ing",120,0.,120.);
77  hBxStarPi0 = new TH1F("hBxStarPi0","Beam x-ing at STAR IP with pi0 detected;star bunch x-ing",120,0.,120.);
78 
79  hMassBx=new TH2F("hMassBx","Beam x-ing vs Mass;M [GeV];STAR bunch xing",120,0.,1.2,120,0.,120.);
80  hZvertBx=new TH2F("hZvertBx","Beam x-ing vs Z vertex [0.1,0.18]",150,-150.,150.,120,0.,120.);
81  hZggBx=new TH2F("hZggBx","Beam x-ing vs Zgg",100,0.,1.,120,0.,120.);
82  hEtaBx=new TH2F("hEtaBx","Beam x-ing vs eta",120,0.8,2.2,120,0.,120.);
83  mRealEvent=new StEEmcMixEvent();
84  mMixedEvent=new StEEmcMixEvent();
85  mRealTree=new TTree("mRealTree","Real Events");
86  mRealTree->Branch("MixEvent","StEEmcMixEvent",&mRealEvent);
87  mMixedTree=new TTree("mMixedTree","Mixed Events");
88  mMixedTree->Branch("MixEvent","StEEmcMixEvent",&mMixedEvent);
89 
90  AddObj( mRealTree, ".hist" );
91  AddObj( mMixedTree, ".hist" );
92 
93  return StMaker::Init();
94 }
95 // ----------------------------------------------------------------------------
96 Int_t StEEmcPi0Analysis::InitRun(Int_t run)
97 {
98 
99  mSpinDb->print(0); // 0=short, 1=huge
100  Info("InitRun","run number = %d",run);
101  const Int_t *spin8bits=mSpinDb->getSpin8bits();
102  for(int bx=0;bx<120;bx++){
103  Bool_t isFilled=(spin8bits[bx] & 0x11)==0x11;
104  if(isFilled) hFillPatternI->Fill(bx);
105  }
106 
107  mRunNumber = run;
108 
109  return StMaker::InitRun(run);
110 
111 }
112 // ----------------------------------------------------------------------------
113 Int_t StEEmcPi0Analysis::Make()
114 {
115 
116 
118  Int_t spin4 = -1;
119  Int_t bxStar = -1;
120  if ( mSpinDb -> isValid() && mSpinDb -> isPolDirLong() )
121  spin4=getSpinState( mMuDst->muDst(), bxStar );
122 
123  hBxStar -> Fill( bxStar );
124 
125  mRealEvent -> setEvent( mMuDst->muDst()->event() );
126  mRealEvent -> setSpin4( spin4 );
127  mMixedEvent -> setEvent( mMuDst->muDst()->event() );
128  mMixedEvent -> setSpin4( spin4 );
129 
130  for ( Int_t ii=0;ii<720;ii++ ) {
131  StEEmcTower tower=mEEanalysis->tower(ii);
132  if ( tower.fail() ) continue;
133  mRealEvent->mADC[ii]=(60./4096.)*tower.adc();
134  mRealEvent->mStat[ii]=tower.stat();
135  }
136 
138  if ( !accept( mMuDst->muDst() ) ) goto END_OF_MAKE;
139  hPairCounter -> Fill( kEvent );
140 
142  static Int_t mymap[]={0,0,0,0,0,1,2,0,0,3,4};
143 
145  mRealEvent -> mTotalEnergyT = mEEanalysis -> energy(0);
146  mRealEvent -> mTotalEnergyP = mEEanalysis -> energy(1);
147  mRealEvent -> mTotalEnergyQ = mEEanalysis -> energy(2);
148  mRealEvent -> mTotalEnergyR = mEEanalysis -> energy(3);
149  mRealEvent -> mTotalEnergyU = mEEanalysis -> energy(4);
150  mRealEvent -> mTotalEnergyV = mEEanalysis -> energy(5);
151 
153  for ( Int_t i=0;i<mEEmixer->numberOfCandidates();i++ )
154  {
155 
156  StEEmcPair pair = mEEmixer->candidate(i);
157  hPairCounter -> Fill( kPair );
158  if ( !accept( pair ) ) continue;
159 
160  mRealEvent -> addPair( pair );
161 
162  std::cout << "spin4=" << spin4 << " ";
163  pair.print();
164  mHistograms[ kAny ] -> Fill( pair );
165 
166  StEEmcPoint p1=pair.point(0);
167  StEEmcPoint p2=pair.point(1);
168  p1=(p1.energy()>p2.energy())?p1:p2;
169  if ( p1.sector() >= 2 && p1.sector() < 7 )
170  mHistograms[5]->Fill( pair );
171  else
172  mHistograms[6]->Fill( pair );
173 
174  mRealEvent->mNumberU[i] = mEEanalysis->numberOfHitStrips( p1.sector(), 0 );
175  mRealEvent->mNumberV[i] = mEEanalysis->numberOfHitStrips( p1.sector(), 1 );
176 
177 #if 1
178 
179  // count up the number of active towers which can form a
180  // "megacluster"
181  //jb -not used Float_t mSeedEnergy = 0.8;
182  Float_t mMinEnergy = 0.1;
183  Bool_t used[720];
184  for ( Int_t j=0;j<720;j++ ) used[j]=false;
185  StEEmcTower tow=p1.tower(0);
186  StEEmcCluster c;
187  if (!tow.fail() )
188  {
189  c.add(tow);
190  used[tow.index()]=true;
191  StEEmcTowerVec_t hits=mEEanalysis->towers(0);
192  for ( UInt_t j=0;j<hits.size();j++ )
193  {
194  tow=hits[j];
195  if ( used[ tow.index() ] ) continue; // next hit
196  if ( tow.energy() < mMinEnergy ) continue;
197  if ( c.isNeighbor( tow ) ) {
198  c.add(tow);
199  used[tow.index()]=true;
200  }
201  }
202  }
203  mRealEvent->mNumberT[i]=c.numberOfTowers();
204 
205 #endif
206 #if 1
207  // repeat for postshower
208  mMinEnergy=0.1/1000.0;
209  for ( Int_t j=0;j<720;j++ ) used[j]=false;
210  Int_t ind=p1.tower(0).index();
211  tow=mEEanalysis->tower(ind,3);
212  StEEmcCluster b;
213  if (!tow.fail() )
214  {
215  b.add(tow);
216  used[tow.index()]=true;
217  StEEmcTowerVec_t hits=mEEanalysis->towers(3);
218  for ( UInt_t j=0;j<hits.size();j++ )
219  {
220  tow=hits[j];
221  if ( used[ tow.index() ] ) continue; // next hit
222  if ( tow.energy() < mMinEnergy ) continue;
223  if ( b.isNeighbor( tow ) ) {
224  b.add(tow);
225  used[tow.index()]=true;
226  }
227  }
228  }
229  mRealEvent->mNumberR[i]=b.numberOfTowers();
230 #endif
231 
232 
233 
234 
236  if ( !mSpinSort ) {
237  std::cout << "Problem detected, spin sorting disabled" << std::endl;
238  continue;
239  }
240 
241  spin4=getSpinState( mMuDst->muDst(),bxStar );
242  if ( spin4>=0 )
243  if ( mymap[spin4] ) {
244  mHistograms[ mymap[spin4] ] -> Fill( pair );
245  }
246 
247  hMassBx->Fill(pair.mass(),bxStar);
248  if ( pair.mass()>0.1 && pair.mass() < 0.18 ) {
249  hBxStarPi0->Fill(bxStar);
250  hZvertBx->Fill(pair.vertex().Z(),bxStar);
251  hZggBx->Fill(pair.zgg(),bxStar);
252  hEtaBx->Fill(pair.momentum().Eta(),bxStar);
253  }
254 
255 
256  }
257 
259  for ( Int_t i=0;i<mEEmixer->numberOfMixedCandidates();i++ )
260  {
261 
262  StEEmcPair pair = mEEmixer->mixedCandidate(i);
263  if ( !accept( pair, false ) ) continue;
264  mBackgrounds[ kAny ] -> Fill( pair );
265  mMixedEvent -> addPair( pair );
266 
267  }
268 
269  END_OF_MAKE:
270  mRealTree->Fill();
271  mMixedTree->Fill();
272  return kStOK;
273 }
274 
275 // ----------------------------------------------------------------------------
276 void StEEmcPi0Analysis::mixer(const Char_t *name)
277 {
278  mEEmixer=(StEEmcMixMaker *)GetMaker(name);
279  assert(mEEmixer);// please specify a valid mix maker
280 }
281 
282 // ----------------------------------------------------------------------------
283 void StEEmcPi0Analysis::points(const Char_t *name)
284 {
285  mEEpoints=(StEEmcPointMaker *)GetMaker(name);
286  assert(mEEpoints);
287 }
288 
289 // ----------------------------------------------------------------------------
290 void StEEmcPi0Analysis::mudst(const Char_t *name)
291 {
292  mMuDst=(StMuDstMaker*)GetMaker(name);
293  assert(mMuDst);
294 }
295 // ----------------------------------------------------------------------------
296 void StEEmcPi0Analysis::analysis(const Char_t *name)
297 {
298  mEEanalysis=(StEEmcA2EMaker*)GetMaker(name);
299  assert(mEEanalysis);
300 }
301 // ----------------------------------------------------------------------------
302 void StEEmcPi0Analysis::spin(const Char_t *name)
303 {
304  mSpinDb=(StSpinDbMaker*)GetMaker(name);
306 }
307 // ----------------------------------------------------------------------------
308 Bool_t StEEmcPi0Analysis::twoBodyCut( StEEmcPair &pair )
309 {
310 
311  static const Int_t maxPerCluster = 2;
312  static const Float_t minTowerFrac = 0.;
313 
315 
316  Bool_t towers[720]; for (Int_t i=0;i<720;i++ ) towers[i]=false;
317  StEEmcTower t1 = pair.point(0).tower(0);
318  StEEmcTower t2 = pair.point(1).tower(0);
319 
320  Float_t Etowers=0.;
321  Etowers += t1.energy();
322 
323 
324  towers[ t1.index() ] = true;
325  towers[ t2.index() ] = true;
326 
327  for ( Int_t i=0;i<t1.numberOfNeighbors();i++ ) {
328  StEEmcTower mytow=t1.neighbor(i);
329  towers[ mytow.index() ] = true;
330  Etowers += mytow.energy();
331  }
332  for ( Int_t i=0;i<t2.numberOfNeighbors();i++ ) {
333  StEEmcTower mytow=t2.neighbor(i);
334  if ( !towers[mytow.index()] ) Etowers += mytow.energy();
335  towers[ mytow.index() ] = true;
336  }
337 
338 
339 
341 
344 
345  Int_t count = 0;
346  for ( Int_t i=0;i<mEEpoints->numberOfPoints();i++ )
347  {
348  StEEmcPoint p=mEEpoints->point(i);
349  StEEmcTower t=p.tower(0);
350  if ( towers[ t.index() ] ) count++;
351  }
352 
353  Float_t Epoints = pair.energy();
354 
355  return ( count <= maxPerCluster && Epoints > minTowerFrac * Etowers );
356 
357 }
358 
359 // ----------------------------------------------------------------------------
360 // mudst based cuts
361 Bool_t StEEmcPi0Analysis::accept( StMuDst *mudst )
362 {
363 
364  // verify that the trigger is in the trigger list
365  StMuEvent *event=mudst->event();
366  assert(event);
367 
368  Bool_t good_trigger = false;
369 
370  // -------------------------------------------------------
371  //
372  // Trigger from real data
373  //
374 
375  StMuTriggerIdCollection tic = event -> triggerIdCollection();
376  StTriggerId l1trig = tic.l1();
377  // if no triggers are specified, always return true
378  if ( mTriggerList.size() <=0 ) {
379  good_trigger = true;
380  }
381 
382  Int_t go=0;
383  std::vector<Int_t>::iterator iter=mTriggerList.begin();
384  while ( iter != mTriggerList.end() ) {
385  go = l1trig.isTrigger( (*iter) );
386  good_trigger |= go;
387  iter++;
388  }
389 
390 
391  // -------------------------------------------------------
392  //
393  // Trigger from sim data
394  //
395  if ( mTrigSim )
396  {
397  good_trigger = mTrigSim -> getEEMCtrigHT( mTrigSimThreshold );
398  good_trigger &= mTrigSim -> getBBCtrig();
399  }
400 
401 
402  if ( l1trig.isTrigger( mMinBias ) )
403  hEventCounter -> Fill( kMinBias );
404 
405  // must have a valid trigger to proceed
406  if ( good_trigger )
407  {
408  hEventCounter -> Fill( kTrig );
409  }
410  else
411  {
412  return false;
413  }
414 
415  // loop over all hit towers and verify that one tower
416  // exceeds the software threshold in mCuts
417  StEEmcTower ht;
418  Bool_t sw36=0;
419  for ( Int_t i=0;i<mEEanalysis->numberOfHitTowers(0);i++ )
420  {
421  StEEmcTower t=mEEanalysis->hittower(i,0);
422  if ( !t.fail() && t.et() > ht.et() ) {
423  ht=t;
424  if ( ht.et()>=mCuts->tower_et_cut &&
425  ht.sector()>=2&&ht.sector()<=5 ) sw36=true;
426  }
427  }
428  if ( ht.et() < mCuts->tower_et_cut ) {
429  good_trigger = false;
430  return false;
431  }
432  else
433  {
434  hEventCounter -> Fill( kSoftTrig );
435  }
436  if ( sw36 ) hEventCounter -> Fill( kSoftTrig36 );
437 
438 
439  StThreeVectorF vert=event->primaryVertexPosition();
440  if ( vert.z() < mCuts->z_vertex_min) {
441  // std::cout << "No vertex" << std::endl;
442  return false;
443  }
444  if ( vert.z() > mCuts->z_vertex_max ) {
445  // std::cout << "No vertex" << std::endl;
446  return false;
447  }
448 
449  hEventCounter -> Fill( kVertex );
450 
451 
452  return true;
453 
454 }
455 
456 Bool_t StEEmcPi0Analysis::accept( StEEmcPair pair, Bool_t fill )
457 {
458 
460  if ( !twoBodyCut(pair) ) return false;
461  if (fill) hPairCounter -> Fill( kTwoBody );
462 
464  StEEmcPoint point1=pair.point(0);
465  StEEmcPoint point2=pair.point(1);
466  StEEmcTower tower1=pair.point(0).tower(0);
467  StEEmcTower tower2=pair.point(1).tower(0);
468 
469  if ( tower1.adc() < mCuts->adc_cut &&
470  tower2.adc() < mCuts->adc_cut ) return false;
471 
472  if ( fill) hPairCounter -> Fill( kAdcTow );
473 
474  /*
475  if ( tower1.et() < mCuts->tower_et_cut &&
476  tower2.et() < mCuts->tower_et_cut ) return false;
477  */
478  TVector3 d1 = mEEgeom -> getTowerCenter( (UInt_t)tower1.sector(), (UInt_t)tower1.subsector(), (UInt_t)tower1.etabin() );
479  TVector3 d2 = mEEgeom -> getTowerCenter( (UInt_t)tower2.sector(), (UInt_t)tower2.subsector(), (UInt_t)tower2.etabin() );
480  d1=d1.Unit();
481  d2=d2.Unit();
482  Float_t et1 = (tower1.energy()*d1).Perp();
483  Float_t et2 = (tower2.energy()*d2).Perp();
484 
485  if ( et1 < mCuts->tower_et_cut &&
486  et2 < mCuts->tower_et_cut ) return false;
487 
488 
489  /*
491  Float_t et_sum1 = tower1.et();
492  Float_t et_sum2 = tower2.et();
493  for ( Int_t ii=0;ii<tower1.numberOfNeighbors();ii++ )
494  {
495  et_sum1 += tower1.neighbor(ii).et();
496  }
497  for ( Int_t ii=0;ii<tower2.numberOfNeighbors();ii++ )
498  {
499  et_sum2 += tower2.neighbor(ii).et();
500  }
501 
502  Bool_t go = false;
503  if ( et1 > 3.0 || et2 > 3.0 ) go = true;
504  if ( et1 > 2.0 && et_sum1 > 4.0 ) go = true;
505  if ( et2 > 2.0 && et_sum2 > 4.0 ) go = true;
506  if ( !go ) return false;
507  */
508 
509  if ( fill ) hPairCounter -> Fill( kEtTow );
510 
512  Float_t eta=pair.momentum().Eta();
513  if ( eta < mCuts->eta_min || eta > mCuts->eta_max ) return false;
514  if ( fill ) hPairCounter->Fill( kKinematics );
515 
516 
518 
519 
520 
521  return true;
522 
523 }
524 
525 // ----------------------------------------------------------------------------
526 Int_t StEEmcPi0Analysis::getSpinState( StMuDst *mudst, Int_t &bxStar )
527 {
528 
529  StMuEvent *event = mudst -> event();
530  StL0Trigger *trig =&(event->l0Trigger());
531 
532  StMuTriggerIdCollection tic = event -> triggerIdCollection();
533  StTriggerId l1trig = tic.l1();
534 
535 
536  Int_t bx48 = trig->bunchCrossingId();
537  Int_t bx7 = trig->bunchCrossingId7bit( mRunNumber );
538 
539  //bxStar = mSpinDb->BXstarUsingBX48(bx48);
540  bxStar = mSpinDb->BXyellowUsingBX48(bx48);
541 
542  mRealEvent->bx48 = bx48;
543  mRealEvent->bx7 = bx7;
544  mRealEvent->bxStar = bxStar;
545 
546  mMixedEvent->bx48=bx48;
547  mMixedEvent->bx7 =bx7;
548  mMixedEvent->bxStar=bxStar;
549 
552  if ( bx7 == 0 || bx7 == 119 ) return -1; // kick 0 and 119 out of mix
553  if ( bx7 == 14 || bx7 == 54 ) return -1;
555 
556  hBx7->Fill( bx7 );
557  hBx48->Fill( bx48 );
558  hBx7diffBx48->Fill( bx7, mSpinDb->offsetBX48minusBX7(bx48,bx7) );
559 
560  //$$$::cout << "bx7=" << bx7 << " bx48=" << bx48 << std::endl;
561 
562  if ( mSpinDb -> isMaskedUsingBX48(bx48) ) return -1; // return an error flag
563  if ( mSpinDb->offsetBX48minusBX7(bx48,bx7)!=0 ) std::cout << "BUNCH CROSSINGS INCONSISTENT" << std::endl;
564 
565  // assert(mSpinDb->offsetBX48minusBX7(bx48,bx7)==0); // scaler boards were not in sync
566  // mSpinSort = (mSpinDb->offsetBX48minusBX7(bx48,bx7)==0);
567  // disable spin sorting and clear histograms
568  if ( mSpinDb->offsetBX48minusBX7(bx48,bx7)!=0 )
569  {
570  mSpinSort = false;
571  for ( Int_t ii=1;ii<=4;ii++ ) mHistograms[ii]->Clear();
572  }
573 
574 
575  Int_t spin4 = mSpinDb->spin4usingBX48(bx48);
576  hSpin4->Fill(spin4);
577 
578  if ( l1trig.isTrigger(96011) ) hSpin4mb -> Fill(spin4);
579 
580 
581  return spin4;
582 
583 }
584 // ----------------------------------------------------------------------------
585 void StEEmcPi0Analysis::Clear(Option_t *opts)
586 {
587  mRealEvent -> Clear();
588  mMixedEvent -> Clear();
589 }
StEEmcPi0Analysis::mHistograms
SpinHistos * mHistograms[100]
Spin-sorted pi0 histograms.
Definition: StEEmcPi0Analysis.h:98
StEEmcPi0Analysis::mSpinDb
StSpinDbMaker * mSpinDb
pointer to the spin database
Definition: StEEmcPi0Analysis.h:90
StEEmcPi0Analysis::twoBodyCut
Bool_t twoBodyCut(StEEmcPair &p)
Definition: StEEmcPi0Analysis.cxx:308
StEEmcTower::numberOfNeighbors
Int_t numberOfNeighbors() const
get the number of neighboring towers
Definition: StEEmcTower.h:54
StEEmcA2EMaker
EEmc ADC –&gt; energy maker.
Definition: StEEmcA2EMaker.h:19
StEEmcPoint
Base class for representing EEMC points.
Definition: StEEmcPoint.h:24
StEEmcElement::stat
void stat(unsigned s)
Set a status bit for this element.
Definition: StEEmcElement.h:23
StEEmcPi0Analysis::accept
Bool_t accept(StMuDst *mu)
method to cut events
Definition: StEEmcPi0Analysis.cxx:361
StMuDstMaker::muDst
StMuDst * muDst()
Definition: StMuDstMaker.h:425
StEEmcCluster::add
void add(const StEEmcTower &t, Float_t weight=1.0)
Definition: StEEmcCluster.cxx:87
StEEmcA2EMaker::hittower
StEEmcTower & hittower(Int_t hit, Int_t layer)
Definition: StEEmcA2EMaker.h:63
StEEmcPi0Analysis::mTrigSim
StRFEmcTrigMaker * mTrigSim
Trigger simulation for MC.
Definition: StEEmcPi0Analysis.h:152
StEEmcPoint::energy
void energy(Float_t e, Int_t layer=0)
Set the energy of this point.
Definition: StEEmcPoint.h:34
StEEmcPi0Analysis
A maker for creating pi0 histograms.
Definition: StEEmcPi0Analysis.h:33
StEEmcPi0Analysis::analysis
void analysis(const Char_t *name)
specifies the name of the analysis maker
Definition: StEEmcPi0Analysis.cxx:296
StEEmcPoint::sector
Int_t sector() const
Returns the sector.
Definition: StEEmcPoint.h:85
StEEmcA2EMaker::towers
StEEmcTowerVec_t & towers(Int_t layer=0)
Definition: StEEmcA2EMaker.h:49
StEEmcTower::neighbor
void neighbor(StEEmcTower *n)
add a tower to list of neighbors
Definition: StEEmcTower.h:52
StEEmcPointMaker::point
StEEmcPoint point(Int_t ipoint)
Return a specified point.
Definition: StEEmcPointMaker.h:170
StEEmcMixMaker::numberOfCandidates
Int_t numberOfCandidates()
returns the number of candidates
Definition: StEEmcMixMaker.h:200
StEEmcA2EMaker::numberOfHitStrips
Int_t numberOfHitStrips(Int_t sector, Int_t plane) const
Definition: StEEmcA2EMaker.h:100
StEEmcPair::print
void print() const
Prints a one-line summary of the pair.
Definition: StEEmcPair.cxx:128
StSpinDbMaker::spin4usingBX48
int spin4usingBX48(int bx48)
8bit spin information
Definition: StSpinDbMaker.cxx:271
StEEmcPair::momentum
const TVector3 & momentum() const
Returns momentum of pair.
Definition: StEEmcPair.h:78
StEEmcPi0Analysis::Init
Int_t Init()
initializes the maker
Definition: StEEmcPi0Analysis.cxx:46
StEEmcMixMaker::mixedCandidate
StEEmcPair mixedCandidate(Int_t m)
Returns the specified mixed candidate pair.
Definition: StEEmcMixMaker.h:47
StEEmcPair::vertex
const TVector3 & vertex() const
Returns vertex of pair.
Definition: StEEmcPair.h:79
StEEmcPointMaker
Class for building points from smd clusters.
Definition: StEEmcPointMaker.h:20
StEEmcPi0Analysis::Make
Int_t Make()
processes a single event
Definition: StEEmcPi0Analysis.cxx:113
StEEmcA2EMaker::numberOfHitTowers
Int_t numberOfHitTowers(Int_t layer) const
Definition: StEEmcA2EMaker.h:58
StEEmcTower::etabin
Int_t etabin() const
Returns the etabin of this tower, pre- or postshower element.
Definition: StEEmcTower.h:45
StEEmcElement::fail
void fail(unsigned f)
Set a fail bit for this element.
Definition: StEEmcElement.h:25
StEEmcMixEvent
copied from muDst
Definition: StEEmcMixEvent.h:23
StEEmcPair::point
const StEEmcPoint & point(Int_t index) const
Definition: StEEmcPair.h:30
StEEmcTower::subsector
Int_t subsector() const
Returns subsector of this tower, pre- or postshower element.
Definition: StEEmcTower.h:43
StEEmcMixMaker::numberOfMixedCandidates
Int_t numberOfMixedCandidates()
returns the number of mixed-background candidates
Definition: StEEmcMixMaker.h:201
StEEmcPointMaker::numberOfPoints
Int_t numberOfPoints()
Return number of points.
Definition: StEEmcPointMaker.h:169
StEEmcPi0Analysis::InitRun
Int_t InitRun(Int_t)
init run
Definition: StEEmcPi0Analysis.cxx:96
StEEmcTower::index
void index(Int_t i)
Definition: StEEmcTower.cxx:76
StEEmcTower
Base class for representing tower, preshower and postshower elements.
Definition: StEEmcTower.h:11
StEEmcPi0Analysis::mEEgeom
EEmcGeomSimple * mEEgeom
EEMC tower geometry.
Definition: StEEmcPi0Analysis.h:159
StEEmcPi0Analysis::mudst
void mudst(const Char_t *name)
specifies the name of the mudst maker
Definition: StEEmcPi0Analysis.cxx:290
StEEmcPi0Analysis::points
void points(const Char_t *name)
specifies the name of the point maker
Definition: StEEmcPi0Analysis.cxx:283
StEEmcPi0Analysis::StEEmcPi0Analysis
StEEmcPi0Analysis(const Char_t *name)
constructor
Definition: StEEmcPi0Analysis.cxx:35
StSpinDbMaker::print
void print(int level=0)
vs. STAR==yellow bXing
Definition: StSpinDbMaker.cxx:464
StEEmcCluster::isNeighbor
Bool_t isNeighbor(const StEEmcTower &tower) const
Returns true if tower is adjacent to any tower in the cluster.
Definition: StEEmcCluster.cxx:188
StEEmcPair::zgg
Float_t zgg() const
Returns energy-sharing of pair.
Definition: StEEmcPair.h:75
StEEmcPi0Analysis::mEEpoints
StEEmcPointMaker * mEEpoints
pointer to the point maker
Definition: StEEmcPi0Analysis.h:84
StEEmcPi0Analysis::mMuDst
StMuDstMaker * mMuDst
pointer to mudst
Definition: StEEmcPi0Analysis.h:86
StEEmcPi0Analysis::getSpinState
Int_t getSpinState(StMuDst *mu, Int_t &bxs)
method to retrieve 4bit spin state
Definition: StEEmcPi0Analysis.cxx:526
StEEmcTower::sector
Int_t sector() const
Returns sector of this tower, pre- or postshower element.
Definition: StEEmcTower.h:41
StEEmcPi0Analysis::hEventCounter
TH1F * hEventCounter
histogram to keep track of where events get cut
Definition: StEEmcPi0Analysis.h:136
StSpinDbMaker::BXyellowUsingBX48
int BXyellowUsingBX48(int bx48)
4bit spin information
Definition: StSpinDbMaker.cxx:341
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
StEEmcPair::energy
Float_t energy() const
Returns energy of pair.
Definition: StEEmcPair.h:74
StEEmcCluster::numberOfTowers
Int_t numberOfTowers() const
Get the number of towers in cluster.
Definition: StEEmcCluster.h:76
EEmcGeomSimple
EEMC simple geometry.
Definition: EEmcGeomSimple.h:22
kStOK
Definition: Stypes.h:40
StEEmcPi0Analysis::Clear
void Clear(Option_t *opts="")
clears the maker
Definition: StEEmcPi0Analysis.cxx:585
StEEmcPi0Analysis::mTriggerList
std::vector< Int_t > mTriggerList
Definition: StEEmcPi0Analysis.h:92
StEEmcPoint::tower
void tower(const StEEmcTower &t, Float_t w=1.)
Add a tower with specified weight to the point.
Definition: StEEmcPoint.h:38
StEEmcTower::et
void et(Float_t e)
Definition: StEEmcTower.h:34
StEEmcElement::adc
void adc(Float_t a)
Set the pedestal-subtracted ADC for this element.
Definition: StEEmcElement.h:19
StEEmcPi0Analysis::hPairCounter
TH1F * hPairCounter
histogram to keep track of where candidates get cut
Definition: StEEmcPi0Analysis.h:139
StEEmcPi0Analysis::mixer
void mixer(const Char_t *name)
Definition: StEEmcPi0Analysis.cxx:276
StEEmcPi0Analysis::mEEmixer
StEEmcMixMaker * mEEmixer
Pointer to the pi0 mixer.
Definition: StEEmcPi0Analysis.h:82
StEEmcCluster
A base class for describing clusters of EEMC towers.
Definition: StEEmcCluster.h:50
StEEmcPair::mass
Float_t mass() const
Returns invariant mass of pair.
Definition: StEEmcPair.h:73
StEEmcA2EMaker::tower
StEEmcTower & tower(Int_t index, Int_t layer=0)
Definition: StEEmcA2EMaker.h:69
StEEmcMixEvent::mADC
Float_t mADC[720]
Definition: StEEmcMixEvent.h:54
StEEmcMixMaker
A class for mixing pi0 candidates.
Definition: StEEmcMixMaker.h:22
StSpinDbMaker::getSpin8bits
const int * getSpin8bits()
experts only
Definition: StSpinDbMaker.cxx:424
StEEmcPi0Analysis::spin
void spin(const Char_t *name)
specifies the name of the spin db maker
Definition: StEEmcPi0Analysis.cxx:302
StEEmcPi0Analysis::mEEanalysis
StEEmcA2EMaker * mEEanalysis
pointer to analysis maker
Definition: StEEmcPi0Analysis.h:88
StEEmcMixMaker::candidate
StEEmcPair candidate(Int_t c)
Return a specified candidate pair.
Definition: StEEmcMixMaker.h:45
StEEmcElement::energy
void energy(Float_t e)
Set the energy (adc-ped+0.5)/gain for this element.
Definition: StEEmcElement.h:21
StEEmcPair
A class to represent pairs of points.
Definition: StEEmcPair.h:9
StMuTriggerIdCollection
Collection of trigger ids as stored in MuDst.
Definition: StMuTriggerIdCollection.h:31
SpinHistos
Spin sorted pi0 histograms.
Definition: SpinHistos.h:22
Generated by   doxygen 1.8.5