#include <PndPidIdealFwdOnlyAssociatorTask.h>

Inheritance diagram for PndPidIdealFwdOnlyAssociatorTask:

Public Member Functions
virtual void	Exec (Option_t *option)

virtual InitStatus	Init ()

void	Register ()

void	Reset ()

	PndPidIdealFwdOnlyAssociatorTask (const char name, const char title="Pnd Task")

	PndPidIdealFwdOnlyAssociatorTask ()

virtual	~PndPidIdealFwdOnlyAssociatorTask ()

void	SetToOnlyOne ()

void	SetVerbose (Bool_t verb)

virtual void	SetParContainers ()

virtual void	Finish ()

Bool_t	IsForward (PndPidCandidate *cand)

Protected Member Functions
void	DoPidMatch (PndPidCandidate pidcand, PndPidProbability prob)
	Monte-Carlo Truth track TCA. More...

Protected Attributes
TString	fNeutralBranchName

TString	fChargedBranchName

TClonesArray *	fPidChargedCand

TClonesArray *	fPidNeutralCand
	PndPidCandidate TCA for charged particles. More...

TClonesArray *	fPidChargedProb
	PndPidCandidate TCA for neutral particles. More...

TClonesArray *	fPidNeutralProb
	PndPidProbability TCA for charged particles. More...

TClonesArray *	fMCTrack
	PndPidProbability TCA for neutral particles. More...

Detailed Description

Definition at line 21 of file PndPidIdealFwdOnlyAssociatorTask.h.

Constructor & Destructor Documentation

PndPidIdealFwdOnlyAssociatorTask::PndPidIdealFwdOnlyAssociatorTask	(	const char *	name,
		const char *	title = `"Pnd Task"`
	)

Definition at line 32 of file PndPidIdealFwdOnlyAssociatorTask.cxx.

References fChargedBranchName, fNeutralBranchName, fPidChargedProb, fPidNeutralProb, and SetTitle().

 :FairTask(name) {
   //---
   fNeutralBranchName="PidAlgoIdealFwdOnlyNeutral";
   fChargedBranchName="PidAlgoIdealFwdOnlyCharged";
   fPidChargedProb = new TClonesArray("PndPidProbability");
   fPidNeutralProb = new TClonesArray("PndPidProbability");
   SetTitle(title);
 }

PndPidIdealFwdOnlyAssociatorTask::PndPidIdealFwdOnlyAssociatorTask ( )

Definition at line 23 of file PndPidIdealFwdOnlyAssociatorTask.cxx.

References fChargedBranchName, fNeutralBranchName, fPidChargedProb, and fPidNeutralProb.

                                                                    {
   //---
   fNeutralBranchName="PidAlgoIdealFwdOnlyNeutral";
   fChargedBranchName="PidAlgoIdealFwdOnlyCharged";
   fPidChargedProb = new TClonesArray("PndPidProbability");
   fPidNeutralProb = new TClonesArray("PndPidProbability");
 }

PndPidIdealFwdOnlyAssociatorTask::~PndPidIdealFwdOnlyAssociatorTask ( )

virtual

Definition at line 16 of file PndPidIdealFwdOnlyAssociatorTask.cxx.

                                                                     {
   //
   FairRootManager *fManager =FairRootManager::Instance();
   fManager->Write();
 }

Member Function Documentation

void PndPidIdealFwdOnlyAssociatorTask::DoPidMatch	(	PndPidCandidate *	pidcand,
		PndPidProbability *	prob
	)

protected

Monte-Carlo Truth track TCA.

Definition at line 111 of file PndPidIdealFwdOnlyAssociatorTask.cxx.

References fMCTrack, PndPidCandidate::GetMcIndex(), PndMCTrack::GetPdgCode(), mcpdg, mctrack, PndPidProbability::SetElectronPdf(), PndPidProbability::SetKaonPdf(), PndPidProbability::SetMuonPdf(), PndPidProbability::SetPionPdf(), and PndPidProbability::SetProtonPdf().

Referenced by Exec().

 {
   // Cheating for each Pid Candidate.
   
   Int_t mcid = pidcand->GetMcIndex();
   if(mcid<0) return; // no specified MC id... do nothing
   PndMCTrack *mctrack = (PndMCTrack*)fMCTrack->At(mcid);
   if( 0==mctrack) return; // better do nothing on a null pointer
   Int_t mcpdg = mctrack->GetPdgCode();
   
   // TLorentzVector lv = pidcand->GetLorentzVector();
   // Double_t mass = TDatabasePDG::Instance()->GetParticle(mcpdg)->Mass();
   // lv.SetXYZM(lv.X(), lv.Y(), lv.Z(), mass);
   //   pidcand->SetLorentzVector(lv);
   
   // chaet around with the probabilities...
   switch(mcpdg) {
     case -11: //positron
     case 11: //electron
       prob->SetProtonPdf(0.);
       prob->SetKaonPdf(0.);
       prob->SetPionPdf(0.);
       prob->SetMuonPdf(0.);
       prob->SetElectronPdf(1.);
       break;
       
     case -13: //muon+
     case 13: //muon-
       prob->SetProtonPdf(0.);
       prob->SetKaonPdf(0.);
       prob->SetPionPdf(0.);
       prob->SetMuonPdf(1.);
       prob->SetElectronPdf(0.);
       break;
       
     case 211: //pion+
     case -211: //pion-
       prob->SetProtonPdf(0.);
       prob->SetKaonPdf(0.);
       prob->SetPionPdf(1.);
       prob->SetMuonPdf(0.);
       prob->SetElectronPdf(0.);
       break;
       
     case -321: //Kaon+
     case 321: //Kaon-
       prob->SetProtonPdf(0.);
       prob->SetKaonPdf(1.);
       prob->SetPionPdf(0.);
       prob->SetMuonPdf(0.);
       prob->SetElectronPdf(0.);
       break;
       
     case -2212: //antiproton
     case 2212: //proton
       prob->SetProtonPdf(1.);
       prob->SetKaonPdf(0.);
       prob->SetPionPdf(0.);
       prob->SetMuonPdf(0.);
       prob->SetElectronPdf(0.);
       break;
       
     default:
       prob->SetProtonPdf(1.);
       prob->SetKaonPdf(1.);
       prob->SetPionPdf(1.);
       prob->SetMuonPdf(1.);
       prob->SetElectronPdf(1.);
       break;
   }
   
 }  

void PndPidIdealFwdOnlyAssociatorTask::Exec ( Option_t * option )

virtual

Definition at line 87 of file PndPidIdealFwdOnlyAssociatorTask.cxx.

References DoPidMatch(), fPidChargedCand, fPidChargedProb, fPidNeutralCand, fPidNeutralProb, fVerbose, PndPidCandidate::GetLorentzVector(), i, and IsForward().

                                                       {
   // CAUTION We use Monte-Carlo info here!
   
   if(fVerbose>1) std::cout << "-I- Start PndPidIdealFwdOnlyAssociatorTask. "<<std::endl;
   if (fPidChargedProb->GetEntriesFast() != 0) fPidChargedProb->Clear();
   if (fPidNeutralProb->GetEntriesFast() != 0) fPidNeutralProb->Clear();
   // Get the Candidates
   for(Int_t i=0; i<fPidChargedCand->GetEntriesFast(); i++){
     PndPidCandidate* pidcand = (PndPidCandidate*)fPidChargedCand->At(i);
     PndPidProbability* prob = new((*fPidChargedProb)[i]) PndPidProbability(1.,1.,1.,1.,1.,i);// initializes with equal probability
     if(fVerbose>1) std::cout<<"-I- PndPidIdealFwdOnlyAssociatorTask Charged BEFORE  "<< pidcand->GetLorentzVector().M()<<std::endl;;
     if(! IsForward(pidcand) ) continue;
     DoPidMatch(pidcand,prob);
     if(fVerbose>1) std::cout<<"-I- PndPidIdealFwdOnlyAssociatorTask Charged AFTER   "<< pidcand->GetLorentzVector().M()<<std::endl;;
   }
   for(Int_t i=0; i<fPidNeutralCand->GetEntriesFast(); i++){
     //PndPidCandidate* pidcand = (PndPidCandidate*)fPidNeutralCand->At(i); //[R.K. 01/2017] unused variable
     new((*fPidNeutralProb)[i]) PndPidProbability(1.,1.,1.,1.,1.,i);//PndPidProbability* prob =  //[R.K.03/2017] unused variable
     // initializes with eqaual pdf (no preference)
     //DoPidMatch(pidcand,prob); //TODO match idealy neutral cands, esp. when we have pi0s 
   }
   
 }

void PndPidIdealFwdOnlyAssociatorTask::Finish ( )

virtual

Definition at line 209 of file PndPidIdealFwdOnlyAssociatorTask.cxx.

                                               {
   //---
   //  FairRootManager* ioman = FairRootManager::Instance();
   //  ioman->W
 }

InitStatus PndPidIdealFwdOnlyAssociatorTask::Init ( )

virtual

Definition at line 50 of file PndPidIdealFwdOnlyAssociatorTask.cxx.

References fMCTrack, fPidChargedCand, fPidNeutralCand, and Register().

                                                   {
   
   //  cout << "InitStatus PndPidIdealFwdOnlyAssociatorTask::Init()" << endl;
   
   FairRootManager *fManager =FairRootManager::Instance();       
   
   // TODO: Am I allowed to write in these Arrays?
   fPidChargedCand = (TClonesArray *)fManager->GetObject("PidChargedCand");
   if ( ! fPidChargedCand) {
     std::cout << "-I- PndPidIdealFwdOnlyAssociatorTask::Init: No PndPidCandidate array PidChargedCand there!" << std::endl;
     return kERROR;
   }
   
   fPidNeutralCand = (TClonesArray *)fManager->GetObject("PidNeutralCand");
   if ( ! fPidNeutralCand) {
     std::cout << "-I- PndPidIdealFwdOnlyAssociatorTask::Init: No PndPidCandidate array PidNeutralCand there!" << std::endl;
     return kERROR;
   }
   
   fMCTrack = (TClonesArray*) fManager->GetObject("MCTrack");
   if ( ! fMCTrack) {
     std::cout << "-I- PndPidIdealFwdOnlyAssociatorTask::Init: No MC Track array there!" << std::endl;
     return kERROR;
   }
   
   Register();
   
   std::cout << "-I- PndPidIdealFwdOnlyAssociatorTask::Init: Success!" << std::endl;
   
   return kSUCCESS;
 }

Bool_t PndPidIdealFwdOnlyAssociatorTask::IsForward ( PndPidCandidate * cand )

Definition at line 186 of file PndPidIdealFwdOnlyAssociatorTask.cxx.

References PndPidCandidate::GetMomentum(), and vec.

Referenced by Exec().

                                                                         {
   //--- 
   // Checks if the track is in 5-10 degree in y and x respectively
   // tan(10˚) and tan(5˚) in numbers, don't call trig. functions too often.
   TVector3 vec = cand->GetMomentum();
   if( 0.08748866 * vec.y() > vec.z()) return kFALSE;
   if( 0.17632698 * vec.x() > vec.z()) return kFALSE;
   return kTRUE;
 }

void PndPidIdealFwdOnlyAssociatorTask::Register ( )

Definition at line 200 of file PndPidIdealFwdOnlyAssociatorTask.cxx.

References fChargedBranchName, fNeutralBranchName, fPidChargedProb, and fPidNeutralProb.

Referenced by Init().

                                                 {
   //---
   FairRootManager::Instance()->
   Register(fChargedBranchName,"Pid", fPidChargedProb, kTRUE); 
   FairRootManager::Instance()->
   Register(fNeutralBranchName,"Pid", fPidNeutralProb, kTRUE);
 }

void PndPidIdealFwdOnlyAssociatorTask::Reset ( )

Definition at line 215 of file PndPidIdealFwdOnlyAssociatorTask.cxx.

                                              {
   //---
 }

void PndPidIdealFwdOnlyAssociatorTask::SetParContainers ( )

virtual

Get parameter containers

Definition at line 83 of file PndPidIdealFwdOnlyAssociatorTask.cxx.

                                                         {
   //--
 }

void PndPidIdealFwdOnlyAssociatorTask::SetToOnlyOne ( )

Definition at line 42 of file PndPidIdealFwdOnlyAssociatorTask.cxx.

References fChargedBranchName, and fNeutralBranchName.

 {
   fNeutralBranchName="PidNeutralProbability";
   fChargedBranchName="PidChargedProbability";
 }

void PndPidIdealFwdOnlyAssociatorTask::SetVerbose ( Bool_t verb )

inline

Definition at line 48 of file PndPidIdealFwdOnlyAssociatorTask.h.

References fVerbose.

48 { fVerbose = verb ;};

fVerbose

int fVerbose

Definition: poormantracks.C:24

Member Data Documentation

TString PndPidIdealFwdOnlyAssociatorTask::fChargedBranchName

protected

Definition at line 25 of file PndPidIdealFwdOnlyAssociatorTask.h.

Referenced by PndPidIdealFwdOnlyAssociatorTask(), Register(), and SetToOnlyOne().

TClonesArray* PndPidIdealFwdOnlyAssociatorTask::fMCTrack

protected

PndPidProbability TCA for neutral particles.

Definition at line 31 of file PndPidIdealFwdOnlyAssociatorTask.h.

Referenced by DoPidMatch(), and Init().

TString PndPidIdealFwdOnlyAssociatorTask::fNeutralBranchName

protected

Definition at line 24 of file PndPidIdealFwdOnlyAssociatorTask.h.

Referenced by PndPidIdealFwdOnlyAssociatorTask(), Register(), and SetToOnlyOne().

TClonesArray* PndPidIdealFwdOnlyAssociatorTask::fPidChargedCand

protected

Definition at line 27 of file PndPidIdealFwdOnlyAssociatorTask.h.

Referenced by Exec(), and Init().

TClonesArray* PndPidIdealFwdOnlyAssociatorTask::fPidChargedProb

protected

PndPidCandidate TCA for neutral particles.

Definition at line 29 of file PndPidIdealFwdOnlyAssociatorTask.h.

Referenced by Exec(), PndPidIdealFwdOnlyAssociatorTask(), and Register().

TClonesArray* PndPidIdealFwdOnlyAssociatorTask::fPidNeutralCand

protected

PndPidCandidate TCA for charged particles.

Definition at line 28 of file PndPidIdealFwdOnlyAssociatorTask.h.

Referenced by Exec(), and Init().

TClonesArray* PndPidIdealFwdOnlyAssociatorTask::fPidNeutralProb

protected

PndPidProbability TCA for charged particles.

Definition at line 30 of file PndPidIdealFwdOnlyAssociatorTask.h.

Referenced by Exec(), PndPidIdealFwdOnlyAssociatorTask(), and Register().

The documentation for this class was generated from the following files:

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation