#include <PndMcCloner.h>

Inheritance diagram for PndMcCloner:

Public Member Functions
	PndMcCloner ()

	~PndMcCloner ()

virtual InitStatus	Init ()

virtual void	Exec (Option_t *)

void	SetCleanMc (Bool_t opt=kTRUE)

void	SetOutputBranch (TString branch)

Protected Member Functions
void	FindUsedMCIndices ()

void	CloneMCTrack ()

void	CloneAndCleanMCTrack ()

void	CorrectMotherIndices ()

void	CorrectPidIndices ()

	ClassDef (PndMcCloner, 2)

Protected Attributes
TClonesArray *	fInputArray

TClonesArray *	fPidChargedArray

TClonesArray *	fPidNeutralArray

TClonesArray *	fOutputArray

map< Int_t, Int_t >	mapMCIndex

Bool_t	fCleanMC

TString	fTrackBranchNamePidHypo

Detailed Description

Definition at line 13 of file PndMcCloner.h.

Constructor & Destructor Documentation

PndMcCloner::PndMcCloner ( )

Default constructor

Definition at line 24 of file PndMcCloner.cxx.

                          : FairTask("Cloner of PndMCTrack"), 
            fInputArray(), fPidChargedArray(), fPidNeutralArray(), fOutputArray(),
            mapMCIndex(), fCleanMC(kFALSE), fTrackBranchNamePidHypo("")
 {
 }

PndMcCloner::~PndMcCloner ( )

Destructor

Definition at line 32 of file PndMcCloner.cxx.

32 { }

Member Function Documentation

PndMcCloner::ClassDef	(	PndMcCloner	,
		2
	)

protected

void PndMcCloner::CloneAndCleanMCTrack ( )

protected

Definition at line 185 of file PndMcCloner.cxx.

References fInputArray, fOutputArray, mapMCIndex, and mctrack.

Referenced by Exec().

 {
   // Copy only the MCTracks which were used, and update the mother indices
 
   for (std::map<Int_t,Int_t>::iterator it=mapMCIndex.begin(); it!=mapMCIndex.end(); ++it)
     {
       PndMCTrack *mctrack  = (PndMCTrack*) fInputArray->At(it->first);
       TClonesArray& clref = *fOutputArray;
       Int_t size = clref.GetEntriesFast();
       new(clref[size]) PndMCTrack(*mctrack);
       mapMCIndex[it->first] = size;
     }
 }

void PndMcCloner::CloneMCTrack ( )

protected

Definition at line 112 of file PndMcCloner.cxx.

References fInputArray, fOutputArray, and mctrack.

Referenced by Exec().

 {
   // Copy 1:1 of the MCTrack TClonesArray
 
   Int_t nMCTracks = fInputArray->GetEntriesFast();
   for (Int_t iMC=0; iMC<nMCTracks; iMC++)
     {
       PndMCTrack *mctrack  = (PndMCTrack*) fInputArray->At(iMC);
       TClonesArray& clref = *fOutputArray;
       Int_t size = clref.GetEntriesFast();
       new(clref[size]) PndMCTrack(*mctrack);
     } // Loop over MCTracks
 }

void PndMcCloner::CorrectMotherIndices ( )

protected

Definition at line 202 of file PndMcCloner.cxx.

References fOutputArray, PndMCTrack::GetMotherID(), PndMCTrack::GetSecondMotherID(), mapMCIndex, mctrack, PndMCTrack::SetMotherID(), and PndMCTrack::SetSecondMotherID().

Referenced by Exec().

 {
   // Loop over the new MCTrack TClonesArray and update the mother indices
   Int_t nmc = 0;
   nmc = fOutputArray->GetEntriesFast();
   for (Int_t imc=0; imc<nmc; imc++)
     {
       PndMCTrack *mctrack = (PndMCTrack*)fOutputArray->At(imc);
       Int_t motherID = mctrack->GetMotherID();
       Int_t secondMotherID = mctrack->GetSecondMotherID();
       if (motherID!=-1) mctrack->SetMotherID(mapMCIndex[motherID]);
       if (secondMotherID!=-1) mctrack->SetSecondMotherID(mapMCIndex[secondMotherID]);
     }
 }

void PndMcCloner::CorrectPidIndices ( )

protected

Definition at line 217 of file PndMcCloner.cxx.

References fPidChargedArray, fPidNeutralArray, PndPidCandidate::GetMcIndex(), mapMCIndex, and PndPidCandidate::SetMcIndex().

Referenced by Exec().

 {
   // Loop over Pid Candidates and set the mc indices with the new value
 
   Int_t nCands = 0;
 
   nCands = fPidChargedArray->GetEntriesFast();
   for (Int_t iPid=0; iPid<nCands; iPid++)
     {
       PndPidCandidate *pidCand  = (PndPidCandidate*) fPidChargedArray->At(iPid);
       Int_t mcIndex = pidCand->GetMcIndex();
       pidCand->SetMcIndex(mapMCIndex[mcIndex]);
     }
 
   nCands = fPidNeutralArray->GetEntriesFast();
   for (Int_t iPid=0; iPid<nCands; iPid++)
     {
       PndPidCandidate *pidCand  = (PndPidCandidate*) fPidNeutralArray->At(iPid);
       Int_t mcIndex = pidCand->GetMcIndex();
       pidCand->SetMcIndex(mapMCIndex[mcIndex]);
     }
 
 }

void PndMcCloner::Exec ( Option_t * )

virtual

Virtual method Exec

Definition at line 89 of file PndMcCloner.cxx.

References CloneAndCleanMCTrack(), CloneMCTrack(), CorrectMotherIndices(), CorrectPidIndices(), fCleanMC, FindUsedMCIndices(), fOutputArray, and mapMCIndex.

                                 {
   
   // Reset output array
   if ( ! fOutputArray ) Fatal("Exec", "No Output Array");
   
   fOutputArray->Clear();
   mapMCIndex.clear();
  
   if (!fCleanMC)
     {
       CloneMCTrack();
     }
   else
     {  
       FindUsedMCIndices();
       CloneAndCleanMCTrack();
       CorrectMotherIndices();
       CorrectPidIndices();
     }
 }

void PndMcCloner::FindUsedMCIndices ( )

protected

Definition at line 127 of file PndMcCloner.cxx.

References fInputArray, fPidChargedArray, fPidNeutralArray, PndPidCandidate::GetMcIndex(), PndMCTrack::GetMotherID(), mapMCIndex, and mctrack.

Referenced by Exec().

                                     {
   // Loop over PidChargedCand and PidNeutralCand, find the used MC indices, and fill the map 
   // with this index and all the mother indices
 
   Int_t nCands = 0;
 
   // First store primary MC tracks
   nCands = fInputArray->GetEntriesFast();
   for (Int_t imc=0; imc<nCands; imc++)
     {
        PndMCTrack *mctrack = (PndMCTrack*)fInputArray->At(imc);
        if (mctrack->GetMotherID()==-1)
          {
            mapMCIndex[imc] = imc;
          }
        else break;
     }
 
   nCands = fPidChargedArray->GetEntriesFast();
   for (Int_t iPid=0; iPid<nCands; iPid++)
     {
       PndPidCandidate *pidCand  = (PndPidCandidate*) fPidChargedArray->At(iPid);
       Int_t mcIndex = pidCand->GetMcIndex();
       
       while (mcIndex!=-1)
         {
           PndMCTrack *mctrack = (PndMCTrack*)fInputArray->At(mcIndex);
           if (mctrack==NULL) 
             {
               Error("FindUsedMCIndices","PndMCTrack is not existing!");
             }
           mapMCIndex[mcIndex] = mcIndex;
           mcIndex = mctrack->GetMotherID();
         }
     } // Loop over PidChargedCand
 
   nCands = fPidNeutralArray->GetEntriesFast();
   for (Int_t iPid=0; iPid<nCands; iPid++)
     {
       PndPidCandidate *pidCand  = (PndPidCandidate*) fPidNeutralArray->At(iPid);
       Int_t mcIndex = pidCand->GetMcIndex();
 
       while (mcIndex!=-1)
         {
           PndMCTrack *mctrack = (PndMCTrack*)fInputArray->At(mcIndex);
           if (mctrack==NULL)
             {
               Error("FindUsedMCIndices","PndMCTrack is not existing!");
             }
           mapMCIndex[mcIndex] = mcIndex;
           mcIndex = mctrack->GetMotherID();
         }
     } // Loop over PidNeutralCand
 
 }

InitStatus PndMcCloner::Init ( )

virtual

Virtual method Init

Definition at line 36 of file PndMcCloner.cxx.

References fInputArray, fOutputArray, fPidChargedArray, fPidNeutralArray, and fTrackBranchNamePidHypo.

                              {
   
   cout << "-I- PndMcCloner::Init: "
        << "INITIALIZATION *********************" << endl;
   
   //FairRun* sim = FairRun::Instance(); //[R.K. 01/2017] unused variable?
   //FairRuntimeDb* rtdb=sim->GetRuntimeDb(); //[R.K. 01/2017] unused variable?
     
   // Get RootManager
   FairRootManager* ioman = FairRootManager::Instance();
   if ( ! ioman ) {
     cout << "-E- PndMcCloner::Init: "
          << "RootManager not instantiated!" << endl;
     return kFATAL;
   }
   
   // Get input array
   fInputArray = (TClonesArray*) ioman->GetObject("MCTrack");
   if ( ! fInputArray ) {
     cout << "-E- PndMcCloner::Init: "
          << "No MCTrack array!" << endl;
     return kERROR;
   }
 
   fPidChargedArray = (TClonesArray*) ioman->GetObject("PidChargedCand"+fTrackBranchNamePidHypo);
   if ( ! fPidChargedArray ) {
     cout << "-E- PndMcCloner::Init: "
          << "No PidChargedCand array!" << endl;
     return kERROR;
   }
 
   fPidNeutralArray = (TClonesArray*) ioman->GetObject("PidNeutralCand"+fTrackBranchNamePidHypo);
   if ( ! fPidNeutralArray ) {
     cout << "-E- PndMcCloner::Init: "
          << "No PidNeutralCand array!" << endl;
     return kERROR;
   }
 
   // Create and register output array
   fOutputArray = new TClonesArray("PndMCTrack");
   
   ioman->Register("MCTrack","MC",fOutputArray,kTRUE);
  
   cout << "-I- PndMcCloner: Intialization successfull" << endl;
   
   return kSUCCESS;
 
 }