CbmLitFitTracksParallel.cxx

Go to the documentation of this file.

/* Copyright (C) 2013-2014 GSI/JINR-LIT, Darmstadt/Dubna
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Andrey Lebedev [committer] */
 
#include "CbmLitFitTracksParallel.h"
 
#include "CbmStsTrack.h"
#include "CbmTrack.h"
#include "FairRootManager.h"
#include "FairTrackParam.h"
#include "TClonesArray.h"
#include "cbm/base/CbmLitTrackingGeometryConstructor.h"
#include "cbm/utils/CbmLitConverterParallel.h"
#include "parallel/LitDetectorLayout.h"
#include "parallel/LitScalPixelHit.h"
#include "parallel/LitScalTrack.h"
#include "parallel/LitTrackFitter.h"
#include "std/utils/CbmLitMemoryManagment.h"
 
#include <algorithm>
#include <cassert>
#include <iostream>
#include <vector>
 
using std::cout;
using std::endl;
using std::for_each;
using std::vector;
 
CbmLitFitTracksParallel::CbmLitFitTracksParallel()
  : FairTask()
  , fGlobalTracks(NULL)
  , fStsTracks(NULL)
  , fMuchTracks(NULL)
  , fTrdTracks(NULL)
  , fMuchPixelHits(NULL)
  , fMuchStrawHits(NULL)
  , fTrdHits(NULL)
{
}
 
CbmLitFitTracksParallel::~CbmLitFitTracksParallel() {}
 
InitStatus CbmLitFitTracksParallel::Init()
{
  ReadDataBranches();
 
  fFitWatch.Reset();
  fFitWithIOWatch.Reset();
 
  return kSUCCESS;
}
 
void CbmLitFitTracksParallel::Exec(Option_t* opt)
{
  static Int_t eventNo = 0;
  std::cout << "CbmLitFitTracksParallel::Exec: eventNo=" << eventNo++ << std::endl;
 
  DoFit();
}
 
void CbmLitFitTracksParallel::Finish() { PrintStopwatchStatistics(); }
 
void CbmLitFitTracksParallel::ReadDataBranches()
{
  FairRootManager* ioman = FairRootManager::Instance();
  assert(ioman != NULL);
 
  fGlobalTracks  = (TClonesArray*) ioman->GetObject("GlobalTrack");
  fStsTracks     = (TClonesArray*) ioman->GetObject("StsTrack");
  fMuchTracks    = (TClonesArray*) ioman->GetObject("MuchTrack");
  fTrdTracks     = (TClonesArray*) ioman->GetObject("TrdTrack");
  fMuchPixelHits = (TClonesArray*) ioman->GetObject("MuchPixelHit");
  fMuchStrawHits = (TClonesArray*) ioman->GetObject("MuchStrawHit");
  fTrdHits       = (TClonesArray*) ioman->GetObject("TrdHit");
}
 
void CbmLitFitTracksParallel::DoFit()
{
  static Bool_t isTrd  = fTrdTracks != NULL;
  static Bool_t isMuch = fMuchTracks != NULL;
 
  static Bool_t firstTime = true;
  static lit::parallel::LitDetectorLayoutScal layout;
  if (firstTime) {
    if (isTrd) {
      CbmLitTrackingGeometryConstructor::Instance()->GetTrdLayoutScal(layout);
    }
    else if (isMuch) {
      CbmLitTrackingGeometryConstructor::Instance()->GetMuchLayoutScal(layout);
    }
    firstTime = false;
  }
 
  fFitWithIOWatch.Start(kFALSE);
 
  // Convert input data
  vector<lit::parallel::LitScalTrack*> ltracks;
  vector<lit::parallel::LitScalPixelHit*> lhits;
  if (isTrd) {
    CbmLitConverterParallel::CbmPixelHitArrayToLitScalPixelHitArray(fTrdHits, lhits);
    CbmLitConverterParallel::CbmTrackArrayToLitScalTrackArray(fTrdTracks, lhits, ltracks);
  }
  else if (isMuch) {
    CbmLitConverterParallel::CbmPixelHitArrayToLitScalPixelHitArray(fMuchPixelHits, lhits);
    CbmLitConverterParallel::CbmTrackArrayToLitScalTrackArray(fMuchTracks, lhits, ltracks);
  }
 
  // Replace first track parameter of the converted tracks with the last STS track parameter
  Int_t nofTracks = ltracks.size();
  for (Int_t iTrack = 0; iTrack < nofTracks; iTrack++) {
    lit::parallel::LitScalTrack& track = *ltracks[iTrack];
    Int_t stsTrackId                   = track.GetPreviousTrackId();
    CbmStsTrack* stsTrack              = static_cast<CbmStsTrack*>(fStsTracks->At(stsTrackId));
    lit::parallel::LitTrackParamScal lpar;
    CbmLitConverterParallel::FairTrackParamToLitTrackParamScal(stsTrack->GetParamLast(), &lpar);
    track.SetParamFirst(lpar);
  }
 
  fFitWatch.Start(kFALSE);
  // Int_t nofTracks = ltracks.size();
  for (Int_t iTrack = 0; iTrack < nofTracks; iTrack++) {
    lit::parallel::LitScalTrack& track = *ltracks[iTrack];
    LitTrackFitter(track, layout);
  }
  fFitWatch.Stop();
 
  // Replace first and last track parameters for the fitted track
  for (Int_t iTrack = 0; iTrack < nofTracks; iTrack++) {
    lit::parallel::LitScalTrack& track = *ltracks[iTrack];
    CbmTrack* cbmTrack =
      (isTrd) ? static_cast<CbmTrack*>(fTrdTracks->At(iTrack)) : static_cast<CbmTrack*>(fMuchTracks->At(iTrack));
    FairTrackParam firstParam, lastParam;
    CbmLitConverterParallel::LitTrackParamScalToFairTrackParam(&track.GetParamFirst(), &firstParam);
    CbmLitConverterParallel::LitTrackParamScalToFairTrackParam(&track.GetParamLast(), &lastParam);
    cbmTrack->SetParamFirst(&firstParam);
    cbmTrack->SetParamLast(&lastParam);
  }
 
  // Clear memory
  for_each(ltracks.begin(), ltracks.end(), DeleteObject());
  for_each(lhits.begin(), lhits.end(), DeleteObject());
  ltracks.clear();
  lhits.clear();
 
  fFitWithIOWatch.Stop();
}
 
void CbmLitFitTracksParallel::PrintStopwatchStatistics()
{
  cout << "CbmLitFitTracksParallel::PrintStopwatchStatistics: " << endl;
  cout << "fit without IO: counts=" << fFitWatch.Counter() << ", real=" << fFitWatch.RealTime() / fFitWatch.Counter()
       << "/" << fFitWatch.RealTime() << " s, cpu=" << fFitWatch.CpuTime() / fFitWatch.Counter() << "/"
       << fFitWatch.CpuTime() << endl;
  cout << "fit with IO: counts=" << fFitWithIOWatch.Counter()
       << ", real=" << fFitWithIOWatch.RealTime() / fFitWithIOWatch.Counter() << "/" << fFitWithIOWatch.RealTime()
       << " s, cpu=" << fFitWithIOWatch.CpuTime() / fFitWithIOWatch.Counter() << "/" << fFitWithIOWatch.CpuTime()
       << endl;
}
ClassImp(CbmLitFitTracksParallel);