#include "iostream"\r
\r
#include <TPDGCode.h>\r
+#include <TDatabasePDG.h>\r
\r
#include "TChain.h"\r
#include "TTreeStream.h"\r
#include "TList.h"\r
#include "TFile.h"\r
#include "TMatrixD.h"\r
-#include "TRandom.h"\r
+#include "TRandom3.h"\r
\r
#include "AliHeader.h" \r
#include "AliGenEventHeader.h" \r
#include "AlidNdPtAcceptanceCuts.h"\r
\r
#include "AlidNdPtTrackDumpTask.h"\r
+#include "AliKFParticle.h"\r
+#include "AliESDv0.h"\r
\r
using namespace std;\r
\r
, fOutputSummary(0)\r
, fTreeSRedirector(0)\r
, fCentralityEstimator(0)\r
+ , fLowPtTrackDownscaligF(0)\r
+ , fLowPtV0DownscaligF(0)\r
{\r
// Constructor\r
\r
//\r
// create output tree\r
//\r
- fTreeSRedirector = new TTreeSRedirector("dNdPtOutliersAnalysisPbPb.root");\r
+ fTreeSRedirector = new TTreeSRedirector("jotwinow_HighPt_TrackAndV0_Trees.root");\r
\r
PostData(0, fOutputSummary);\r
//PostData(1, fOutput);\r
\r
//\r
Process(fESD,fMC,fESDfriend);\r
+ ProcessV0(fESD,fMC,fESDfriend);\r
\r
// Post output data.\r
PostData(0, fOutputSummary);\r
// check event cuts\r
if(isEventOK && isEventTriggered)\r
{\r
- TRandom random;\r
+ TRandom3 random;\r
\r
for (Int_t iTrack = 0; iTrack < esdEvent->GetNumberOfTracks(); iTrack++)\r
{\r
if(!accCuts->AcceptTrack(track)) continue;\r
\r
// downscale low-pT tracks\r
- if(TMath::Exp(2*track->Pt())<1000*random.Rndm()) continue;\r
+ Double_t scalempt= TMath::Min(track->Pt(),10.);\r
+ if(TMath::Exp(2*scalempt)<fLowPtTrackDownscaligF*random.Rndm()) continue;\r
\r
// Dump to the tree \r
// vertex\r
//PostData(1, fOutput);\r
}\r
\r
+//_____________________________________________________________________________\r
+void AlidNdPtTrackDumpTask::ProcessV0(AliESDEvent *const esdEvent, AliMCEvent * const mcEvent, AliESDfriend *const /*esdFriend*/)\r
+{\r
+ //\r
+ // Process real and/or simulated events\r
+ //\r
+ if(!esdEvent) {\r
+ AliDebug(AliLog::kError, "esdEvent not available");\r
+ return;\r
+ }\r
+\r
+ // get selection cuts\r
+ AlidNdPtEventCuts *evtCuts = GetEventCuts(); \r
+ AlidNdPtAcceptanceCuts *accCuts = GetAcceptanceCuts(); \r
+ AliESDtrackCuts *esdTrackCuts = GetTrackCuts(); \r
+\r
+ if(!evtCuts || !accCuts || !esdTrackCuts) {\r
+ AliDebug(AliLog::kError, "cuts not available");\r
+ return;\r
+ }\r
+\r
+\r
+\r
+\r
+ // trigger selection\r
+ Bool_t isEventTriggered = kTRUE;\r
+ AliPhysicsSelection *physicsSelection = NULL;\r
+ AliTriggerAnalysis* triggerAnalysis = NULL;\r
+\r
+ // \r
+ AliInputEventHandler* inputHandler = (AliInputEventHandler*) AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler();\r
+ if (!inputHandler)\r
+ {\r
+ Printf("ERROR: Could not receive input handler");\r
+ return;\r
+ }\r
+ \r
+ // get file name\r
+ TTree *chain = (TChain*)GetInputData(0);\r
+ if(!chain) { \r
+ Printf("ERROR: Could not receive input chain");\r
+ return;\r
+ }\r
+ TObjString fileName(chain->GetCurrentFile()->GetName());\r
+\r
+ // trigger\r
+ if(evtCuts->IsTriggerRequired()) \r
+ {\r
+ // always MB\r
+ isEventTriggered = inputHandler->IsEventSelected() & AliVEvent::kMB;\r
+\r
+ physicsSelection = static_cast<AliPhysicsSelection*> (inputHandler->GetEventSelection());\r
+ if(!physicsSelection) return;\r
+ //SetPhysicsTriggerSelection(physicsSelection);\r
+\r
+ if (isEventTriggered && (GetTrigger() == AliTriggerAnalysis::kV0AND)) {\r
+ // set trigger (V0AND)\r
+ triggerAnalysis = physicsSelection->GetTriggerAnalysis();\r
+ if(!triggerAnalysis) return;\r
+ isEventTriggered = triggerAnalysis->IsOfflineTriggerFired(esdEvent, GetTrigger());\r
+ }\r
+ }\r
+\r
+ // centrality determination\r
+ Float_t centralityF = -1;\r
+ AliCentrality *esdCentrality = esdEvent->GetCentrality();\r
+ centralityF = esdCentrality->GetCentralityPercentile(fCentralityEstimator.Data());\r
+\r
+\r
+ // get reconstructed vertex \r
+ //const AliESDVertex* vtxESD = 0; \r
+ const AliESDVertex* vtxESD = 0; \r
+ if(GetAnalysisMode() == AlidNdPtHelper::kTPC) {\r
+ vtxESD = esdEvent->GetPrimaryVertexTPC();\r
+ }\r
+ else if(GetAnalysisMode() == AlidNdPtHelper::kTPCITS) {\r
+ vtxESD = esdEvent->GetPrimaryVertexTracks();\r
+ }\r
+ else {\r
+ return;\r
+ }\r
+\r
+ if(!vtxESD) return;\r
+\r
+ Bool_t isEventOK = evtCuts->AcceptEvent(esdEvent,mcEvent,vtxESD); \r
+ //printf("isEventOK %d, isEventTriggered %d \n",isEventOK, isEventTriggered);\r
+ //printf("GetAnalysisMode() %d \n",GetAnalysisMode());\r
+\r
+ // check event cuts\r
+ if(isEventOK && isEventTriggered) {\r
+ //\r
+ // Dump the pt downscaled V0 into the tree\r
+ // \r
+ //\r
+ Int_t ntracks = esdEvent->GetNumberOfTracks();\r
+ Int_t nV0s = esdEvent->GetNumberOfV0s();\r
+ Int_t run = esdEvent->GetRunNumber();\r
+ Int_t time= esdEvent->GetTimeStamp();\r
+ Int_t evNr=esdEvent->GetEventNumberInFile();\r
+ \r
+ for (Int_t iv0=0; iv0<nV0s; iv0++){\r
+ AliESDv0 * v0 = esdEvent->GetV0(iv0);\r
+ if (!v0) continue;\r
+ AliESDtrack * track0 = esdEvent->GetTrack(v0->GetIndex(0));\r
+ AliESDtrack * track1 = esdEvent->GetTrack(v0->GetIndex(1));\r
+ if (!track0) continue;\r
+ if (!track1) continue;\r
+ if (track0->GetSign()<0) {\r
+ track1 = esdEvent->GetTrack(v0->GetIndex(0));\r
+ track0 = esdEvent->GetTrack(v0->GetIndex(1));\r
+ }\r
+ //\r
+ Bool_t isDownscaled = IsV0Downscaled(v0);\r
+ if (isDownscaled) continue;\r
+ AliKFParticle kfparticle; //\r
+ Int_t type=GetKFParticle(v0,esdEvent,kfparticle);\r
+ if (type==0) continue; \r
+\r
+ if(!fTreeSRedirector) return;\r
+ (*fTreeSRedirector)<<"V0s"<<\r
+ "isDownscaled="<<isDownscaled<<\r
+ "run="<<run<<\r
+ "fname="<<&fileName<<\r
+ "time="<<time<<\r
+ "evNr="<<evNr<<\r
+ "type="<<type<<\r
+ "ntracks="<<ntracks<<\r
+ "v0.="<<v0<<\r
+ "kf.="<<&kfparticle<<\r
+ "track0.="<<track0<<\r
+ "track1.="<<track1<<\r
+ "centralityF="<<centralityF<<\r
+ "\n";\r
+ }\r
+ }\r
+ PostData(0, fOutputSummary);\r
+}\r
+\r
+//_____________________________________________________________________________\r
+Int_t AlidNdPtTrackDumpTask::GetKFParticle(AliESDv0 *const v0, AliESDEvent * const event, AliKFParticle & kfparticle)\r
+{\r
+ //\r
+ // Create KF particle in case the V0 fullfill selection criteria\r
+ //\r
+ // Selection criteria\r
+ // 0. algorithm cut\r
+ // 1. track cut\r
+ // 3. chi2 cut\r
+ // 4. rough mass cut\r
+ // 5. Normalized pointing angle cut\r
+ //\r
+ const Double_t cutMass=0.2;\r
+ const Double_t kSigmaDCACut=3;\r
+ //\r
+ // 0.) algo cut - accept only on the fly\r
+ //\r
+ if (v0->GetOnFlyStatus() ==kFALSE) return 0; \r
+ //\r
+ // 1.) track cut\r
+ // \r
+ AliESDtrack * track0 = event->GetTrack(v0->GetIndex(0));\r
+ AliESDtrack * track1 = event->GetTrack(v0->GetIndex(1));\r
+ /*\r
+ TCut cutD="abs(track0.fD/sqrt(track0.fCdd))>2&&abs(track1.fD/sqrt(track1.fCdd))>2";\r
+ TCut cutTheta="abs(track0.fP[3])<1&&abs(track1.fP[3])<1";\r
+ TCut cutNcl="track0.GetTPCClusterInfo(2,1)>100&&track1.GetTPCClusterInfo(2,1)>100";\r
+ */ \r
+ if (TMath::Abs(track0->GetTgl())>1) return 0;\r
+ if (TMath::Abs(track1->GetTgl())>1) return 0;\r
+ if ((track0->GetTPCClusterInfo(2,1))<100) return 0;\r
+ if ((track1->GetTPCClusterInfo(2,1))<100) return 0;\r
+ //if ((track0->GetITSclusters(0))<2) return 0;\r
+ //if ((track1->GetITSclusters(0))<2) return 0; \r
+ Float_t pos0[2]={0}, cov0[3]={0};\r
+ Float_t pos1[2]={0}, cov1[3]={0};\r
+ track0->GetImpactParameters(pos0,cov0);\r
+ track0->GetImpactParameters(pos1,cov1);\r
+ //\r
+ if (TMath::Abs(pos0[0])<kSigmaDCACut*TMath::Sqrt(cov0[0])) return 0;\r
+ if (TMath::Abs(pos1[0])<kSigmaDCACut*TMath::Sqrt(cov1[0])) return 0;\r
+ // \r
+ //\r
+ // 3.) Chi2 cut\r
+ //\r
+ Double_t chi2KF = v0->GetKFInfo(2,2,2);\r
+ if (chi2KF>25) return 0;\r
+ //\r
+ // 4.) Rough mass cut - 0.200 GeV\r
+ //\r
+ static Double_t masses[2]={-1};\r
+ if (masses[0]<0){\r
+ masses[0] = TDatabasePDG::Instance()->GetParticle("K_S0")->Mass();\r
+ masses[1] = TDatabasePDG::Instance()->GetParticle("Lambda0")->Mass();\r
+ }\r
+ Double_t mass00= v0->GetEffMass(0,0);\r
+ Double_t mass22= v0->GetEffMass(2,2);\r
+ Double_t mass42= v0->GetEffMass(4,2);\r
+ Double_t mass24= v0->GetEffMass(2,4);\r
+ Bool_t massOK=kFALSE;\r
+ Int_t type=0;\r
+ Int_t ptype=0;\r
+ Double_t dmass=1;\r
+ Int_t p1=0, p2=0;\r
+ if (TMath::Abs(mass00-0)<cutMass) {\r
+ massOK=kTRUE; type+=1; \r
+ if (TMath::Abs(mass00-0)<dmass) {\r
+ ptype=1;\r
+ dmass=TMath::Abs(mass00-0); \r
+ p1=0; p2=0;\r
+ } \r
+ }\r
+ if (TMath::Abs(mass24-masses[1])<cutMass) {\r
+ massOK=kTRUE; type+=2; \r
+ if (TMath::Abs(mass24-masses[1])<dmass){\r
+ dmass = TMath::Abs(mass24-masses[1]);\r
+ ptype=2;\r
+ p1=2; p2=4;\r
+ }\r
+ }\r
+ if (TMath::Abs(mass42-masses[1])<cutMass) {\r
+ massOK=kTRUE; type+=4;\r
+ if (TMath::Abs(mass42-masses[1])<dmass){\r
+ dmass = TMath::Abs(mass42-masses[1]);\r
+ ptype=4;\r
+ p1=4; p2=2;\r
+ }\r
+ }\r
+ if (TMath::Abs(mass22-masses[0])<cutMass) {\r
+ massOK=kTRUE; type+=8;\r
+ if (TMath::Abs(mass22-masses[0])<dmass){\r
+ dmass = TMath::Abs(mass22-masses[0]);\r
+ ptype=8;\r
+ p1=2; p2=2;\r
+ }\r
+ }\r
+ if (type==0) return 0;\r
+ //\r
+ const Int_t spdg[5]={kPositron,kMuonPlus,kPiPlus, kKPlus, kProton};\r
+ const AliExternalTrackParam *paramP = v0->GetParamP();\r
+ const AliExternalTrackParam *paramN = v0->GetParamN();\r
+ if (paramP->GetSign()<0){\r
+ paramP=v0->GetParamP();\r
+ paramN=v0->GetParamN();\r
+ }\r
+ //Double_t *pparam1 = (Double_t*)paramP->GetParameter();\r
+ //Double_t *pparam2 = (Double_t*)paramN->GetParameter();\r
+ //\r
+ AliKFParticle kfp1( *paramP, spdg[p1] );\r
+ AliKFParticle kfp2( *paramN, -1 *spdg[p2] );\r
+ AliKFParticle V0KF;\r
+ (V0KF)+=kfp1;\r
+ (V0KF)+=kfp2;\r
+ kfparticle=V0KF;\r
+ //\r
+ // Pointing angle\r
+ //\r
+ Double_t errPhi = V0KF.GetErrPhi();\r
+ Double_t pointAngle= TMath::ACos(v0->GetV0CosineOfPointingAngle());\r
+ if (pointAngle/errPhi>10) return 0; \r
+ //\r
+ return ptype; \r
+}\r
+\r
+//_____________________________________________________________________________\r
+Bool_t AlidNdPtTrackDumpTask::IsV0Downscaled(AliESDv0 *const v0)\r
+{\r
+ //\r
+ // Downscale randomly low pt V0\r
+ //\r
+ //return kFALSE;\r
+ Double_t maxPt= TMath::Max(v0->GetParamP()->Pt(), v0->GetParamN()->Pt());\r
+ Double_t scalempt= TMath::Min(maxPt,10.);\r
+ if (TMath::Exp(2*scalempt)<fLowPtV0DownscaligF*gRandom->Rndm()) return kTRUE;\r
+ return kFALSE;\r
+ /*\r
+ \r
+ TH1F his1("his1","his1",100,0,10);\r
+ TH1F his2("his2","his2",100,0,10);\r
+ {for (Int_t i=0; i<10000; i++){\r
+ Double_t rnd=gRandom->Exp(1);\r
+ Bool_t isDownscaled =TMath::Exp(rnd)<100*gRandom->Rndm();\r
+ his1->Fill(rnd); \r
+ if (!isDownscaled) his2->Fill(rnd); \r
+ }}\r
+\r
+ */\r
+\r
+}\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
\r
//_____________________________________________________________________________\r
Bool_t AlidNdPtTrackDumpTask::ConstrainTPCInner(AliExternalTrackParam *const tpcInnerC, const AliESDVertex* vtx, Double_t b[3])\r
void AlidNdPtTrackDumpTask::Terminate(Option_t *) \r
{\r
// Called one at the end \r
- \r
- // check output data\r
+ if(fTreeSRedirector) delete fTreeSRedirector; fTreeSRedirector=0;\r
fOutputSummary = dynamic_cast<TTree*> (GetOutputData(0));\r
if(fOutputSummary) delete fOutputSummary; fOutputSummary=0;\r
- if(fTreeSRedirector) delete fTreeSRedirector; fTreeSRedirector=0;\r
\r
TChain* chain = new TChain("dNdPtTree");\r
if(!chain) return;\r
- chain->Add("dNdPtOutliersAnalysisPbPb.root");\r
+ chain->Add("jotwinow_HighPt_TrackAndV0_Trees.root");\r
TTree *tree = chain->CopyTree("1");\r
if (chain) { delete chain; chain=0; }\r
if(!tree) return;\r
Printf("ERROR: AlidNdPtTrackDumpTask::Terminate(): Output data not avaiable GetOutputData(0)==0x0 ..." );\r
return;\r
}\r
- \r
-\r
\r
PostData(0, fOutputSummary);\r
//PostData(1, fOutput);\r