#include <PndMcCloner2.h>

Inheritance diagram for PndMcCloner2:

Public Member Functions
	PndMcCloner2 ()

	~PndMcCloner2 ()

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 (PndMcCloner2, 2)

Protected Attributes
TClonesArray *	fInputArray

TClonesArray *	fPidChargedArray [5]

TClonesArray *	fPidNeutralArray [5]

TClonesArray *	fOutputArray

map< Int_t, Int_t >	mapMCIndex

Bool_t	fCleanMC

TString	fPidHypoStr [5]

Bool_t	fHypoFlagCharged [5]

Bool_t	fHypoFlagNeutral [5]
	Flag to check which hypotheses are present. More...

TString	fTrackBranchNamePidHypo
	Flag to check which hypotheses are present. More...

Detailed Description

Definition at line 13 of file PndMcCloner2.h.

Constructor & Destructor Documentation

PndMcCloner2::PndMcCloner2 ( )

Default constructor

Definition at line 24 of file PndMcCloner2.cxx.

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

PndMcCloner2::~PndMcCloner2 ( )

Destructor

Definition at line 32 of file PndMcCloner2.cxx.

32 { }

Member Function Documentation

PndMcCloner2::ClassDef	(	PndMcCloner2	,
		2
	)

protected

void PndMcCloner2::CloneAndCleanMCTrack ( )

protected

Definition at line 233 of file PndMcCloner2.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 PndMcCloner2::CloneMCTrack ( )

protected

Definition at line 142 of file PndMcCloner2.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 PndMcCloner2::CorrectMotherIndices ( )

protected

Definition at line 250 of file PndMcCloner2.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 PndMcCloner2::CorrectPidIndices ( )

protected

Definition at line 265 of file PndMcCloner2.cxx.

References At, fHypoFlagCharged, fHypoFlagNeutral, fPidChargedArray, fPidNeutralArray, PndPidCandidate::GetMcIndex(), i, mapMCIndex, and PndPidCandidate::SetMcIndex().

Referenced by Exec().

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

void PndMcCloner2::Exec ( Option_t * )

virtual

Virtual method Exec

Definition at line 119 of file PndMcCloner2.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 PndMcCloner2::FindUsedMCIndices ( )

protected

Definition at line 157 of file PndMcCloner2.cxx.

References At, fHypoFlagCharged, fHypoFlagNeutral, fInputArray, fPidChargedArray, fPidNeutralArray, PndPidCandidate::GetMcIndex(), PndMCTrack::GetMotherID(), i, 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;
         }
 
         //todo:assume all arrays are of same length, use list0 to get ncands for now
         //todo:assuming also that all entries in the lists have the same ordering
         for (int ihyp = 0; ihyp < 5;ihyp++){
                 if (fPidChargedArray[ihyp]) nCands = fPidChargedArray[ihyp]->GetEntriesFast();
         }
 //      nCands = fPidChargedArray[0]->GetEntriesFast();
         for (Int_t iPid=0; iPid<nCands; iPid++)
         {
                 Int_t mcIndex = -1;
                 for(int i = 0;i<5;i++){
                         if (!fHypoFlagCharged[i]) continue;
                         PndPidCandidate *pidCand  = (PndPidCandidate*) fPidChargedArray[i]->At(iPid);
                         mcIndex = pidCand->GetMcIndex();
                         if (mcIndex !=-1) break;        //If any of the pidcandidates are pointing to a track, we exit loop
                 }
                 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
 
         for (int ihyp = 0; ihyp < 5;ihyp++){
                 if (fPidNeutralArray[ihyp]) nCands = fPidNeutralArray[ihyp]->GetEntriesFast();
         }
 //      nCands = fPidNeutralArray[0]->GetEntriesFast();
         for (Int_t iPid=0; iPid<nCands; iPid++)
         {
 
                 Int_t mcIndex = -1;
                 for(int i=0;i<5;i++){
                         if (!fHypoFlagNeutral[i]) continue;
                         PndPidCandidate *pidCand  = (PndPidCandidate*) fPidNeutralArray[i]->At(iPid);
                         mcIndex = pidCand->GetMcIndex();
                         if (mcIndex !=-1) break;        //If any of the pidcandidates are pointing to a track, we exit loop
                 }
                 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 PndMcCloner2::Init ( )

virtual

Virtual method Init

Definition at line 36 of file PndMcCloner2.cxx.

References fHypoFlagCharged, fHypoFlagNeutral, fInputArray, fOutputArray, fPidChargedArray, fPidHypoStr, fPidNeutralArray, fTrackBranchNamePidHypo, and i.

                               {
 
         cout << "-I- PndMcCloner2::Init: "
                         << "INITIALIZATION *********************" << endl;
 
         fPidHypoStr[0] = "Electron";
         fPidHypoStr[1] = "Muon";
         fPidHypoStr[2] = "Pion";
         fPidHypoStr[3] = "Kaon";
         fPidHypoStr[4] = "Proton";
 
         //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- PndMcCloner2::Init: "
                                 << "RootManager not instantiated!" << endl;
                 return kFATAL;
         }
 
         // Get input array
         fInputArray = (TClonesArray*) ioman->GetObject("MCTrack");
         if ( ! fInputArray ) {
                 cout << "-E- PndMcCloner2::Init: "
                                 << "No MCTrack array!" << endl;
                 return kERROR;
         }
         bool anychargedtca = false;
         bool anyneutraltca = false;
 
         for(int i=0;i<5;i++){
                 fPidChargedArray[i] = (TClonesArray*) ioman->GetObject("PidChargedCand"+fPidHypoStr[i]);
                 if ( ! fPidChargedArray[i] ) {
                         cout << "-E- PndMcCloner2::Init: "
                                         << "No PidChargedCand"+fPidHypoStr[i]+" array. Continue looking." << endl;
 //                      return kERROR;
                 }
                 else {
                         fHypoFlagCharged[i] = true;
                         anychargedtca = true;
                 }
 
                 fPidNeutralArray[i] = (TClonesArray*) ioman->GetObject("PidNeutralCand"+fPidHypoStr[i]);
                 if ( ! fPidNeutralArray[i] ) {
                         cout << "-E- PndMcCloner2::Init: "
                                         << "No PidNeutralCand"+fPidHypoStr[i]+" array. Continue looking." << endl;
 //                      return kERROR;
                 }
                 else {
                         fHypoFlagNeutral[i] = true;
                         anyneutraltca = true;
                 }
         }
 
         if (!anychargedtca) {
                 cout << "-E- PndMcCloner2::Init: "
                                 << "No PidChargedCand array found!" << endl;
                 return kERROR;
         }
         if (!anyneutraltca) {
                 cout << "-E- PndMcCloner2::Init: "
                                 << "No PidNeutralCand array found!" << endl;
                 return kERROR;
         }
 
 
         // Create and register output array
         fOutputArray = new TClonesArray("PndMCTrack");
 
         ioman->Register("MCTrack"+fTrackBranchNamePidHypo,"MC",fOutputArray,kTRUE);
 
         cout << "-I- PndMcCloner2: Intialization successfull" << endl;
 
         return kSUCCESS;
 
 }