/***************************************************************************
 *
 * $Id: StHiMicroMaker.h,v 1.3 2002/05/31 21:50:14 jklay Exp $
 *
 * Author: Bum Choi, UT Austin, Apr 2002
 *
 ***************************************************************************
 *
 * Description:  This Maker creates the highpt uDST's from StEvent' 
 *		 for highpt Analysis.
 *
 ***************************************************************************
 *
 * $Log: StHiMicroMaker.h,v $
 * Revision 1.3  2002/05/31 21:50:14  jklay
 * Fixed the way centrality is calculated, see README
 *
 * Revision 1.2  2002/04/03 00:37:41  jklay
 * Fixed some bugs, added new version of dcaz
 *
 * Revision 1.1  2002/04/02 20:00:41  jklay
 * Bums highpt uDST Maker
 *
 *
 **************************************************************************/
#ifndef StHiMicroMaker_hh     
#define StHiMicroMaker_hh

#ifndef __CINT__
#include <utility>
#endif

//#include "StMaker.h"

#include "TString.h"
#include "TFile.h"
#include "TTree.h"
#include "TNtuple.h"
#include "StChain/StMaker.h"
#include "StarClassLibrary/StThreeVectorF.hh"

//  technique is that the these classes do not get passed
//  through rootcint.
//
class StHiMicroEvent;
class StPhysicalHelixD;
class StEvent;
class StFpdCollection;
class StCtbTriggerDetector;
class StZdcTriggerDetector;
class StBbcTriggerDetector;
class StTrack;
class StIOMaker;
class StMuDstMaker;
class StMuEvent;
class StMuTrack;
class StMuDst;

#ifndef ST_NO_NAMESPACES
using std::string;
#endif

class StHiMicroMaker : public StMaker {
 public:

    StHiMicroMaker(const Char_t *makerName="micro");
    ~StHiMicroMaker();                         
    
    void   Clear(Option_t *option="");   
    Int_t  Init(); 
    Int_t  InitRun(int runumber); 
    Int_t  Make(); 
    Int_t  Finish();

    void     setDebug(Int_t debug=1) { mDebug = debug; }
    //       loop over all track nodes even for events w/o a primary vtx
    void     setSaveAllEvents(bool val=false)	{mSaveAllEvents = val;}
    void     setHitLoop(Int_t doit=1) { mHitLoop=doit; }
    void     setOutDir(const char* dir= "./")  { mOutDir = dir; }
    void     setSaveLowPt(Int_t doit=1) { mSaveLowPt=doit; }

    bool     SaveAllEvents() const {return mSaveAllEvents;}
 private:
    void     getBeamLine();
    void     processStEvent(StEvent*);
    void     processMuDst(StMuDst*);
    void     fillCtbZdcBbc(StCtbTriggerDetector &, StZdcTriggerDetector &,
			   StBbcTriggerDetector &);
    void     fillQuadrant();
    void     fillEvent(StEvent*);
    void     fillEvent(StMuDst*);
    void     fillTracks(StEvent*);
    void     fillTracks(StMuDst*);
    void     fillFpdCollection(StEvent*);
    void     dump(StTrack* prTrack,StTrack* glTrack);
    void     dump(StMuTrack* prTrack,StMuTrack* glTrack);
    void     computeQuadrant(StEvent*);
    void     computeQuadrant(StMuDst*);
    
    Float_t  computeXY(const StThreeVectorF&, const StPhysicalHelixD &);
    double   dcaz(const StPhysicalHelixD& helix, 
		  const StThreeVectorF& point);

    Int_t    openFile();
    Int_t    closeFile();

    bool accept(StEvent*);            // this method serves as an event filter
    bool accept(StMuEvent*);          // this method serves as an event filter
    bool accept(StTrack*);            // and this is used to select tracks
    bool accept(StMuTrack*);          // and this is used to select tracks
    bool acceptNch(StTrack*,StEvent*);
    bool acceptNch(StMuTrack*,StMuEvent*);
    bool acceptLead(StTrack*,StEvent*);
    bool acceptLead(StMuTrack*,StMuEvent*);
    bool acceptFTPC(StTrack*,StEvent*);
    bool acceptFTPC(StMuTrack*,StMuEvent*);
    bool goodGlobal(StTrack*);
    bool goodGlobal(StMuTrack*);
    bool goodGlobalCTBMatch(StTrack*,unsigned int);
    bool goodGlobalCTBMatch(StMuTrack*,unsigned int);
    bool goodGlobalFlag(StTrack*);
    bool goodGlobalFlag(StMuTrack*);

    // 0 if Nch, 1 if FTPCe, 2 FTPCw, -1 doesnt pass cuts
    Int_t type(StTrack*,StEvent*); 
    Int_t type(StMuTrack*,StMuEvent*); 

    TString    mDSTName;      //!
    TFile*     mDSTFile;      //!
    TTree*     mDSTTree;      //!
    StIOMaker* mIOMaker;      //!
    StMuDstMaker* mMudstMaker;   //!
    TString    mInFileName;   //!
    TString    mOutDir;       //!

    Int_t      mNEvent;       //!
    Int_t      mNAcceptedEvent;//!
    Int_t      mNAcceptedTrack;//!
    bool       mSaveAllEvents; //!If all events are saved, can look at vertex efficiency with ZDC info
    Int_t      mDebug;         //!
    Int_t      mHitLoop;       //!
    Int_t      mSaveLowPt;     //

    Int_t      mFTPCe;
    Int_t      mFTPCw;

    struct Quadrant{
      Int_t    QLead;
      Int_t    QOpp;
      Int_t    QA;
      Int_t    QB;

      StThreeVectorF LeadMom; 
    };    
    Quadrant   mQuad[3];  //!  0 Nch, 1 FTPCe, 2 FTPCw

    StPhysicalHelixD*  mBeamLineHelix; //!
    StHiMicroEvent*    mHiMicroEvent; //!


    ClassDef(StHiMicroMaker,2)
};
#endif