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