StEEmcIUMixMaker.h

#ifndef __StEEmcIUMixMaker_h__
#define __StEEmcIUMixMaker_h__

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

class TH1F;
class TH2F;

#include "StEEmcIUPoint.h"
#include "StEEmcIUPair.h"

class TRandom;
class StEEmcIUPointMaker;
class StMuDstMaker;
class StEEmcA2EMaker;
class StMuEvent;
class EEmcGeomSimple;

class StEEmcIUMixMaker : public StMaker {

 public:

  StEEmcIUMixMaker( const Char_t *name, Int_t size=20 );
  ~StEEmcIUMixMaker(){ /* 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(); 
  Int_t numberofFpoint();
  StEEmcIUPair candidate(Int_t c){ return mCandidates[c]; }
  StEEmcIUPair 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, StEEmcIUPair pair ); 
  void fillQA( std::vector<TH2F *> &h, StEEmcIUPair 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; }

  void mixLimit(Int_t m){ mMixLimits=m; }

 private:
 protected:

  TVector3 mFixedVertex; 
  Float_t  mSigmaVertex; 
  Float_t mETcut;  
  Float_t mZcut;   
  Float_t mEpoint; 
  Int_t mTrigMode; 
  void fillPool(); 
  Int_t mMixLimits; 
  std::vector<Int_t> mSectorList;    
  std::vector<Int_t> mTriggerList;   
  std::vector<Int_t> numberofFailpoint;
  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; 
  StEEmcIUPointMaker *mEEpoints;   
  
  StEEmcA2EMaker   *mEEanalysis; 
  TString mMuDstMakerName;
  TString mPointMakerName;
  TString mAnalysisName;
  EEmcGeomSimple *mEEmcTow;


  TH1F       *hZ1;
  TH1F       *hZ2;
  
  StEEmcIUPointVec_t mPoints;


  std::vector< StEEmcIUPointVec_t > mPool;

  StEEmcIUPairVec_t mCandidates;
  StEEmcIUPairVec_t mBackground;


  Bool_t accept(StMuEvent *);

  Bool_t accept( StEEmcIUPoint &p1, StEEmcIUPoint &p2 );

  Float_t mMinMass, mMaxMass; 
  Int_t mPoolSize; 

  void mixReal();
  void mixBackground();

  TRandom *mRandom;

  ClassDef(StEEmcIUMixMaker,1);

};

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

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

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

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