StEEmcIUPi0Analysis.h

#ifndef __StEEmcIUPi0Analysis_h__
#define __StEEmcIUPi0Analysis_h__

#include "StMaker.h"

#include "StMuDSTMaker/COMMON/StMuDstMaker.h"
#include "StMuDSTMaker/COMMON/StMuDst.h"
#include "StMuDSTMaker/COMMON/StMuEvent.h"
#include "StMuDSTMaker/COMMON/StMuTriggerIdCollection.h"
#include "StMuDSTMaker/COMMON/StMuPrimaryVertex.h" 
#include "StEvent/StTriggerId.h" 

#include "StSpinPool/StSpinDbMaker/StSpinDbMaker.h"

#include "StEEmcIUMixEvent.h" 
//#include "StEEmcMcReadMaker/StMcOutputMaker.h"

class StEEmcIUMixMaker;
class StEEmcIUPointMaker;
class StRFEmcTrigMaker;
class TH1F;
class TH2F;
class TH2D;
class TFile; 
class SpinCutsIU; 
class EEmcGeomSimple;
class StEEmcA2EMaker; 
class TTree; 
//class StMcOutputMaker;
#include <vector>
#include "StEEmcIUPair.h"
#include "SpinIUHistos.h"
#include "TString.h" 

class StEEmcIUPi0Analysis : public StMaker
{

 public:
  StEEmcIUPi0Analysis(const Char_t *name);
  ~StEEmcIUPi0Analysis(){ /* nada */ };

  Int_t Init();
  Int_t Make();
  Int_t InitRun(Int_t);

  Int_t numbofcutCandidate();
  void  Clear(Option_t *opts="");
  void mixer(const Char_t *name);
  void points(const Char_t *name);
  void mudst(const Char_t *name); 
  void analysis(const Char_t *name); 
  void spin(const Char_t *name);

  void trigger(Int_t trig){ mTriggerList.push_back(trig); }

  void minbias(Int_t trig){ mMinBias = trig; }

  SpinCutsIU *cuts(){ return mCuts; } 

  void filename(const Char_t *fname){ mFilename=fname; } 

  void triggerSim( const Char_t *name, Int_t t ) { mTrigSim=(StRFEmcTrigMaker*)GetMaker(name); mTrigSimThreshold=t; }

 private:
 protected:

  Bool_t twoBodyCut( StEEmcIUPair &p );

  StEEmcIUMixMaker   *mEEmixer;  
  StEEmcIUPointMaker *mEEpoints; 
  StMuDstMaker *mMuDst; 
  StEEmcA2EMaker *mEEanalysis; 
  StSpinDbMaker  *mSpinDb;
 
  std::vector<Int_t> mTriggerList;   
  Int_t mMinBias;                    
  enum SpinStates { kAny=0, kUpUp, kUpDn, kDnUp, kDnDn };

  SpinIUHistos *mHistograms[5];
  SpinIUHistos *mBackgrounds[5];
  SpinCutsIU   *mCuts; 
  TH1F       *hFillPatternI;    
  TH1F       *hSpin4;           
  TH1F       *hBx7;             
  TH1F       *hBx48;            
  TH2F       *hBx7diffBx48;     
  TH1F       *hBxStar;          
  TH1F       *hBxStarPi0;       
  TH1F       *hPi0Mass;
  TH1F       *hPTvsPiNum;       // pi0# vs pt
  TH1F       *hMcEta; 
  TH1F       *hMcPhi; 
  TH1F       *hMcPt;
  TH2F       *hREtaPhi;
  TH1F       *hReconEta;
  TH1F       *hReconPhi; 
  TH1F       *hEEmcEta;
  TH1F       *hResoEta;
  TH1F       *hResoPhi;
  TH1F       *hResoPt;
  TH2F       *hResoPtvsG;
  TH1F       *hMcEnergy;
  TH1F       *hResoEnergy;
  TH2F       *hResoEnergyvsG;
  TH1F       *hRecoEnergy; 
  TH1F       *hZvert;   
  TH2F       *hMassBx;          
  TH2F       *hZvertBx;         
  TH2F       *hZggBx;           
  TH2F       *hEtaBx;           
  TH1F       *hSpin4mb;         
  TH1F       *hRealMcPD;
  TH1F       *hRealMcPR;
  TH2F       *McEvsMass;
  TH2F       *DEtaMass;
  TH2F       *DPhiMass;

  TH2D       *dUvsdV;
  TH2D       *dUvsdVGood;
  TH1F       *dUVzeroE;
  TH1F       *dUVzeroEta;
  TH2F       *dUvsRatio;
  TH2F       *dUvsRatioGood;
  TH2F       *dVvsRatio;
  TH2F       *dVvsRatioGood;

  TH2F       *GoodPiGeo;
  TH1F       *GoodPiPt;
  TH1F       *EventCounter;
  TH1F       *hPi0Counter;
  enum EventCutTypes { 
      kEvent=0,
      kMinBias, 
      kTrig,
      kSoftTrig, 
      kSoftTrig36, 
      kVertex,
      kCandidate 
  }; 

  enum PairCutTypes {
      kPair=1, 
      kTwoBody,
      kAdcTow,
      kEtTow,
      kKinematics 
  }; 
      
  TH1F *hEventCounter; 

  TH1F *hPairCounter; 

  Bool_t accept(StMuDst *mu); 
  Bool_t accept(StEEmcIUPair pair, Bool_t fill=true ); 

  Int_t getSpinState(StMuDst *mu, Int_t &bxs);

  TString mFilename;
  TFile *mFile; 

  StRFEmcTrigMaker *mTrigSim;
  Int_t mTrigSimThreshold;

  Int_t mRunNumber;
  Bool_t mSpinSort;
  Int_t numcutCan;
  Int_t numoacceptedpair;
  EEmcGeomSimple *mEEgeom;

  StEEmcIUMixEvent *mRealEvent;
  StEEmcIUMixEvent *mMixedEvent; 


  TTree *mRealTree;
  TTree *mMixedTree; 

  ClassDef(StEEmcIUPi0Analysis,1);  

};
inline Int_t StEEmcIUPi0Analysis::numbofcutCandidate(){return (Int_t) numcutCan;}
#endif