PndFtsHoughTrackerTask.h

Go to the documentation of this file.

#ifndef PndFtsHoughTrackerTask_H
#define PndFtsHoughTrackerTask_H

#include "PndPersistencyTask.h"
#include <cmath>
#include <vector>
#include "Rtypes.h"                     // for Double_t, Int_t, etc
#include <iostream>

#include "TVector3.h"
#include "PndFtsHit.h"
#include "TClonesArray.h"
#include "PndFtsTube.h"

class PndFtsHoughTrackCand;
class PndFtsHoughSpace;
class PndGeoFtsPar;
class FairField;

// For error reporting
#include "TString.h"
#include <stdexcept>
// for debugging
#include "FairMCPoint.h"

class PndFtsHoughTrackerTask : public PndPersistencyTask
{
public:
        enum DebugLevelMultiplicators { kHoughSpaces=2, kAllFoundPeaksTogether=3, kEachFoundPeakSeparately=5, kMcTruthPeaksExclusively=7, kMcTruthPeaksProjected=11, kHitCurvesExclusively=13, kHitCurvesProjected=17 };


        PndFtsHoughTrackerTask(Int_t verbose=0, Bool_t persistence=kTRUE);
        ~PndFtsHoughTrackerTask();

        virtual void SetParContainers();
        virtual InitStatus Init();
        virtual InitStatus ReInit();


        virtual void Exec(Option_t* opt);
        virtual void FinishEvent();

        virtual void Finish();

        //----------
        // SETTERS
        //----------
        void SetVerbose(Int_t verbose){ fVerbose = verbose;};
        void SetPersistence(Bool_t val){ SetPersistency(val);};
        void SetSaveDebugInfo(Int_t saveDebugInfo){ fSaveDebugInfo = saveDebugInfo;};
        //      void SetTrackOutput(TString name = "FTSTrkHough") { fTracksArrayName = name; };

        //----------
        // GETTERS
        //----------
        Int_t GetVerbose() const { return fVerbose; }; 
        Int_t GetSaveDebugInfo() const { return fSaveDebugInfo; }; 
        UInt_t GetEventNr() const { return fEventNr; }; 



        //-----------
        //DATA ACCESS TO FTS
        //-----------
        Int_t GetNFtsHits() const { return fFtsHitArray->GetEntriesFast(); };
        const PndFtsHit* GetFtsHit(UInt_t hitId) const {
                if ( hitId >= (UInt_t)GetNFtsHits() ) throwError("GetFtsHit: hitId is too large.");
                //              TClonesArray *ftsHitArray= (TClonesArray *)FairRootManager::Instance()->GetObject("FTSHit");
                const PndFtsHit *myHit = (PndFtsHit*) fFtsHitArray->At(hitId);
                if (0 == myHit) throwError("GetFtsHit was not able to get the hit.");
                return myHit;
        };
        Int_t getMcTruthIdForHitId(UInt_t hitId) const {
                const PndFtsHit *const ftsHit = GetFtsHit(hitId);
                Int_t mcPointId=ftsHit->GetRefIndex();
                if(0 > mcPointId) throwError("getMcTruthIdForHitId: negative mcPointId.");
                FairMCPoint* myPoint = (FairMCPoint*)(fFtsMcPoints->At(mcPointId));
                if(0==myPoint) throwError("getMcTruthIdForHitId: Could not get point belonging to hit.");
                Int_t mcTrackId = myPoint->GetTrackID();
                if(mcTrackId<0) throwError("getMcTruthIdForHitId: negative mcTrackId.");
                return mcTrackId;
        }
        const PndFtsTube* GetFtsTube(const PndFtsHit *const myHit) const {
                Int_t tubeID = myHit->GetTubeID();
                const PndFtsTube *tube = (PndFtsTube*) fFtsTubeArray->At(tubeID);
                return tube;
        }
        const TVector3 GetFtsHitPosErrors(const PndFtsHit *const ftsHit) const;
        const TMatrixT<Double_t> GetFtsHitCovMatrix(const PndFtsHit *const ftsHit) const;
        Int_t getFtsBranchId() const {  return fFtsBranchId; };
        TClonesArray* getFtsHitArrayPtr() const { return fFtsHitArray; };



        //-----------
        //DATA ACCESS TO B FIELD
        //-----------
        FairField* getMagneticFieldPtr() const { return fField; }; 


        FairLogger* fLogger; 


protected:
        //  for writing out histograms for debugging
        //      void InitOutFileForDebugging();
        //      void AddNewEventToOutFileForDebugging(UInt_t eventNr);
        //      TFile* fOutFile;

        //--------
        // General
        //--------

        //--------
        // Input
        //--------
        Int_t   fFtsBranchId; 
        TClonesArray *fFtsHitArray; 
        TClonesArray*  fFtsMcPoints;      


        PndGeoFtsPar *fFtsParameters;
        TClonesArray *fFtsTubeArray;

        FairField* fField;


        //--------
        // Output
        //--------
        TString fTracksArrayName;     
        TClonesArray  *fTrackCands;   
        TClonesArray  *fTracks;       
        //      TClonesArray *fHoughTrackCands; ///< @brief Array of found track cands in PndFtsHoughTrackCand (only for debugging)
        /* @brief Not used.
         *
         * The idea was to use this in order to write out the Hough spaces to the root file.
         * Due to bad performance this is not used. Instead, I write it out as pictures directly.
         */
        //TClonesArray *fHoughSpaces;

        //-------
        // Debug
        //-------
        Int_t fSaveDebugInfo; 
        UInt_t fEventNr; 

        void throwError(const TString s) const{ throw std::runtime_error(s.Data()); };

        void CheckForDuplicateFtsHits()
        {
                for (int iHit1 = 0; iHit1 < GetNFtsHits(); ++iHit1)
                {
                        const PndFtsHit *const myHit1 = GetFtsHit(iHit1);

                        const Int_t tubeIdHit1 = myHit1->GetTubeID();

                        for (int iHit2 = iHit1+1; iHit2 < GetNFtsHits(); ++iHit2)
                        {
                                const PndFtsHit *const myHit2 = GetFtsHit(iHit2);

                                const Int_t tubeIdHit2 = myHit2->GetTubeID();

                                if ( tubeIdHit1 == tubeIdHit2 ) std::cout << "Event " << GetEventNr() << "tubeID1="<<tubeIdHit1<<" tubeID2="<<tubeIdHit2 <<": HitIdx " << iHit1 << " and HitIdx " << iHit2 << " are duplicate!\n";
                        }

                } // for loop over all hits
        };


        // TODO: I don't think I need the copy constructor and the operator=
        PndFtsHoughTrackerTask(const PndFtsHoughTrackerTask&);
        PndFtsHoughTrackerTask operator=(const PndFtsHoughTrackerTask&);

ClassDef(PndFtsHoughTrackerTask,1);
};

#endif