PndGapEventBuilderTask.cxx

Go to the documentation of this file.

#include "PndGapEventBuilderTask.h"

#include <iostream>

// Root includes
#include "TROOT.h"
#include "TString.h"
#include "TClonesArray.h"
#include "TParticlePDG.h"

// framework includes
#include "FairRootManager.h"
#include "FairRun.h"
#include "FairRuntimeDb.h"
#include "FairRunAna.h"
#include "FairTimeStamp.h"

PndGapEventBuilderTask::PndGapEventBuilderTask() :
        FairTask("Pnd Gap Event Builder"), fTimeGap(10), fMainBranchName(), fPersistence(kTRUE), fEntryNr(0)
{
}

PndGapEventBuilderTask::~PndGapEventBuilderTask()
{
}

void PndGapEventBuilderTask::SetParContainers()
{
  //FairRuntimeDb* rtdb = FairRunAna::Instance()->GetRuntimeDb(); //[R.K. 01/2017] unused variable?
//  fSttParameters = (PndGeoSttPar*) rtdb->getContainer("PndGeoSttPar");
}

InitStatus PndGapEventBuilderTask::ReInit()
{
  InitStatus stat=kSUCCESS;
  return stat;
}

// -----   Public method Init   --------------------------------------------
InitStatus PndGapEventBuilderTask::Init()
{
  FairRootManager* ioman = FairRootManager::Instance();

  if ( ! ioman )
    {
      std::cout << "-E- PndGapEventBuilderTask::Init: "
     << "RootManager not instantiated!" << std::endl;
      return kFATAL;
    }

  TString outputName = fMainBranchName;
  outputName.Append("_event");
  fMainHitArray = (TClonesArray*) FairRootManager::Instance()->GetObject(fMainBranchName);
  std::cout << "ClassName of HitArray: " << fMainHitArray->ClassName() << std::endl;
  fMainEventHitArray = ioman->Register(outputName.Data(), fMainHitArray->GetClass()->GetName(), "EventData", fPersistence);

  for (size_t i = 0; i < fAddBranches.size(); i++){
          outputName = fAddBranches[i].first;
          fAddHitArray.push_back((TClonesArray*)ioman->GetObject(outputName.Data()));
          outputName.Append("_event");
          fAddEventHitArray.push_back(ioman->Register(outputName.Data(), fAddHitArray[i]->GetClass()->GetName(), "EventData", fPersistence));
  }

  fStartFunctor = new StopTime();
  fStopFunctor= new StopTime();
  fTimeGapFunctor = new TimeGap();

  std::cout << "-I- PndGapEventBuilderTask: Initialisation successfull" << std::endl;
  fInitDone = kTRUE;
  return kSUCCESS;
}


// -----   Public method Exec   --------------------------------------------
void PndGapEventBuilderTask::Exec(Option_t*)
{
        fMainHitArray->Delete();
        fMainEventHitArray->Delete();
        for (size_t i = 0; i < fAddHitArray.size(); i++){
                fAddEventHitArray[i]->Delete();
        }



        fMainHitArray = FairRootManager::Instance()->GetData(fMainBranchName, fTimeGapFunctor, fTimeGap);

        if (++fEntryNr % 1000 == 0 && fVerbose > 0) {
                std::cout << "-I- PndGapEventBuilderTask:Exec " << fEntryNr << std::endl;
        }


        fMainEventHitArray->AbsorbObjects(fMainHitArray);



        if (fMainEventHitArray->GetEntriesFast() > 0 && fAddHitArray.size() > 0){

                FairTimeStamp* data = (FairTimeStamp*)fMainEventHitArray->At(0);
                Double_t startTime = data->GetTimeStamp() - 10;
                if (startTime < 0) startTime = 0;

                data = (FairTimeStamp*)fMainEventHitArray->At(fMainEventHitArray->GetEntriesFast() - 1);
                Double_t stopTime  = data->GetTimeStamp();

                for (size_t i = 0; i < fAddHitArray.size(); i++){
                        TClonesArray* tempArray = FairRootManager::Instance()->GetData(fAddBranches[i].first, fStartFunctor, startTime, fStopFunctor, stopTime + fAddBranches[i].second);
                        fAddEventHitArray[i]->AbsorbObjects(tempArray);
                }
        }

}

void PndGapEventBuilderTask::FinishEvent()
{
//      fMainEventHitArray->Delete();
}


ClassImp(PndGapEventBuilderTask);