PndFtsTrackerIdeal Class Reference

#include <PndFtsTrackerIdeal.h>

Inheritance diagram for PndFtsTrackerIdeal:

Public Member Functions
	PndFtsTrackerIdeal ()
virtual	~PndFtsTrackerIdeal ()
virtual void	Exec (Option_t *option)
virtual InitStatus	Init ()
virtual void	Finish ()
void	Reset ()
void	Register ()
void	SetParContainers ()
void	SetTrackOutput (TString name="FTSTrkIdeal")
void	SetMomentumSmearing (Double_t sigmax=-1., Double_t sigmay=-1., Double_t sigmaz=-1.)
void	SetRelativeMomentumSmearing (Double_t dpop=-1.)
void	SetVertexSmearing (Double_t sigmax=-1., Double_t sigmay=-1., Double_t sigmaz=-1.)
void	SetTrackingEfficiency (Double_t eff=1.)
Int_t	SetMinFtsHitsPerTrack (Int_t minFtsHitsPerTrack=5)
void	DeactivateFtsStation (Int_t i)
void	SetFtsActivity (Bool_t act=kTRUE)
void	SetGemActivity (Bool_t act=kTRUE)
void	SetMvdActivity (Bool_t act=kTRUE)
void	SetPersistence (Bool_t persistence)

Protected Member Functions
void	SmearFWD (TVector3 &vec, const TVector3 &sigma)
	PndFtsTrackerIdeal (const PndFtsTrackerIdeal &L)
PndFtsTrackerIdeal &	operator= (const PndFtsTrackerIdeal &)
	ClassDef (PndFtsTrackerIdeal, 1)

Protected Attributes
TClonesArray *	fMCTracks
TClonesArray *	fMCPoints [4]
	Array of PndMCTrack. More...
TClonesArray *	fHits [4]
	Array of event's points. More...
Int_t	fBranchIDs [4]
	Array of event's hits. More...
Bool_t	fBranchActive [4]
	Array of Branch IDs. More...
std::map< int, bool >	fStationsDisabled
	Array of Branch Activeness. More...
TClonesArray *	fTrackCands
	Array of disabled stations. More...
TClonesArray *	fTracks
	Array of found track candidates. More...
TClonesArray *	fTrackIds
	Array of found tracks. More...
Int_t	fMinFtsHitsPerTrack
	Array of track IDs (Links) More...
TVector3	fMomSigma
Double_t	fDPoP
Bool_t	fRelative
TVector3	fVtxSigma
Double_t	fEfficiency
Bool_t	fPersistence
TString	fTracksArrayName
TDatabasePDG *	pdg
PndGeoFtsPar *	fFtsParameters
	Particle DB. More...
TClonesArray *	fTubeArrayFts

Detailed Description

Definition at line 34 of file PndFtsTrackerIdeal.h.

Constructor & Destructor Documentation

PndFtsTrackerIdeal::PndFtsTrackerIdeal

(

)

Definition at line 37 of file PndFtsTrackerIdeal.cxx.

References fBranchActive, fMomSigma, fTrackCands, fTracks, fVerbose, fVtxSigma, i, and SetTrackOutput().

                                      :
    FairTask("FTSTrackfinderIdeal"), fMCTracks(0), fTrackCands(0), fTracks(0),
    fTrackIds(0), fMinFtsHitsPerTrack(5), fMomSigma(0,0,0), fDPoP(0.), fRelative (kFALSE), fVtxSigma(0,0,0), fEfficiency(1.), fPersistence(kTRUE),
    fTracksArrayName("FTSTrkIdeal"), pdg(0)
{
  //---
  fTrackCands = new TClonesArray("PndTrackCand");
  fTracks = new TClonesArray("PndTrack");
  fVerbose = 0;
  fMomSigma.SetXYZ(0.,0.,0.);
  fVtxSigma.SetXYZ(0.,0.,0.);
  SetTrackOutput();
  fBranchActive[0]=kTRUE;
  for (int i=1;i<4;i++) fBranchActive[i]=kFALSE;
}

PndFtsTrackerIdeal::~PndFtsTrackerIdeal ( )

virtual

Definition at line 54 of file PndFtsTrackerIdeal.cxx.

{
  FairRootManager *fManager =FairRootManager::Instance();
  fManager->Write();
}

PndFtsTrackerIdeal::PndFtsTrackerIdeal ( const PndFtsTrackerIdeal &  L )

protected

Member Function Documentation

PndFtsTrackerIdeal::ClassDef ( PndFtsTrackerIdeal  , 1    )

protected

void PndFtsTrackerIdeal::DeactivateFtsStation ( Int_t  i )

inline

Definition at line 58 of file PndFtsTrackerIdeal.h.

References fStationsDisabled, and i.

{fStationsDisabled[i]=true;};

void PndFtsTrackerIdeal::Exec ( Option_t *  option )

virtual

Definition at line 152 of file PndFtsTrackerIdeal.cxx.

References PndTrackCand::AddHit(), At, Double_t, fBranchActive, fBranchIDs, fDPoP, fEfficiency, fHits, fMCPoints, fMCTracks, fMinFtsHitsPerTrack, fMomSigma, fRelative, fStationsDisabled, fTrackCands, fTracks, fTubeArrayFts, fVerbose, fVtxSigma, PndTrackCandHit::GetDetId(), GetEntriesFast(), PndTrackCandHit::GetHitId(), PndFtsHit::GetLayerID(), PndTrackCand::GetNHits(), PndMCTrack::GetPdgCode(), PndTrackCand::GetSortedHit(), hit, PndFtsTube::IsSkew(), pdg, pnt, Reset(), PndTrackCand::setMcTrackId(), SmearFWD(), and PndTrackCand::Sort().

{
  Reset();
  if(fVerbose>3) Info("Exec","Start eventloop.");
  if(fVerbose>4){
    Info("Exec","Print some array properties");
    for(int iii=0;iii<4;iii++){
      std::cout<<"fHits["<<iii<<"] is branchID "<<fBranchIDs[iii]<<" with the name "<<fHits[iii]->GetName()<<" and contains "<<fHits[iii]->GetEntriesFast()<<" entries."<<std::endl;
      std::cout<<"fMCPoints["<<iii<<"] with the name "<<fMCPoints[iii]->GetName()<<" and contains "<<fMCPoints[iii]->GetEntriesFast()<<" entries."<<std::endl;
    }
  }

  // Do we have enough hits in the FTS in this particular event?
  if(fHits[0]->GetEntriesFast() < fMinFtsHitsPerTrack) {
    if(fVerbose>3) Info("Exec","Skip the event, since we have less than %i hits in FTS", fMinFtsHitsPerTrack);
    return;
  }


  FairHit* ghit = NULL;
  std::map<Int_t, FairHit*> firstHit;
  std::map<Int_t, FairHit*> lastHit;
  FairMCPoint* myPoint=NULL;
  std::map<Int_t, FairMCPoint*> firstPoint;
  std::map<Int_t, FairMCPoint*> lastPoint;
  std::map<Int_t, PndTrackCand*> candlist;

  // Loop over all hits from FTS first (later other detectors, too)
  // When looping over FTS hits create a PndTrackCand with the same index as the MC truth track if we find at least one FTS hit
  // After the FTS Hit Loop remove all candidates which do not have at least fMinFtsHitsPerTrack hits (from FTS)
  // and remove all tracks which are bent in the dipole so much that they turn around and fly towards the barrel again (this leads to problems in the fitter)
  //  I will remove such tracks at the end of the loop on FTS hits. I plan to check all (MC truth) time-ordered FTS hits associated to a given PndTrackCand and check if the z-component is increasing. If not, I will remove the PndTrackCand.
  // When looping over the other detectors only hits are added to PndTrackCand objects which were created in the loop over FTS hits and NOT removed afterwards

  // Detector loop
  for(Int_t iDet=0;iDet<4;iDet++){
    if (kFALSE == fBranchActive[iDet]) continue; //skip manually switched off detector
    if(fVerbose>4) Info("Exec","Use detector %i",iDet);
    // Hit loop
    for (Int_t ih = 0; ih < fHits[iDet]->GetEntriesFast(); ih++) {
      ghit = (FairHit*) fHits[iDet]->At(ih);
      if(!ghit) {
        if(fVerbose>3) Error("Exec","Have no ghit %i, array size: %i",ih,fHits[iDet]->GetEntriesFast());
        continue;
      }
      if(iDet==0)
      {
        if(fStationsDisabled.size() > 0)
        {
          PndFtsHit* myhit = (PndFtsHit*) fHits[iDet]->At(ih);
          if(fStationsDisabled.find(myhit->GetLayerID()) != fStationsDisabled.end()) continue;
        }
      }
      Int_t mchitid=ghit->GetRefIndex();
      if(mchitid<0) {
        if(fVerbose>3) Error("Exec","Have a negative mcHit %i",mchitid);
        continue;
      }
      myPoint = (FairMCPoint*)(fMCPoints[iDet]->At(mchitid));
      if(!myPoint) continue;
      Int_t trackID = myPoint->GetTrackID();
      if(trackID<0) continue;

      if(fVerbose>5) Info("Exec","Have a Hit %i at Track index %i",ih,trackID);

      // Continue Construction of a track candidate (start with FTS hits)
      // Track candidates and corresponding MC track index are saved in a map
      PndTrackCand* cand=candlist[trackID];
      if(NULL==cand){
        if(0!=iDet){
          if(fVerbose>5) Info("Exec","Skip Hit %i, it's not connected to a Track in FTS",ih);
          continue; // skip Tracks in MVD/GEM not going to FTS
        }
        if(fVerbose>5) Info("Exec","Create new PndTrack object %i",trackID);
        cand=new PndTrackCand();
        cand->setMcTrackId(trackID);
        if(fVerbose>5) Info("Exec","Creating new PndTrack object finished %i",trackID);
      }
      if(fVerbose>5) Info("Exec","add the hit %i to trackcand %i",ih,trackID);
      cand->AddHit(fBranchIDs[iDet],ih,myPoint->GetTime());
      // Figure out if the current hit is the earliest in the event
      if(!firstHit[trackID] || firstPoint[trackID]->GetTime() > myPoint->GetTime()) {
        firstHit[trackID]=ghit;
        firstPoint[trackID]=myPoint;
      }
      // or the latest one
      if(!lastHit[trackID] || lastPoint[trackID]->GetTime() < myPoint->GetTime()) {
        lastHit[trackID]=ghit;
        lastPoint[trackID]=myPoint;
      }

      candlist[trackID] = cand; // set
    }// end loop over hits





    // TODO: Check if the following loops work
    // After the FTS Hit Loop remove all candidates which do not have at least fMinFtsHitsPerTrack hits (from FTS)
    // and remove all tracks which are bent in the dipole so much that they turn around and fly towards the barrel again (this leads to problems in the fitter)
    if(0==iDet){ // only needed after PndTrkCand contain only FTS hits
      if(fVerbose>5) Info("Exec","Remove all PndTrkCand which are not realistic to be found by FTS Pattern Recognition");

      // re-iterate over candlist and save key values for PndTrkCand which are not realisitic to be found by FTS PR in a vector
      // these will be deleted after the clean loop
      std::map<Int_t, PndTrackCand*>::iterator  candit;
      std::vector<Int_t> keysToDeleteFromCandList;

      if(fVerbose>10){
        cout << "print the map keys BEFORE cleaning\n";
        for(candit=candlist.begin(); candit!=candlist.end(); ++candit) {
          cout << "trackID == " << candit->first << endl;
        }
      }


      for(candit=candlist.begin(); candit!=candlist.end(); ++candit) {
        Int_t trackID=candit->first;
        PndTrackCand* tcand=candit->second;
        if(!tcand) {
          if(fVerbose>3) Warning("Exec","Have no candidate at %i",trackID);
          continue;
        }
        // remove tcand if it does not have enough hits from FTS (after run with iDet == 0 only FTS hits are filled)
        if( (int)tcand->GetNHits() < fMinFtsHitsPerTrack ){ // TODO: Make this criterion more realistic
          if(fVerbose>9){
            Info("Exec","Mark candlist[%i] for deletion because it has only %i FTS hits which is not enough.", trackID, tcand->GetNHits());
          }
          keysToDeleteFromCandList.push_back(trackID);
          continue;
        }

        // check if tcand is deflected too much in dipole and turns around again
        tcand->Sort();

        // Go through all hits of the PndTrkCand and check if their z values are increasing.
        // If not, remove the PndTrkCand from candlist
        Double_t lastz = -100.; // saves the z-position of the last hit
        for( size_t iSortedHit=0; iSortedHit<tcand->GetNHits(); ++iSortedHit ) {
          // TODO: This needs to be checked
          if(fVerbose>11) Info("Exec","Look at hit iSortedHit == %i", (int)iSortedHit);
          PndTrackCandHit candhit = tcand->GetSortedHit(iSortedHit);
          Int_t hitID = candhit.GetHitId();
          Int_t detID = candhit.GetDetId();
          if(fVerbose > 11) {
            cout << "PndFtsTrackerIdeal at cleaning loop\n";
            cout << "candhit = " << candhit << endl;
            cout << "hitID = " << hitID << endl;
            cout << "detID = " << detID << endl;
          }
          FairHit *hit = NULL;
          // check if it really comes from the FTS (should always be true)
          if(detID == FairRootManager::Instance()->GetBranchId("FTSHit")) {
            hit = (PndFtsHit*) fHits[iDet]->At(hitID);
            Int_t tubeID = ((PndFtsHit*) hit)->GetTubeID();
            PndFtsTube *tube = (PndFtsTube*) fTubeArrayFts->At(tubeID);
            if( tube->IsSkew() ){ // only check and count non-skewed hits
              if(hit->GetRefIndex() == -1) {
                Error("Exec","Cleaning loop found a hit which was not caused by any MC truth track at iSortedHit == %i",(int)iSortedHit);
              }
              else {
                PndFtsPoint *pnt = (PndFtsPoint*) fMCPoints[0]->At(hit->GetRefIndex());
                //if(tube->IsSkew()) nofFtsSkewPoints++;
                //else nofFtsSkewPoints++;
                // TODO: count if I have enough non-skewed hits from layers 1+2 and 3-5

                // determine if z-coordinates are increasing
                if ( pnt->GetZ() < lastz ){
                  if(fVerbose>9){
                    Info("Exec","Mark candlist[%i] for deletion because the track turns around in the dipole field (its time-sorted hits have decreasing z values at some point).", trackID);
                  }
                  // delete candlist[trackID] check if this works
                  keysToDeleteFromCandList.push_back(trackID);
                  break; // do not look at further hits from that track, look at next track
                }
                else {
                  lastz = pnt->GetZ();
                }
              }
            } // if IsSkew
          } else Error("Exec","Cleaning loop found a hit from a detector other than FTS at iSortedHit == %i",(int)iSortedHit);



        } // sorted hit loop
        if(fVerbose>3) Info("Exec","Ended cleaning loop for candidate with trackID %i",trackID);
      } // for candidate cleaning loop


      // now delete all keys from candlist that have previously been saved in the vector keysToDeleteFromCandList
      for (size_t iKey=0; iKey<keysToDeleteFromCandList.size(); ++iKey){
        if(fVerbose>10){
          std::cout << "Delete key " << keysToDeleteFromCandList[iKey] << std::endl;
        }
        candlist.erase(keysToDeleteFromCandList[iKey]);
      }
      keysToDeleteFromCandList.clear();

      if(fVerbose>10){
        cout << "print the map keys AFTER cleaning\n";
        for(candit=candlist.begin(); candit!=candlist.end(); ++candit) {
          cout << "trackID == " << candit->first << endl;
        }
      }

    } // if only FTS hits filled


  }// end loop over detectors
  // now we have track candidates
  if(fVerbose>3) Info("Exec","Insert to TCA (depending on efficiency)");

  // re-iterate and select by efficiency & number of hits
  std::map<Int_t, PndTrackCand*>::iterator  candit;
  //FairTrackParP* firstPar=NULL;
  //FairTrackParP* lastPar=NULL;
  PndMCTrack *mc=NULL;
  TVector3 svtx, smom;
  Int_t charge=0, trackID=-1;

  for(candit=candlist.begin(); candit!=candlist.end(); ++candit) {
    PndTrackCand* tcand=candit->second;
    trackID=candit->first;
    if(!tcand) {
      if(fVerbose>3) Warning("Exec","Have no candidate at %i",trackID);
      continue;
    }
    if( tcand->GetNHits() < 3 ) continue; // Here the total number of hits in the candidate are considered, not just the FTS hits. Note that this is obsolete in case fMinFtsHitsPerTrack is set to 3 or more
    if(0 < fEfficiency && fEfficiency < 1){
      if(gRandom->Rndm() > fEfficiency) continue;
    }
    tcand->Sort();
    mc = (PndMCTrack*)fMCTracks->At(trackID);
    if (mc->GetPdgCode()<100000000) charge = (Int_t)TMath::Sign(1.0, ((TParticlePDG*)pdg->GetParticle(mc->GetPdgCode()))->Charge());
    else charge = 1;
    tcand->setMcTrackId(trackID);
    // prepare track parameters
    firstPoint[trackID]->Position(svtx); // set position to first hit
    SmearFWD(svtx, fVtxSigma);
    firstPoint[trackID]->Momentum(smom);
    if (fRelative) fMomSigma.SetXYZ(fDPoP*smom.Mag(),fDPoP*smom.Mag(),fDPoP*smom.Mag());
    SmearFWD(smom, fMomSigma);
    FairTrackParP* firstPar=new FairTrackParP(svtx, smom,
        fVtxSigma, fMomSigma,
        charge, svtx,
        TVector3(1.,0.,0.), TVector3(0.,1.,0.));

    lastPoint[trackID]->Position(svtx);
    SmearFWD(svtx, fVtxSigma);
    lastPoint[trackID]->Momentum(smom);
    SmearFWD(smom, fMomSigma);
    FairTrackParP* lastPar=new FairTrackParP(svtx, smom,
        fVtxSigma, fMomSigma,
        charge, svtx,
        TVector3(1.,0.,0.), TVector3(0.,1.,0.));

    if(fVerbose>3) Info("Exec","Store candidate at %i",trackID);
    // Creates a new track in the TClonesArray.
    if(fVerbose>3) Info("AddTrack","Adding a Track.");
    TClonesArray &pndtracks = *fTracks;
    TClonesArray &pndtrackcands = *fTrackCands;
    //  TClonesArray &pndtrackids = *fTrackIds;
    Int_t size = pndtrackcands.GetEntriesFast();
    if(pndtracks.GetEntriesFast() != size) {
      Error("Exec","Arrays out of synchronisation: %i tracks, %i cands. Abort event."
          ,pndtracks.GetEntriesFast(),pndtrackcands.GetEntriesFast());
      return;
    }

    new(pndtrackcands[size]) PndTrackCand(*tcand);
    new(pndtracks[size]) PndTrack(*firstPar, *lastPar, *tcand,0,0,1,mc->GetPdgCode(),trackID,FairRootManager::Instance()->GetBranchId("MCTrack"));
    //delete(tcand);
    delete(firstPar);
    delete(lastPar);
  }

  if(fVerbose>3) Info("Exec","End eventloop.");
}

void PndFtsTrackerIdeal::Finish ( )

virtual

Definition at line 433 of file PndFtsTrackerIdeal.cxx.

References fTracks.

{
  std::cout << " Found  "<< fTracks->GetEntriesFast() << " tracks\n";
}

InitStatus PndFtsTrackerIdeal::Init ( )

virtual

Definition at line 76 of file PndFtsTrackerIdeal.cxx.

References fBranchIDs, fFtsParameters, fHits, PndFtsMapCreator::FillTubeArray(), fMCPoints, fMCTracks, fTubeArrayFts, fVerbose, pdg, and Register().

                                    {
  // ---
  if(fVerbose>3) Info("Init","Start initialisation.");

  FairRootManager *fManager = FairRootManager::Instance();

  // Get MC arrays
  fMCTracks = dynamic_cast<TClonesArray *>(fManager->GetObject("MCTrack"));
  if ( ! fMCTracks ) {
    std::cout << "-W-  PndFtsTrackerIdeal::Init: No MCTrack array! Needed for MC Truth" << std::endl;
    return kERROR;
  }

  //FTS
  fMCPoints[0] = dynamic_cast<TClonesArray *> (fManager->GetObject("FTSPoint"));
  if ( ! fMCPoints[0] ) {
    std::cout << "-W-  PndFtsTrackerIdeal::Init: No FTSPoint array!" << std::endl;
    return kERROR;
  }
  fHits[0] = dynamic_cast<TClonesArray *> (fManager->GetObject("FTSHit"));
  if ( ! fHits[0] ) {
    std::cout << "-W-  PndFtsTrackerIdeal::Init: No FTSHit array!" << std::endl;
    return kERROR;
  }
  fBranchIDs[0] =   FairRootManager::Instance()->GetBranchId("FTSHit");


  //GEM
  fMCPoints[1] = dynamic_cast<TClonesArray *> (fManager->GetObject("GEMPoint"));
  if ( ! fMCPoints[1] ) {
    std::cout << "-W-  PndFtsTrackerIdeal::Init: No GEMPoint array!" << std::endl;
    fMCPoints[1]=new TClonesArray("FairMCPoint");
  }
  fHits[1] = dynamic_cast<TClonesArray *> (fManager->GetObject("GEMHit"));
  if ( ! fHits[1] ) {
    std::cout << "-W-  PndFtsTrackerIdeal::Init: No GEMHit array!" << std::endl;
    fHits[1]=new TClonesArray("FairHit");
  }
  fBranchIDs[1] =   FairRootManager::Instance()->GetBranchId("GEMHit");

  //MVD Pixel
  fMCPoints[2] = dynamic_cast<TClonesArray *> (fManager->GetObject("MVDPoint"));
  if ( ! fMCPoints[2] ) {
    std::cout << "-W-  PndFtsTrackerIdeal::Init: No MVDPoint array!" << std::endl;
    fMCPoints[1]=new TClonesArray("FairMCPoint");
  }
  fHits[2] = dynamic_cast<TClonesArray *> (fManager->GetObject("MVDHitsPixel"));
  if ( ! fHits[2] ) {
    std::cout << "-W-  PndFtsTrackerIdeal::Init: No MVDHitsPixel array!" << std::endl;
    fHits[2]=new TClonesArray("FairHit");
  }
  fBranchIDs[2] =   FairRootManager::Instance()->GetBranchId("MVDHitsPixel");

  fMCPoints[3] = fMCPoints[2];
  fHits[3] = dynamic_cast<TClonesArray *> (fManager->GetObject("MVDHitsStrip"));
  if ( ! fHits[3] ) {
    std::cout << "-W-  PndFtsTrackerIdeal::Init: No MVDHitsStrip array!" << std::endl;
    fMCPoints[3]=new TClonesArray("FairHit");
  }
  fBranchIDs[3] =   FairRootManager::Instance()->GetBranchId("MVDHitsStrip");

  if(fVerbose>3) Info("Init","Fetched all arrays.");

  Register();

  pdg = new TDatabasePDG();
  if(fVerbose>3) Info("Init","End initialisation.");


  PndFtsMapCreator *mapperFts = new PndFtsMapCreator(fFtsParameters);
  fTubeArrayFts = mapperFts->FillTubeArray();

  return kSUCCESS;
}

PndFtsTrackerIdeal& PndFtsTrackerIdeal::operator= ( const PndFtsTrackerIdeal &  )

inlineprotected

Definition at line 99 of file PndFtsTrackerIdeal.h.

{return *this;}

void PndFtsTrackerIdeal::Register

(

)

Definition at line 61 of file PndFtsTrackerIdeal.cxx.

References fPersistence, fTrackCands, fTracks, fTracksArrayName, and fVerbose.

Referenced by Init().

{
  //---
  FairRootManager::Instance()->Register(fTracksArrayName,"FTSTrk", fTracks, fPersistence);
  FairRootManager::Instance()->Register(fTracksArrayName+"Cand","FTSTrk", fTrackCands, fPersistence);
  if(fVerbose>3) Info("Register","Done.");
}

void PndFtsTrackerIdeal::Reset

(

)

Definition at line 439 of file PndFtsTrackerIdeal.cxx.

References fTrackCands, and fTracks.

Referenced by Exec().

                               {
  //---
  if (fTracks->GetEntriesFast() != 0)  fTracks->Delete();
  if (fTrackCands->GetEntriesFast() != 0)  fTrackCands->Delete();
}

void PndFtsTrackerIdeal::SetFtsActivity ( Bool_t  act = kTRUE )

inline

Definition at line 60 of file PndFtsTrackerIdeal.h.

References fBranchActive.

{fBranchActive[0]=act;}

void PndFtsTrackerIdeal::SetGemActivity ( Bool_t  act = kTRUE )

inline

Definition at line 61 of file PndFtsTrackerIdeal.h.

References fBranchActive.

{fBranchActive[1]=act;}

Int_t PndFtsTrackerIdeal::SetMinFtsHitsPerTrack

(

Int_t

minFtsHitsPerTrack = 5

)

Definition at line 447 of file PndFtsTrackerIdeal.cxx.

References fMinFtsHitsPerTrack.

{
  // check that the argument is >= 1
  if (minFtsHitsPerTrack<1)
  {
    minFtsHitsPerTrack=1;
  }
  fMinFtsHitsPerTrack=minFtsHitsPerTrack;
  return fMinFtsHitsPerTrack;
}

void PndFtsTrackerIdeal::SetMomentumSmearing ( Double_t  sigmax = -1., Double_t  sigmay = -1., Double_t  sigmaz = -1.  )

inline

Definition at line 52 of file PndFtsTrackerIdeal.h.

References fabs(), fMomSigma, and fRelative.

{ fMomSigma.SetXYZ(fabs(sigmax),fabs(sigmay),fabs(sigmaz)); fRelative=kFALSE; }; // in GeV

void PndFtsTrackerIdeal::SetMvdActivity ( Bool_t  act = kTRUE )

inline

Definition at line 62 of file PndFtsTrackerIdeal.h.

References fBranchActive.

{fBranchActive[2]=act;fBranchActive[3]=act;}

void PndFtsTrackerIdeal::SetParContainers

(

)

Definition at line 70 of file PndFtsTrackerIdeal.cxx.

References fFtsParameters, and rtdb.

                                          {
  FairRuntimeDb* rtdb = FairRunAna::Instance()->GetRuntimeDb();
  fFtsParameters = (PndGeoFtsPar*) rtdb->getContainer("PndGeoFtsPar");
}

void PndFtsTrackerIdeal::SetPersistence ( Bool_t  persistence )

inline

Definition at line 64 of file PndFtsTrackerIdeal.h.

References fPersistence.

Referenced by prod_rec(), reco(), reco_complete(), reco_complete_gf2(), reco_complete_runs(), and recoideal_complete().

{ fPersistence = persistence; }

void PndFtsTrackerIdeal::SetRelativeMomentumSmearing ( Double_t  dpop = -1. )

inline

Definition at line 53 of file PndFtsTrackerIdeal.h.

References fabs(), fDPoP, and fRelative.

Referenced by prod_rec(), reco(), reco_complete(), reco_complete_gf2(), reco_complete_runs(), recoideal_complete(), and run_tracking_sttcombi_timebased().

{ fDPoP=fabs(dpop); fRelative=kTRUE;}; // in GeV

void PndFtsTrackerIdeal::SetTrackingEfficiency ( Double_t  eff = 1. )

inline

Definition at line 55 of file PndFtsTrackerIdeal.h.

References fEfficiency.

Referenced by prod_rec(), reco(), reco_complete(), reco_complete_gf2(), reco_complete_runs(), recoideal_complete(), and run_tracking_sttcombi_timebased().

{ fEfficiency=eff; };

void PndFtsTrackerIdeal::SetTrackOutput ( TString  name = "FTSTrkIdeal" )

inline

Definition at line 50 of file PndFtsTrackerIdeal.h.

References fTracksArrayName, and name.

Referenced by PndFtsTrackerIdeal(), prod_rec(), reco(), reco_complete(), reco_complete_gf2(), reco_complete_runs(), recoideal_complete(), and run_tracking_sttcombi_timebased().

{ fTracksArrayName = name; };

void PndFtsTrackerIdeal::SetVertexSmearing ( Double_t  sigmax = -1., Double_t  sigmay = -1., Double_t  sigmaz = -1.  )

inline

Definition at line 54 of file PndFtsTrackerIdeal.h.

References fabs(), and fVtxSigma.

Referenced by prod_rec(), reco(), reco_complete(), reco_complete_gf2(), reco_complete_runs(), recoideal_complete(), and run_tracking_sttcombi_timebased().

{ fVtxSigma.SetXYZ(fabs(sigmax),fabs(sigmay),fabs(sigmaz)); }; // in cm

void PndFtsTrackerIdeal::SmearFWD ( TVector3 &  vec, const TVector3 &  sigma  )

protected

Definition at line 461 of file PndFtsTrackerIdeal.cxx.

References Double_t.

Referenced by Exec().

{
  // gaussian smearing
  Double_t rannn=0.;
  rannn = gRandom->Gaus(vec.X(),sigma.X());
  vec.SetX(rannn);

  rannn = gRandom->Gaus(vec.Y(),sigma.Y());
  vec.SetY(rannn);

  rannn = gRandom->Gaus(vec.Z(),sigma.Z());
  vec.SetZ(rannn);

  return;
}

Member Data Documentation

Bool_t PndFtsTrackerIdeal::fBranchActive[4]

protected

Array of Branch IDs.

Definition at line 74 of file PndFtsTrackerIdeal.h.

Referenced by Exec(), PndFtsTrackerIdeal(), SetFtsActivity(), SetGemActivity(), and SetMvdActivity().

Int_t PndFtsTrackerIdeal::fBranchIDs[4]

protected

Array of event's hits.

Definition at line 73 of file PndFtsTrackerIdeal.h.

Referenced by Exec(), and Init().

Double_t PndFtsTrackerIdeal::fDPoP

protected

Definition at line 86 of file PndFtsTrackerIdeal.h.

Referenced by Exec(), and SetRelativeMomentumSmearing().

Double_t PndFtsTrackerIdeal::fEfficiency

protected

Definition at line 89 of file PndFtsTrackerIdeal.h.

Referenced by Exec(), and SetTrackingEfficiency().

PndGeoFtsPar* PndFtsTrackerIdeal::fFtsParameters

protected

Particle DB.

Definition at line 95 of file PndFtsTrackerIdeal.h.

Referenced by Init(), and SetParContainers().

TClonesArray* PndFtsTrackerIdeal::fHits[4]

protected

Array of event's points.

Definition at line 72 of file PndFtsTrackerIdeal.h.

Referenced by Exec(), and Init().

TClonesArray* PndFtsTrackerIdeal::fMCPoints[4]

protected

Array of PndMCTrack.

Definition at line 71 of file PndFtsTrackerIdeal.h.

Referenced by Exec(), and Init().

TClonesArray* PndFtsTrackerIdeal::fMCTracks

protected

Definition at line 70 of file PndFtsTrackerIdeal.h.

Referenced by Exec(), and Init().

Int_t PndFtsTrackerIdeal::fMinFtsHitsPerTrack

protected

Array of track IDs (Links)

Definition at line 82 of file PndFtsTrackerIdeal.h.

Referenced by Exec(), and SetMinFtsHitsPerTrack().

TVector3 PndFtsTrackerIdeal::fMomSigma

protected

Definition at line 85 of file PndFtsTrackerIdeal.h.

Referenced by Exec(), PndFtsTrackerIdeal(), and SetMomentumSmearing().

Bool_t PndFtsTrackerIdeal::fPersistence

protected

Definition at line 90 of file PndFtsTrackerIdeal.h.

Referenced by Register(), and SetPersistence().

Bool_t PndFtsTrackerIdeal::fRelative

protected

Definition at line 87 of file PndFtsTrackerIdeal.h.

Referenced by Exec(), SetMomentumSmearing(), and SetRelativeMomentumSmearing().

std::map<int,bool> PndFtsTrackerIdeal::fStationsDisabled

protected

Array of Branch Activeness.

Definition at line 75 of file PndFtsTrackerIdeal.h.

Referenced by DeactivateFtsStation(), and Exec().

TClonesArray* PndFtsTrackerIdeal::fTrackCands

protected

Array of disabled stations.

Definition at line 77 of file PndFtsTrackerIdeal.h.

Referenced by Exec(), PndFtsTrackerIdeal(), Register(), and Reset().

TClonesArray* PndFtsTrackerIdeal::fTrackIds

protected

Array of found tracks.

Definition at line 79 of file PndFtsTrackerIdeal.h.

TClonesArray* PndFtsTrackerIdeal::fTracks

protected

Array of found track candidates.

Definition at line 78 of file PndFtsTrackerIdeal.h.

Referenced by Exec(), Finish(), PndFtsTrackerIdeal(), Register(), and Reset().

TString PndFtsTrackerIdeal::fTracksArrayName

protected

Definition at line 92 of file PndFtsTrackerIdeal.h.

Referenced by Register(), and SetTrackOutput().

TClonesArray* PndFtsTrackerIdeal::fTubeArrayFts

protected

Definition at line 96 of file PndFtsTrackerIdeal.h.

Referenced by Exec(), and Init().

TVector3 PndFtsTrackerIdeal::fVtxSigma

protected

Definition at line 88 of file PndFtsTrackerIdeal.h.

Referenced by Exec(), PndFtsTrackerIdeal(), and SetVertexSmearing().

TDatabasePDG* PndFtsTrackerIdeal::pdg

protected

Definition at line 93 of file PndFtsTrackerIdeal.h.

Referenced by Exec(), and Init().

---

The documentation for this class was generated from the following files:

• PndFtsTrackerIdeal.h
• PndFtsTrackerIdeal.cxx