CbmStsFindTracks.cxx

Go to the documentation of this file.

// -------------------------------------------------------------------------
// -----                   CbmStsFindTracks source file                -----
// -----                  Created 02/02/05  by V. Friese               -----
// -------------------------------------------------------------------------
// Includes from STS
#include "CbmStsFindTracks.h"
 
#include "CbmL1StsTrackFinder.h"
#include "CbmStsHit.h"
#include "CbmStsTrack.h"
#include "CbmStsTrackFinderIdeal.h"
 
// Includes from base
#include "FairField.h"
#include "FairRootManager.h"
#include "FairRunAna.h"
#include "FairRuntimeDb.h"
 
// Includes from ROOT
#include "TClonesArray.h"
 
// Includes from C++
#include <iomanip>
#include <iostream>
 
using namespace std;
 
// -----   Default constructor   -------------------------------------------
CbmStsFindTracks::CbmStsFindTracks()
    : BmnTask("STSFindTracks", 1)
    , fUseMvd(kFALSE)
    , fGeoPar(nullptr)
    , fDigiPar(nullptr)
    ,
    // AZ fDigiScheme(new CbmStsDigiScheme()),
    fDigiScheme(CbmStsDigiScheme::Instance())
    , fField(nullptr)
    , fFinder(nullptr)
    , fMvdHits(nullptr)
    , fStsHits(nullptr)
    , fTracks(nullptr)
    , fTimer()
    , fNEvents(0)
    , fNEventsFailed(0)
    , fTime(0.)
    , fNTracks(0.)
    , finderName("CbmStsTrackFinderIdeal")
{}
 
// -----   Standard constructor   ------------------------------------------
CbmStsFindTracks::CbmStsFindTracks(Int_t iVerbose, const TString& sFinderName, Bool_t useMvd, const char* name)
    : BmnTask(name, iVerbose)
    , fUseMvd(useMvd)
    , fGeoPar(nullptr)
    , fDigiPar(nullptr)
    ,
    // AZ fDigiScheme(new CbmStsDigiScheme()),
    fDigiScheme(CbmStsDigiScheme::Instance())
    , fField(nullptr)
    , fFinder(nullptr)
    , fMvdHits(nullptr)
    , fStsHits(nullptr)
    , fTracks(nullptr)
    , fTimer()
    , fNEvents(0)
    , fNEventsFailed(0)
    , fTime(0.)
    , fNTracks(0.)
    , finderName(sFinderName)
{}
 
// -----   Destructor   ----------------------------------------------------
CbmStsFindTracks::~CbmStsFindTracks()
{
    // AZ if ( fDigiScheme ) delete fDigiScheme;
    fTracks->Delete();
    if (fFinder)
        delete fFinder;
}
 
// -----   Virtual public method Exec   ------------------------------------
void CbmStsFindTracks::Exec(Option_t* opt)
{
    if (!IsActive())
        return;
 
    fTimer.Start();
 
    fTracks->Delete();
    Int_t nTracks = fFinder->DoFind();
    for (Int_t iTrack = 0; iTrack < fTracks->GetEntriesFast(); iTrack++) {
        CbmStsTrack* track = (CbmStsTrack*)fTracks->At(iTrack);
        track->SortHits();
    }
 
    fTimer.Stop();
    if (fVerbose)
        cout << "+ " << setw(15) << left << fName << ": " << setprecision(4) << setw(8) << fixed << right
             << fTimer.RealTime() << " s, tracks found " << nTracks << endl;
 
    fNEvents++;
    fTime += fTimer.RealTime();
    fNTracks += Double_t(nTracks);
}
 
// -----   Private virtual method SetParContainers   -----------------------
void CbmStsFindTracks::SetParContainers()
{
 
    // Get run and runtime database
    FairRunAna* run = FairRunAna::Instance();
    if (!run)
        Fatal("SetParContainers", "No analysis run");
 
    FairRuntimeDb* db = run->GetRuntimeDb();
    if (!db)
        Fatal("SetParContainers", "No runtime database");
 
    // Get STS geometry parameter container
    fGeoPar = (CbmGeoStsPar*)db->getContainer("CbmGeoStsPar");
 
    // Get STS digitisation parameter container
    fDigiPar = (CbmStsDigiPar*)db->getContainer("CbmStsDigiPar");
}
 
void CbmStsFindTracks::InitFinder()
{
    if (finderName == "CbmStsTrackFinderIdeal")
        fFinder = new CbmStsTrackFinderIdeal(fVerbose);
    else if (finderName == "CbmL1StsTrackFinder")
        fFinder = new CbmL1StsTrackFinder();
    else
        LOG(error) << "Cannot initialize finder. Invalid finder name: " << finderName;
}
 
void CbmStsFindTracks::BuildDigitisationScheme()
{
    if (fDigiScheme->Init(fGeoPar, fDigiPar)) {
        if (fVerbose == 1 || fVerbose == 2)
            fDigiScheme->Print(kFALSE);
        else if (fVerbose > 2)
            fDigiScheme->Print(kTRUE);
        cout << "-I- "
             << "STS digitisation scheme succesfully initialised" << endl;
        cout << "    Stations: " << fDigiScheme->GetNStations() << ", Sectors: " << fDigiScheme->GetNSectors()
             << ", Channels: " << fDigiScheme->GetNChannels() << endl;
    }
}
 
// -----   Private virtual method Init  ------------------------------------
InitStatus CbmStsFindTracks::Init()
{
    cout << endl;
    cout << "---------------------------------------------" << endl;
    cout << "-I- Initialising " << GetName() << " ...." << endl;
 
    InitFinder();
 
    // Get input hit arrays
    FairRootManager* ioman = FairRootManager::Instance();
    if (!ioman)
        Fatal("Init", "No FairRootManager");
    fStsHits = (TClonesArray*)ioman->GetObject("StsHit");
    if (!fStsHits) {
        cout << "-E- " << GetName() << "::Init: No StsHit array!" << endl;
        return kERROR;
    }
    if (fUseMvd) {
        fMvdHits = (TClonesArray*)ioman->GetObject("MvdHit");
        if (!fMvdHits) {
            cout << "-W- " << GetName() << "::Init: No MVD hits available!" << endl;
            cout << "     Running track finding without MVD hits" << endl;
        }
    }
 
    // Create and register output array STSTrack
    fTracks = new TClonesArray("CbmStsTrack", 100);
    ioman->Register("StsTrack", "STS", fTracks, kTRUE);
 
    BuildDigitisationScheme();
 
    // Check for Track finder
    if (!fFinder) {
        cout << "-E- " << GetName() << "::Init: No track finder selected!" << endl;
        return kERROR;
    }
    cout << "-I- Track finder engine " << fFinder->GetName() << " selected" << endl;
 
    // Set members of track finder and verbosity and initialise track finder
    fFinder->SetDigiScheme(fDigiScheme);
    fFinder->SetField(fField);
    fFinder->SetMvdHitArray(fMvdHits);
    fFinder->SetStsHitArray(fStsHits);
    fFinder->SetTrackArray(fTracks);
    fFinder->SetVerbose(fVerbose);
    fFinder->Init();
 
    // Screen output
    cout << "-I- " << GetName() << " intialised " << endl;
    cout << "---------------------------------------------" << endl;
 
    return kSUCCESS;
}
 
void CbmStsFindTracks::OnlineWrite(const std::unique_ptr<TTree>& resultTree)
{
    if (!IsActive())
        return;
 
    resultTree->Branch("StsTrack", &fTracks);
    resultTree->Fill();
}
 
// -----   Virtual private method Finish   ---------------------------------
void CbmStsFindTracks::Finish()
{
 
    fFinder->Finish();
 
    if (fVerbose > 0) {
        cout << endl;
        cout << "============================================================" << endl;
        cout << "=====   " << GetName() << ": Run summary " << endl;
        cout << "===== " << endl;
        cout << "===== Good events   : " << setw(6) << fNEvents << endl;
        cout << "===== Failed events : " << setw(6) << fNEventsFailed << endl;
        cout << "===== Average time  : " << setprecision(4) << setw(8) << right << fTime / Double_t(fNEvents) << " s"
             << endl;
        cout << "===== " << endl;
        cout << "===== Found tracks per event  : " << fixed << setprecision(0) << fNTracks / Double_t(fNEvents) << endl;
        cout << "============================================================" << endl;
    }
    printf("Work time of CbmStsFindTracks: %4.2f sec.\n", fTime);
}
// -------------------------------------------------------------------------