StEEmcMixMaker.h

#ifndef __StEEmcMixMaker_h__
#define __StEEmcMixMaker_h__

#include <StMaker.h>
#include <vector>
#include <algorithm>
#include "TString.h"

class TH1F;
class TH2F;

#include "StEEmcPoint.h"
#include "StEEmcPair.h"

class TRandom;
class StEEmcPointMaker;
class StMuDstMaker;
class StEEmcA2EMaker;
class StMuEvent;
class EEmcGeomSimple;

class StEEmcMixMaker : public StMaker {

 public:

  StEEmcMixMaker( const Char_t *name, Int_t size=20 );
  ~StEEmcMixMaker(){ /* nada */ };

  void mudst( const Char_t *name );
  void points( const Char_t *name );
  void analysis( const Char_t *name );

  Int_t numberOfCandidates();
  Int_t numberOfMixedCandidates(); 

  StEEmcPair candidate(Int_t c){ return mCandidates[c]; }
  StEEmcPair mixedCandidate(Int_t m) { return mBackground[m]; }

  Int_t Init();
  Int_t Make();
  void  Clear( Option_t *opts="" );

  void sector( Int_t sector );
  void trigger( Int_t trigger );

  void minET( Float_t et );
  void maxZ( Float_t z );
  void minEpoint( Float_t m );


  void setTrigMode(Int_t m){ mTrigMode=m; }


  void book();
  void fill();
  void fill ( std::vector<TH1F *> &h, StEEmcPair pair ); 
  void fillQA( std::vector<TH2F *> &h, StEEmcPair pair ); 

  void range( Float_t min, Float_t max ); 


  void fixedVertex(Float_t x, Float_t y, Float_t z){ mFixedVertex=TVector3(x,y,z); }
  void floatVertex(Float_t x, Float_t y, Float_t z, Float_t s){ fixedVertex(x,y,z); mSigmaVertex=s; }

 private:
 protected:

  TVector3 mFixedVertex;
  Float_t  mSigmaVertex;

  Float_t mETcut;
  Float_t mZcut;
  Float_t mEpoint;

  Int_t mTrigMode;
  void fillPool();

  std::vector<Int_t> mSectorList;
  std::vector<Int_t> mTriggerList;

  std::vector<TH1F*> mH1; 
  std::vector<TH2F*> mH2; 

  std::vector<TH1F*> mH1real; 
  std::vector<TH2F*> mH2real; 

  std::vector<TH1F*> mH1mix; 
  std::vector<TH2F*> mH2mix; 

  StMuDstMaker     *mMuDstMaker; 
  StEEmcPointMaker *mEEpoints;   
  StEEmcA2EMaker   *mEEanalysis; 

  TString mMuDstMakerName;
  TString mPointMakerName;
  TString mAnalysisName;

  EEmcGeomSimple *mEEmcTow;

  StEEmcPointVec_t mPoints;


  std::vector< StEEmcPointVec_t > mPool;

  StEEmcPairVec_t mCandidates;
  StEEmcPairVec_t mBackground;


  Bool_t accept(StMuEvent *);

  Float_t mMinMass, mMaxMass; 
  Int_t mPoolSize; 

  void mixReal();
  void mixBackground();


  TRandom *mRandom;

  ClassDef(StEEmcMixMaker,1);

};

inline void StEEmcMixMaker::sector(Int_t s){ mSectorList.push_back(s); }
inline void StEEmcMixMaker::trigger(Int_t t){ mTriggerList.push_back(t); }
inline void StEEmcMixMaker::minET(Float_t et){ mETcut=et; }
inline void StEEmcMixMaker::maxZ(Float_t z){ mZcut=z; }
inline void StEEmcMixMaker::minEpoint(Float_t m){ mEpoint=m; } 

inline void StEEmcMixMaker::mudst( const Char_t *n ){mMuDstMakerName=n;}
inline void StEEmcMixMaker::analysis(const Char_t *a){mAnalysisName=a;}
inline void StEEmcMixMaker::points(const Char_t *n){mPointMakerName=n; }

inline void StEEmcMixMaker::range( Float_t mn, Float_t mx ){ mMinMass=mn; mMaxMass=mx; } 

inline Int_t StEEmcMixMaker::numberOfCandidates(){ return (Int_t)mCandidates.size(); } 
inline Int_t StEEmcMixMaker::numberOfMixedCandidates(){ return (Int_t)mBackground.size(); } 
#endif