#include <PndPatternMatcher.h>

Inheritance diagram for PndPatternMatcher:

Public Member Functions
	PndPatternMatcher ()

virtual	~PndPatternMatcher ()

void	SetOutputBranchname (TString name)

void	SetPersistence (Bool_t val)

void	SetMatchRatio (float ratio)

Protected Member Functions
virtual void	SetParContainers ()

virtual InitStatus	Init ()

virtual void	Exec (Option_t *opt)

virtual void	FinishTask ()

Private Member Functions
void	LoadPatternDB (TString filename)

void	FindMatch ()

void	CreateTrackCandFromMatch (std::set< int > partialMatch)

Private Attributes
PndGeoSttPar *	fSttParameters

TClonesArray *	fEventHeader

TClonesArray *	fSTTHitArray

TFile *	dbFile

TTree *	patternTree

std::vector< std::set< int > >	dbTubeIDs

std::vector< PndTrackCand >	fPartialCand

TClonesArray *	fPartialMatchCand

TString	fTrackCandName

Bool_t	fPersistence

bool	verboseMatches

float	fMatchRatio

Detailed Description

Definition at line 18 of file PndPatternMatcher.h.

Constructor & Destructor Documentation

PndPatternMatcher::PndPatternMatcher ( )

PndPatternMatcher::~PndPatternMatcher ( )

virtual

Definition at line 37 of file PndPatternMatcher.cxx.

37 {

38 }

Member Function Documentation

void PndPatternMatcher::CreateTrackCandFromMatch ( std::set< int > partialMatch )

private

Definition at line 125 of file PndPatternMatcher.cxx.

References PndTrackCand::AddHit(), fPartialCand, fSTTHitArray, and PndSttHit::GetTubeID().

Referenced by FindMatch().

                                                                          {
 //  Create a PndTrackCand from the partial match found in FindMatch()
   PndTrackCand trackCand;
   int nSttHits = fSTTHitArray->GetEntriesFast();
 //  Loop over all STT hits
   for (int iHit = 0; iHit < nSttHits; ++iHit) {
     PndSttHit *sttHit = (PndSttHit*) fSTTHitArray->At(iHit);
     int tubeID = sttHit->GetTubeID();
 //    verify if this hit is part of the partial match
     auto search = partialMatch.find(tubeID);
 //    if hit is found in partial match, add it to track cand
     if (search != partialMatch.end()) {
       trackCand.AddHit(sttHit->GetEntryNr(),iHit);
     }
   }
 //  Add new trackCand to vector of all trackCands for this event
   fPartialCand.push_back(trackCand);
 }

void PndPatternMatcher::Exec ( Option_t * opt )

protectedvirtual

Definition at line 67 of file PndPatternMatcher.cxx.

References FindMatch(), fPartialCand, and fPartialMatchCand.

                                        {
   fPartialCand.clear();
   fPartialMatchCand->Delete();
   FindMatch();
 
 //  Write trackCands into the data stream
   for (auto const& trackCand : fPartialCand) {
     new ((*fPartialMatchCand)[fPartialMatchCand->GetEntriesFast()]) PndTrackCand(trackCand);
   }
 }

void PndPatternMatcher::FindMatch ( )

private

Definition at line 81 of file PndPatternMatcher.cxx.

References CreateTrackCandFromMatch(), dbTubeIDs, fMatchRatio, fSTTHitArray, PndSttHit::GetTubeID(), and verboseMatches.

Referenced by Exec().

                                   {
 //  Get a list of all tubeIDs in the event
   int nSttHits = fSTTHitArray->GetEntriesFast();
   std::set<int> tubeIDs;
   for (int iHit = 0; iHit < nSttHits; ++iHit) {
     PndSttHit *sttHit = (PndSttHit*) fSTTHitArray->At(iHit);
     int tubeID = sttHit->GetTubeID();
     tubeIDs.insert(tubeID);
   }
 
 //  std::cout << dbTubeIDs.at(1).size() << std::endl;
 
 
   int matches = 0;
 //  Compare each pattern in the data base with the current set of tubeIDs
   for (auto const& dbPattern : dbTubeIDs) {
     std::set<int> intersection;
     intersection.clear();
 //    Determine the intersection between the current database pattern and the event's set of tubeIDs
     std::set_intersection(tubeIDs.begin(), tubeIDs.end(), dbPattern.begin(), dbPattern.end(), std::inserter(intersection,intersection.begin()));
 //    Determine the ratio to which there is an overlap with the database pattern
     float matchRatio = (float)intersection.size() / (float)dbPattern.size();
 //    If the matching ratio is large enough, proceed to create trackCand from intersection
     if (matchRatio > fMatchRatio) {
 //      std::cout<< "match ratio: " << matchRatio << std::endl;
       matches++;
 
 //      Detailed output in case it is needed (set verboseMatches to true)
       if (verboseMatches) {
         if (intersection.size() > 0) {
           std::cout << "matching tubes: ";
           for (auto const& tube : intersection) {
             std::cout << tube << " ";
           }
           std::cout << std::endl;
         }
       }
 
       CreateTrackCandFromMatch(intersection);
 
     }
   }
   if (verboseMatches) std::cout << "partial matches found: " << matches << std::endl;
 }

void PndPatternMatcher::FinishTask ( )

protectedvirtual

Definition at line 77 of file PndPatternMatcher.cxx.

                                    {
 
 }

InitStatus PndPatternMatcher::Init ( )

protectedvirtual

Definition at line 44 of file PndPatternMatcher.cxx.

References fEventHeader, fPartialMatchCand, fPersistence, fSTTHitArray, fTrackCandName, and LoadPatternDB().

                                    {
   LoadPatternDB("patternDB.root");
 
 // Get the running instance of the FairRootManager to access tree branches
   FairRootManager *ioman = FairRootManager::Instance();
   if(!ioman) {
     std::cout << "-E- PatternDBGenerator::Init: FairRootManager not instantiated!" << std::endl;
     return kFATAL;
   }
 
   fEventHeader = (TClonesArray*) ioman->GetObject("EventHeader.");
   if (!fEventHeader) {
     std::cout << "-E- PatternDBGenerator:Init: EventHeader not instantiated!" << std::endl;
   }
 
 // Access the STTHit branch
   fSTTHitArray = (TClonesArray*) ioman->GetObject("STTHit");
 
 //  Set the output branch
   fPartialMatchCand = ioman->Register(fTrackCandName,"PndTrackCand","STT",fPersistence);
 
   return kSUCCESS;
 }

void PndPatternMatcher::LoadPatternDB ( TString filename )

private

Definition at line 143 of file PndPatternMatcher.cxx.

References dbFile, dbTubeIDs, PndPattern::GetTubeIDs(), and patternTree.

Referenced by Init().

                                                       {
   dbFile = new TFile(filename,"READ");
   patternTree = (TTree*) dbFile->Get("trackPatterns");
 
   dbTubeIDs.clear();
 
   PndPattern *pattern;
   patternTree->SetBranchAddress("pattern", &pattern);
 
   Long64_t nPatterns = patternTree->GetEntriesFast();
   for (Long64_t iEntry = 0; iEntry < nPatterns; ++iEntry) {
     patternTree->GetEntry(iEntry);
     std::set<int> tubeIDs = pattern->GetTubeIDs();
     dbTubeIDs.push_back(tubeIDs);
   }
   std::cout << "# DB patterns: " << dbTubeIDs.size() << std::endl;
 
 }

void PndPatternMatcher::SetMatchRatio ( float ratio )

inline

Definition at line 25 of file PndPatternMatcher.h.

References fMatchRatio.

25 {fMatchRatio = ratio;}

PndPatternMatcher::fMatchRatio

float fMatchRatio

Definition: PndPatternMatcher.h:55

void PndPatternMatcher::SetOutputBranchname ( TString name )

inline

Definition at line 23 of file PndPatternMatcher.h.

References fTrackCandName, and name.

23 {fTrackCandName = name;}

name

TString name

Definition: createRootGeoFile.C:82

PndPatternMatcher::fTrackCandName

TString fTrackCandName

Definition: PndPatternMatcher.h:50

void PndPatternMatcher::SetParContainers ( )

protectedvirtual

Definition at line 40 of file PndPatternMatcher.cxx.

References fSttParameters, and rtdb.

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