// -------------------------------------------------------------------------
// -----               PndTrackFilterTask header file                  -----
// -------------------------------------------------------------------------

/** PndTrackFilterTask.h
 * @author A. Goerres <a.goerres@fz-juelich.de>
 * @date February 2015
 * @brief Filter tracks based on minimum hits criteria.
 *
 * With this task one is able to sort out tracks coming from candidates with
 * less than a given number of hits in certain detectors.
 * Multiple filters are combined with a logical OR. So the following calls
 * would filter for a minimum of 3 hits in MVD  OR  1 in MVD and 5 in STT:
 *      filter->AddMinHitsMvdFilter(3);
 *      filter->AddMinHitsMvdAndSttFilter(1,5);
 */


#ifndef PndTrackFilterTask_H_
#define PndTrackFilterTask_H_

#include "TClonesArray.h"
#include "TString.h"

#include "PndTrack.h"
#include "FairTask.h"

class PndTrackFilterTask : public FairTask
{

public:

    /** Default constructor */
    PndTrackFilterTask();

    /** Destructor */
    virtual ~PndTrackFilterTask();


    /** Initialize the task */
    InitStatus Init();

    /** Execute the task */
    void Exec(Option_t * opt);

    /** Finish the task */
    void Finish();

    /** Enable storing to file */
    void SetPersistence(Bool_t pers = kTRUE) { fPersistence = pers; };

    /** Be verbose */
    void SetVerbose(Int_t verboseLevel = 10) { fVerbose = verboseLevel; };

    /** Accessor functions to fTrackInputBranch */
    void SetTrackInBranchName(TString branch) { fTrackInBranchName = branch; };
    TString GetTrackInBranchName() { return fTrackInBranchName; };

    /** Accessor functions to fTrackInputBranch */
    void SetTrackCandInfoInBranchName(TString branch) { fTrackCandInfoInBranchName = branch; };
    TString GetTrackCandInfoInBranchName() { return fTrackCandInfoInBranchName; };

    /** Accessor functions to fFilteredTrackOutBranchName */
    void SetFilteredTrackOutBranchName(TString branch) { fFilteredTrackOutBranchName = branch; };
    TString GetFilteredTrackOutBranchName() { return fFilteredTrackOutBranchName; };

    /** Accessor functions to fFilteredTrackCandOutBranchName */
    void SetFilteredTrackCandInfoOutBranchName(TString branch) { fFilteredTrackCandInfoOutBranchName = branch; };
    TString GetFilteredTrackCandInfoOutBranchName() { return fFilteredTrackCandInfoOutBranchName; };

    /** Set minimum hits per detector */
    void AddMinHitsFilter(Int_t minMvd, Int_t minStt, Int_t minGem, Int_t minFts, Int_t minTot);

    void AddMinHitsMvdFilter(Int_t minMvd) { AddMinHitsFilter(minMvd, 0, 0, 0, 0); }
    void AddMinHitsSttFilter(Int_t minStt) { AddMinHitsFilter(0, minStt, 0, 0, 0); }
    void AddMinHitsGemFilter(Int_t minGem) { AddMinHitsFilter(0, 0, minGem, 0, 0); }
    void AddMinHitsFtsFilter(Int_t minFts) { AddMinHitsFilter(0, 0, 0, minFts, 0); }
    void AddMinHitsTotalFilter(Int_t minTot) { AddMinHitsFilter(0, 0, 0, 0, minTot); }
    void AddMinHitsMvdAndSttFilter(Int_t minMvd, Int_t minStt) { AddMinHitsFilter(minMvd, minStt, 0, 0, 0); }
    void AddMinHitsMvdAndTotalFilter(Int_t minMvd, Int_t minTot) { AddMinHitsFilter(minMvd, 0, 0, 0, minTot); }

    /** Set maximum hits per detector */
    void AddMaxHitsFilter(Int_t maxMvd, Int_t maxStt, Int_t maxGem, Int_t maxFts, Int_t maxTot);

    void AddMaxHitsMvdFilter(Int_t maxMvd) { AddMaxHitsFilter(maxMvd, 9999, 9999, 9999, 9999); }
    void AddMaxHitsSttFilter(Int_t maxStt) { AddMaxHitsFilter(9999, maxStt, 9999, 9999, 9999); }
    void AddMaxHitsGemFilter(Int_t maxGem) { AddMaxHitsFilter(9999, 9999, maxGem, 9999, 9999); }
    void AddMaxHitsFtsFilter(Int_t maxFts) { AddMaxHitsFilter(9999, 9999, 9999, maxFts, 9999); }
    void AddMaxHitsTotalFilter(Int_t maxTot) { AddMaxHitsFilter(9999, 9999, 9999, 9999, maxTot); }


private:

    /** Check if the track machtes the hit count filter */
    Bool_t TrackMatchesHitCountFilter(PndTrack * myTrack);


    /** Branch names */
    TString fTrackInBranchName;
    TString fTrackCandInfoInBranchName;
    TString fFilteredTrackOutBranchName;
    TString fFilteredTrackCandInfoOutBranchName;
    TString fMvdPixelHitBranch;
    TString fMvdStripHitBranch;
    TString fSttHitBranch;
    TString fGemHitBranch;
    TString fFtsHitBranch;

    /** branch IDs for hits */
    Int_t fHitIDMvdPixel, fHitIDMvdStrip, fHitIDStt, fHitIDGem, fHitIDFts;

    /** Array of tracks from ideal track finder */
    TClonesArray * fInputTrack;
    TClonesArray * fInputTrackCandInfo;

    /** Filtered track array */
    TClonesArray * fFilteredTrackArray;
    TClonesArray * fFilteredTrackCandInfoArray;

    /** Store output into file */
    Bool_t fPersistence;

    /** Verbose level */
    Int_t fVerbose;

    /** A struct holding the required hits in detectors */
    typedef struct MinHits_t {
        // initialize variables to 0
        MinHits_t() : Mvd(0), Stt(0), Gem(0), Fts(0), Tot(0) {}

        // print the content
        TString GetPrint();

        Int_t Mvd, Stt, Gem, Fts, Tot;
    } MinHits_t;
    typedef struct MaxHits_t {
        // initialize variables to 9999 which should be sufficient for one track
        MaxHits_t() : Mvd(9999), Stt(9999), Gem(9999), Fts(9999), Tot(9999) {}

        // print the content
        TString GetPrint();

        Int_t Mvd, Stt, Gem, Fts, Tot;
    } MaxHits_t;

    /** Vector holding the set filters */
    std::vector<MinHits_t> fMinHitsList;
    std::vector<MaxHits_t> fMaxHitsList;

    /** Statistics for filter */
    Int_t fPassCounter, fFailCounter;

    ClassDef(PndTrackFilterTask,1);
};


#endif /* PndTrackFilterTask_H_ */