CbmLitFitTracksParallel.cxx

Go to the documentation of this file.

 
#include "CbmLitFitTracksParallel.h"
#include "CbmStsTrack.h"
#include "CbmTrack.h"
#include "FairRootManager.h"
#include "FairTrackParam.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 "TClonesArray.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);