fhNMergedFiles(0), fhScaleFactor(0),
fhEMCalBCEvent(0), fhEMCalBCEventCut(0),
fhTrackBCEvent(0), fhTrackBCEventCut(0),
-fhPrimaryVertexBC(0), fhTimeStampFraction(0)
+fhPrimaryVertexBC(0), fhTimeStampFraction(0),
+fhNPileUpVertSPD(0), fhNPileUpVertTracks(0)
{
//Default Ctor
if(fAnaDebug > 1 ) printf("*** Analysis Maker Constructor *** \n");
fhTrackBCEvent(maker.fhTrackBCEvent),
fhTrackBCEventCut(maker.fhTrackBCEventCut),
fhPrimaryVertexBC(maker.fhPrimaryVertexBC),
-fhTimeStampFraction(maker.fhTimeStampFraction)
+fhTimeStampFraction(maker.fhTimeStampFraction),
+fhNPileUpVertSPD(maker.fhNPileUpVertSPD),
+fhNPileUpVertTracks(maker.fhNPileUpVertTracks)
{
// cpy ctor
}
{
// Event control histograms
+ AliVEvent* event = fReader->GetInputEvent();
+ AliESDEvent* esdevent = dynamic_cast<AliESDEvent*> (event);
+ AliAODEvent* aodevent = dynamic_cast<AliAODEvent*> (event);
+
fhNEvents ->Fill(0); // Number of events analyzed
if( fReader->IsPileUpFromSPD())
fhNPileUpEvents->Fill(0.5);
- if( fReader->GetInputEvent()->IsPileupFromSPDInMultBins())
+ if( event->IsPileupFromSPDInMultBins())
fhNPileUpEvents->Fill(1.5);
if( fReader->IsPileUpFromEMCal())
fhNPileUpEvents->Fill(2.5);
if(fReader->IsPileUpFromSPD())
fhPileUpClusterMultAndSPDPileUp ->Fill(fReader->GetNPileUpClusters());
-
+
fhPileUpClusterMult ->Fill(fReader->GetNPileUpClusters ());
fhTrackMult ->Fill(fReader->GetTrackMultiplicity());
fhCentrality ->Fill(fReader->GetEventCentrality ());
fhEventPlaneAngle ->Fill(fReader->GetEventPlaneAngle ());
-
for(Int_t i = 0; i < 19; i++)
{
if(fReader->GetTrackEventBC(i)) fhTrackBCEvent ->Fill(i);
}
Double_t v[3];
- fReader->GetInputEvent()->GetPrimaryVertex()->GetXYZ(v) ;
+ event->GetPrimaryVertex()->GetXYZ(v) ;
fhZVertex->Fill(v[2]);
- Int_t primaryBC = -1000;
- AliESDEvent* esdevent = dynamic_cast<AliESDEvent*> (fReader->GetInputEvent());
- AliAODEvent* aodevent = dynamic_cast<AliAODEvent*> (fReader->GetInputEvent());
+ Int_t bc = fReader->GetVertexBC();
+ if(bc!=AliVTrack::kTOFBCNA)fhPrimaryVertexBC->Fill(bc);
- if (esdevent)
- primaryBC = esdevent->GetPrimaryVertex()->GetBC();
- else if(aodevent)
- primaryBC = aodevent->GetPrimaryVertex()->GetBC();
- fhPrimaryVertexBC->Fill(primaryBC);
+ // N pile up vertices
+ Int_t nVerticesSPD = -1;
+ Int_t nVerticesTracks = -1;
+ if (esdevent)
+ {
+ nVerticesSPD = esdevent->GetNumberOfPileupVerticesSPD();
+ nVerticesTracks = esdevent->GetNumberOfPileupVerticesTracks();
+
+ }//ESD
+ else if (aodevent)
+ {
+ nVerticesSPD = aodevent->GetNumberOfPileupVerticesSPD();
+ nVerticesTracks = aodevent->GetNumberOfPileupVerticesTracks();
+ }//AOD
+
+ fhNPileUpVertSPD ->Fill(nVerticesSPD);
+ fhNPileUpVertTracks->Fill(nVerticesTracks);
+
// Time stamp
if(fReader->IsSelectEventTimeStampOn() && esdevent)
{
fhTrackBCEventCut->GetXaxis()->SetBinLabel(i ,Form("%d",i-10));
fOutputContainer->Add(fhTrackBCEventCut);
- fhPrimaryVertexBC = new TH1F("hPrimaryVertexBC", "Number of primary vertex per bunch crossing ", 18 , -9 , 9 ) ;
+ fhPrimaryVertexBC = new TH1F("hPrimaryVertexBC", "Number of primary vertex per bunch crossing ", 41 , -20 , 20 ) ;
fhPrimaryVertexBC->SetYTitle("# events");
fhPrimaryVertexBC->SetXTitle("Bunch crossing");
fOutputContainer->Add(fhPrimaryVertexBC);
fhPileUpClusterMultAndSPDPileUp->SetXTitle("# clusters");
fOutputContainer->Add(fhPileUpClusterMultAndSPDPileUp);
+ fhNPileUpVertSPD = new TH1F ("hNPileUpVertSPD","N pile-up SPD vertex", 50,0,50);
+ fhNPileUpVertSPD->SetYTitle("# vertex ");
+ fOutputContainer->Add(fhNPileUpVertSPD);
+
+ fhNPileUpVertTracks = new TH1F ("hNPileUpVertTracks","N pile-up Tracks vertex", 50,0,50);
+ fhNPileUpVertTracks->SetYTitle("# vertex ");
+ fOutputContainer->Add(fhNPileUpVertTracks);
+
fhCentrality = new TH1F("hCentrality","Number of events in centrality bin",100,0.,100) ;
fhCentrality->SetXTitle("Centrality bin");
fOutputContainer->Add(fhCentrality) ;
TH1F * fhTrackBCEventCut; //! N events depending on the existance of a track above acceptance and pt cut in a given bunch crossing
TH1F * fhPrimaryVertexBC; //! Primary vertex BC
TH1F * fhTimeStampFraction; //! event fraction depending on Time Stamp, only if activated on reader
+ TH1F * fhNPileUpVertSPD; //! number of pile-up vertices from SPD
+ TH1F * fhNPileUpVertTracks; //! number of pile-up vertices from tracks
AliAnaCaloTrackCorrMaker & operator = (const AliAnaCaloTrackCorrMaker & ) ; // cpy assignment
- ClassDef(AliAnaCaloTrackCorrMaker,15)
+ ClassDef(AliAnaCaloTrackCorrMaker,16)
} ;
fWriteOutputDeltaAOD(kFALSE),fOldAOD(kFALSE), fCaloFilterPatch(kFALSE),
fEMCALClustersListName(""), fZvtxCut(0.),
fAcceptFastCluster(kFALSE), fRemoveLEDEvents(kTRUE),
-fDoEventSelection(kFALSE), fDoV0ANDEventSelection(kFALSE), fUseEventsWithPrimaryVertex(kFALSE),
+fDoEventSelection(kFALSE), fDoV0ANDEventSelection(kFALSE), fDoVertexBCEventSelection(kFALSE),
+fUseEventsWithPrimaryVertex(kFALSE),
fTriggerAnalysis (0x0), fTimeStampEventSelect(0),
fTimeStampEventFracMin(0), fTimeStampEventFracMax(0),
fTimeStampRunMin(0), fTimeStampRunMax(0),
fNPileUpClusters(-1), fNNonPileUpClusters(-1), fNPileUpClustersCut(3),
-fCentralityClass(""), fCentralityOpt(0),
+fVertexBC(-200), fRecalculateVertexBC(0),
+fCentralityClass(""), fCentralityOpt(0),
fEventPlaneMethod(""), fImportGeometryFromFile(kFALSE), fImportGeometryFilePath("")
{
//Ctor
}
+//________________________________________________________________________
+Bool_t AliCaloTrackReader::AcceptDCA(const Float_t pt, const Float_t dca)
+{
+ // Accept track if DCA is smaller than function
+
+ Float_t cut = fTrackDCACut[0]+fTrackDCACut[1]/TMath::Power(pt,fTrackDCACut[2]);
+
+ if(TMath::Abs(dca) < cut)
+ return kTRUE;
+ else
+ return kFALSE;
+
+}
+
//________________________________________________
Bool_t AliCaloTrackReader::ComparePtHardAndJetPt()
{
return mch;
}
+//___________________________________________________________
+Int_t AliCaloTrackReader::GetVertexBC(const AliVVertex * vtx)
+{
+ // Get the vertex BC
+
+ Int_t vertexBC=vtx->GetBC();
+ if(!fRecalculateVertexBC) return vertexBC;
+
+ // In old AODs BC not stored, recalculate it
+ // loop over the global track and select those which have small DCA to primary vertex (e.g. primary).
+ // If at least one of these primaries has valid BC != 0, then this vertex is a pile-up candidate.
+ // Execute after CTS
+ Double_t bz = fInputEvent->GetMagneticField();
+ Bool_t bc0 = kFALSE;
+ Int_t ntr = GetCTSTracks()->GetEntriesFast();
+ //printf("N Tracks %d\n",ntr);
+
+ for(Int_t i = 0 ; i < ntr ; i++)
+ {
+ AliVTrack * track = (AliVTrack*) (GetCTSTracks()->At(i));
+
+ //Check if has TOF info, if not skip
+ ULong_t status = track->GetStatus();
+ Bool_t okTOF = (status & AliVTrack::kTOFout) == AliVTrack::kTOFout ;
+ vertexBC = track->GetTOFBunchCrossing(bz);
+ Float_t pt = track->Pt();
+
+ if(!okTOF) continue;
+
+ // Get DCA x, y
+ Double_t dca[2] = {1e6,1e6};
+ Double_t covar[3] = {1e6,1e6,1e6};
+ track->PropagateToDCA(vtx,bz,100.,dca,covar);
+
+ if(AcceptDCA(pt,dca[0]))
+ {
+ if (vertexBC !=0 && fVertexBC != AliVTrack::kTOFBCNA) return vertexBC;
+ else if(vertexBC == 0) bc0 = kTRUE;
+ }
+ }
+
+ if( bc0 ) vertexBC = 0 ;
+ else vertexBC = AliVTrack::kTOFBCNA ;
+
+ return vertexBC;
+
+}
+
//_____________________________
void AliCaloTrackReader::Init()
{
fPHOSPtMax = 1000. ;
//Track DCA cuts
- fTrackDCACut[0] = 3; //xy, quite large
- fTrackDCACut[1] = 3; //z, quite large
- fTrackDCACut[2] = 3; //TPC constrained, quite large
-
+ // dca_xy cut = 0.0105+0.0350/TMath::Power(pt,1.1);
+ fTrackDCACut[0] = 0.0105;
+ fTrackDCACut[1] = 0.0350;
+ fTrackDCACut[2] = 1.1;
+
//Do not filter the detectors input by default.
fFillEMCAL = kFALSE;
fFillPHOS = kFALSE;
const char * /*currentFileName*/)
{
//Fill the event counter and input lists that are needed, called by the analysis maker.
-
+
fEventNumber = iEntry;
//fCurrentFileName = TString(currentFileName);
if(!fInputEvent)
Int_t cen = GetEventCentrality();
if(cen > fCentralityBin[1] || cen < fCentralityBin[0]) return kFALSE; //reject events out of bin.
}
-
+
//Fill the arrays with cluster/tracks/cells data
if(!fEventTriggerAtSE)
//printf("Selected triggered event : %s\n",GetFiredTriggerClasses().Data());
}
+ // Get the main vertex BC, in case not available
+ // it is calculated in FillCTS checking the BC of tracks
+ // with DCA small (if cut applied, if open)
+ fVertexBC=fInputEvent->GetPrimaryVertex()->GetBC();
+
if(fFillCTS)
{
FillInputCTS();
if(fTrackMult == 0 && fDoEventSelection) return kFALSE;
}
+ if(fDoVertexBCEventSelection)
+ {
+ if(fVertexBC!=0 && fVertexBC!=AliVTrack::kTOFBCNA) return kFALSE ;
+ }
+
if(fFillEMCALCells)
FillInputEMCALCells();
fTrackBCEventCut[i] = 0;
}
+ Bool_t bc0 = kFALSE;
+ if(fRecalculateVertexBC) fVertexBC=AliVTrack::kTOFBCNA;
+
for (Int_t itrack = 0; itrack < nTracks; itrack++)
{////////////// track loop
AliVTrack * track = (AliVTrack*)fInputEvent->GetTrack(itrack) ; // retrieve track from esd
TLorentzVector momentum(pTrack[0],pTrack[1],pTrack[2],0);
- Bool_t okTOF = ( (status & AliVTrack::kTOFout) == AliVTrack::kTOFout ) ;
- Double_t tof = -1000;
- //Int_t bc = -1000;
+ Bool_t okTOF = ( (status & AliVTrack::kTOFout) == AliVTrack::kTOFout ) ;
+ Double_t tof = -1000;
Int_t trackBC = -1000 ;
if(okTOF)
SetTrackEventBC(trackBC+9);
tof = track->GetTOFsignal()*1e-3;
- //printf("track TOF %e\n",tof);
- //bc = TMath::Nint((tof-25)/50) + 9;
- //printf("track pt %f, tof %2.2f, bc=%d\n",track->Pt(),tof,bc);
- //SetTrackEventBC(bc);
-
}
if(fCTSPtMin > momentum.Pt() || fCTSPtMax < momentum.Pt()) continue ;
if(fCheckFidCut && !fFiducialCut->IsInFiducialCut(momentum,"CTS")) continue;
-
- if(okTOF)
- {
- //SetTrackEventBCcut(bc);
- SetTrackEventBCcut(trackBC+9);
-
- //In any case, the time should to be larger than the fixed window ...
- if( fUseTrackTimeCut && (trackBC!=0 || tof < fTrackTimeCutMin || tof > fTrackTimeCutMax) )
- {
- //printf("Remove track time %f and bc = %d\n",tof,trackBC);
- continue ;
- }
- //else printf("Accept track time %f and bc = %d\n",tof,trackBC);
-
- }
-
+
if(fUseTrackDCACut)
{
- //In case of hybrid tracks on AODs, constrained TPC tracks cannot be propagated back to primary vertex
+ //In case of AODs, TPC tracks cannot be propagated back to primary vertex,
+ // info stored
AliAODTrack * aodTrack = dynamic_cast<AliAODTrack*>(track);
- Float_t dcaCons = -999;
+
+ Float_t dcaTPC =-999;
+ Bool_t okDCA = kFALSE;
if(aodTrack)
{
- dcaCons = aodTrack->DCA();
+ dcaTPC = aodTrack->DCA();
//vtxBC = aodTrack->GetProdVertex()->GetBC();
- if(dcaCons > -999)
+ if(dcaTPC!=-999)
{
- if(TMath::Abs(dcaCons) > fTrackDCACut[2] ) continue ;
+ okDCA = AcceptDCA(momentum.Pt(),dcaTPC);
+ if(!okDCA) continue ;
}
}
-
- //non contrained TPC tracks (tracks with ITS points) on AODs
- if(dcaCons==-999)
+
+ //normal way to get the dca, cut on dca_xy
+ if(dcaTPC==-999)
{
Double_t dca[2] = {1e6,1e6};
Double_t covar[3] = {1e6,1e6,1e6};
- Bool_t okDCA = track->PropagateToDCA(fInputEvent->GetPrimaryVertex(),bz,100.,dca,covar);
- if( !okDCA ||
- TMath::Abs(dca[0]) > fTrackDCACut[0] ||
- TMath::Abs(dca[1]) > fTrackDCACut[1] ) continue ;
+ okDCA = track->PropagateToDCA(fInputEvent->GetPrimaryVertex(),bz,100.,dca,covar);
+ if( okDCA) okDCA = AcceptDCA(momentum.Pt(),dca[0]);
+ if(!okDCA) continue ;
}
}// DCA cuts
+ if(okTOF)
+ {
+ //SetTrackEventBCcut(bc);
+ SetTrackEventBCcut(trackBC+9);
+
+ //After selecting tracks with small DCA, pointing to vertex, set vertex BC depeding on tracks BC
+ if(fRecalculateVertexBC)
+ {
+ if (trackBC !=0 && trackBC != AliVTrack::kTOFBCNA) fVertexBC = trackBC;
+ else if(trackBC == 0) bc0 = kTRUE;
+ }
+
+ //In any case, the time should to be larger than the fixed window ...
+ if( fUseTrackTimeCut && (trackBC!=0 || tof < fTrackTimeCutMin || tof > fTrackTimeCutMax) )
+ {
+ //printf("Remove track time %f and bc = %d\n",tof,trackBC);
+ continue ;
+ }
+ //else printf("Accept track time %f and bc = %d\n",tof,trackBC);
+
+ }
+
if(fDebug > 2 && momentum.Pt() > 0.1)
printf("AliCaloTrackReader::FillInputCTS() - Selected tracks E %3.2f, pt %3.2f, phi %3.2f, eta %3.2f\n",
momentum.E(),momentum.Pt(),momentum.Phi()*TMath::RadToDeg(),momentum.Eta());
}// track loop
+ if(fVertexBC ==0 || fVertexBC == AliVTrack::kTOFBCNA)
+ {
+ if( bc0 ) fVertexBC = 0 ;
+ else fVertexBC = AliVTrack::kTOFBCNA ;
+ }
+
if(fDebug > 1)
printf("AliCaloTrackReader::FillInputCTS() - aod entries %d, input tracks %d, pass status %d, multipliticy %d\n", fCTSTracks->GetEntriesFast(), nTracks, nstatus, fTrackMult);//fCTSTracksNormalInputEntries);
void SetEMCALEMax (Float_t e) { SetEMCALPtMax(e) ; }
void SetPHOSEMax (Float_t e) { SetPHOSPtMax (e) ; }
-
+ // Track DCA cut
+ Bool_t AcceptDCA(const Float_t pt, const Float_t dca);
Double_t GetTrackDCACut(Int_t i) const { if(i >= 0 && i < 3 ) return fTrackDCACut[i] ;
else return -999 ; }
void SwitchOnUseTrackDCACut() { fUseTrackDCACut = kTRUE ; }
void SwitchOffUseTrackDCACut() { fUseTrackDCACut = kFALSE ; }
+ Bool_t IsDCACutOn() const { return fUseTrackDCACut ; }
//Time cut
void SwitchOnEventSelection() { fDoEventSelection = kTRUE ; }
void SwitchOffEventSelection() { fDoEventSelection = kFALSE ; }
- Bool_t IsEventSelectionDone() const { return fDoEventSelection ; }
+ Bool_t IsEventSelectionDone() const { return fDoEventSelection ; }
void SwitchOnV0ANDSelection() { fDoV0ANDEventSelection = kTRUE ; }
void SwitchOffV0ANDSelection() { fDoV0ANDEventSelection = kFALSE ; }
Bool_t IsV0ANDEventSelectionDone() const { return fDoV0ANDEventSelection ; }
+ void SwitchOnVertexBCEventSelection() { fDoVertexBCEventSelection = kTRUE ; }
+ void SwitchOffVertexBCEventSelection() { fDoVertexBCEventSelection = kFALSE ; }
+ Bool_t IsVertexBCEventSelectionDone() const { return fDoVertexBCEventSelection ; }
+
void SwitchOnPrimaryVertexSelection() { fUseEventsWithPrimaryVertex = kTRUE ; }
void SwitchOffPrimaryVertexSelection() { fUseEventsWithPrimaryVertex = kFALSE ; }
Bool_t IsPrimaryVertexSelectionDone() const { return fUseEventsWithPrimaryVertex ; }
-
//Time Stamp
Double_t GetRunTimeStampMin() const { return fTimeStampRunMin ; }
void SetEMCalEventBCcut(Int_t bc) { if(bc >=0 && bc < 19) fEMCalBCEventCut[bc] = 1 ; }
void SetTrackEventBCcut(Int_t bc) { if(bc >=0 && bc < 19) fTrackBCEventCut[bc] = 1 ; }
+ Int_t GetVertexBC(const AliVVertex * vtx);
+ Int_t GetVertexBC() const { return fVertexBC ; }
+ void SwitchOnRecalculateVertexBC() { fRecalculateVertexBC = kTRUE ; }
+ void SwitchOffRecalculateVertexBC() { fRecalculateVertexBC = kFALSE ; }
// Track selection
ULong_t GetTrackStatus() const { return fTrackStatus ; }
Double_t fTrackTimeCutMin; // Remove tracks with time smaller than this value, in ns
Double_t fTrackTimeCutMax; // Remove tracks with time larger than this value, in ns
Bool_t fUseTrackDCACut; // Do DCA selection
- Double_t fTrackDCACut[3]; // Remove tracks with DCA larger than cut
+ Double_t fTrackDCACut[3]; // Remove tracks with DCA larger than cut, parameters of function stored here
TList * fAODBranchList ; //-> List with AOD branches created and needed in analysis
TObjArray * fCTSTracks ; //-> temporal array with tracks
Bool_t fRemoveLEDEvents; // Remove events where LED was wrongly firing - EMCAL LHC11a
Bool_t fDoEventSelection; // Select events depending on V0, pileup, vertex well reconstructed, at least 1 track ...
Bool_t fDoV0ANDEventSelection; // Select events depending on V0, fDoEventSelection should be on
+ Bool_t fDoVertexBCEventSelection; // Select events with vertex on BC=0 or -100
Bool_t fUseEventsWithPrimaryVertex ; // Select events with primary vertex
AliTriggerAnalysis* fTriggerAnalysis; // Access to trigger selection algorithm for V0AND calculation
Int_t fEMCalBCEventCut[19]; // Fill one entry per event if there is a cluster in a given BC, depend on cluster E, acceptance cut
Int_t fTrackBCEvent[19]; // Fill one entry per event if there is a track in a given BC
Int_t fTrackBCEventCut[19]; // Fill one entry per event if there is a track in a given BC, depend on track pT, acceptance cut
-
+ Int_t fVertexBC; // Vertex BC
+ Bool_t fRecalculateVertexBC; // Recalculate vertex BC from tracks pointing to vertex
+
//Centrality/Event plane
TString fCentralityClass; // Name of selected centrality class
Int_t fCentralityOpt; // Option for the returned value of the centrality, possible options 5, 10, 100
AliCaloTrackReader( const AliCaloTrackReader & r) ; // cpy ctor
AliCaloTrackReader & operator = (const AliCaloTrackReader & r) ; // cpy assignment
- ClassDef(AliCaloTrackReader,49)
+ ClassDef(AliCaloTrackReader,50)
} ;
AliAnaCaloTrackCorrBaseClass(),
fFillPileUpHistograms(0),
fFillVertexBC0Histograms(0),
- fRecalculateVertexBC(0),
//Histograms
fhNtracks(0), fhPt(0), fhPtNoCut(0),
fhPtCutDCA(0), fhPtCutDCABCOK(0),
fhPtUnknown(0), fhPhiUnknown(0), fhEtaUnknown(0),
//TOF
fhTOFSignal(0), fhTOFSignalPtCut(0), fhTOFSignalBCOK(0),
- fhPtTOFSignal(0), fhPtTOFSignalVtxOutBC0(0), fhPtTOFSignalVtxInBC0(0),
+ fhPtTOFSignal(0), fhPtTOFSignalDCACut(0),
+ fhPtTOFSignalVtxOutBC0(0), fhPtTOFSignalVtxInBC0(0),
fhPtTOFStatus0(0), fhEtaPhiTOFStatus0(0),
fhEtaPhiTOFBC0(0), fhEtaPhiTOFBCPlus(0), fhEtaPhiTOFBCMinus(0),
fhEtaPhiTOFBC0PileUpSPD(0),
for(Int_t i = 0; i < 3; i++)
{
- fDCACutParam [i] = 0 ;
fhPtDCA [i] = 0 ;
fhPtDCASPDRefit [i] = 0 ;
}
-//_____________________________________________________________________________
-Bool_t AliAnaChargedParticles::AcceptDCA(const Float_t pt, const Float_t dca)
-{
- // Accept track if DCA is smaller than function
-
- Float_t cut = fDCACutParam[0]+fDCACutParam[1]/TMath::Power(pt,fDCACutParam[2]);
-
- if(TMath::Abs(dca) < cut)
- return kTRUE;
- else
- return kFALSE;
-
-}
-
//_______________________________________________________
TList * AliAnaChargedParticles::GetCreateOutputObjects()
{
fhPtTOFSignal->SetYTitle("TOF signal (ns)");
fhPtTOFSignal->SetXTitle("p_{T} (GeV/c)");
outputContainer->Add(fhPtTOFSignal);
+
+ fhPtTOFSignalDCACut = new TH2F ("hPtTOFSignalDCACut","TOF signal after DCA cut", nptbins,ptmin,ptmax,ntofbins,mintof,maxtof);
+ fhPtTOFSignalDCACut->SetYTitle("TOF signal (ns)");
+ fhPtTOFSignalDCACut->SetXTitle("p_{T} (GeV/c)");
+ outputContainer->Add(fhPtTOFSignalDCACut);
if(fFillVertexBC0Histograms)
{
}
-//___________________________________________
-Int_t AliAnaChargedParticles::GetVertexBC(const AliVVertex * vtx)
-{
- // Get the vertex BC
-
- AliVEvent * event = GetReader()->GetInputEvent();
-
- if(!fRecalculateVertexBC) return vtx->GetBC();
-
- // In old AODs BC not stored, recalculate it
- // loop over the global track and select those which have small DCA to primary vertex (e.g. primary).
- // If at least one of these primaries has valid BC != 0, then this vertex is a pile-up candidate.
-
- Double_t bz = event->GetMagneticField();
- Bool_t bc0 = kFALSE;
- Int_t ntr = GetCTSTracks()->GetEntriesFast();
- //printf("N Tracks %d\n",ntr);
-
- for(Int_t i = 0 ; i < ntr ; i++)
- {
- AliVTrack * track = (AliVTrack*) (GetCTSTracks()->At(i));
-
- //Check if has TOF info, if not skip
- ULong_t status = track->GetStatus();
- Bool_t okTOF = (status & AliVTrack::kTOFout) == AliVTrack::kTOFout ;
- Int_t trackBC = track->GetTOFBunchCrossing(bz);
- Float_t pt = track->Pt();
-
- if(!okTOF) continue;
-
- // Get DCA x, y
- Double_t dca[2] = {1e6,1e6};
- Double_t covar[3] = {1e6,1e6,1e6};
- track->PropagateToDCA(GetReader()->GetInputEvent()->GetPrimaryVertex(),bz,100.,dca,covar);
-
- if(AcceptDCA(pt,dca[0]))
- {
- if (trackBC !=0 && trackBC != AliVTrack::kTOFBCNA) return trackBC;
- else if(trackBC == 0) bc0 = kTRUE;
- }
- }
-
- if( bc0 ) return 0 ;
- else return AliVTrack::kTOFBCNA ;
-
-}
//___________________________________________
void AliAnaChargedParticles::InitParameters()
AddToHistogramsName("AnaCharged_");
- // dca_xy cut = 0.0105+0.0350/TMath::Power(pt,1.1);
- fDCACutParam[0]= 0.0105;
- fDCACutParam[1]= 0.0350;
- fDCACutParam[2]= 1.1;
}
if(GetDebug() > 0)
printf("AliAnaChargedParticles::MakeAnalysisFillAOD() - In CTS aod entries %d\n", ntracks);
-
AliVEvent * event = GetReader()->GetInputEvent();
- //AliESDEvent* esdevent = dynamic_cast<AliESDEvent*> (event);
- //AliAODEvent* aodevent = dynamic_cast<AliAODEvent*> (event);
+ Int_t vtxBC = GetReader()->GetVertexBC();
+ if(!GetReader()->IsDCACutOn()) vtxBC = GetReader()->GetVertexBC(event->GetPrimaryVertex());
- const AliVVertex * vtx = event->GetPrimaryVertex();
- Int_t vtxBC = GetVertexBC(vtx);
-
if(fFillVertexBC0Histograms)
{
fhProductionVertexBC->Fill(vtxBC);
fhPtDCA[2]->Fill(pt, dcaCons);
}
- if(AcceptDCA(pt,trackDCA)) fhPtCutDCA->Fill(pt);
+ if(GetReader()->AcceptDCA(pt,trackDCA)) fhPtCutDCA->Fill(pt);
if(fFillVertexBC0Histograms)
{
{
fhPtVtxInBC0->Fill(pt);
fhEtaPhiVtxInBC0->Fill(eta,phi);
- if(AcceptDCA(pt,trackDCA)) fhPtCutDCABCOK->Fill(pt);
+ if(GetReader()->AcceptDCA(pt,trackDCA)) fhPtCutDCABCOK->Fill(pt);
if(dcaCons == -999)
{
{
fhTOFSignal ->Fill(tof);
fhPtTOFSignal->Fill(pt, tof);
-
+ if(GetReader()->AcceptDCA(pt,trackDCA)) fhPtTOFSignalDCACut->Fill(pt, tof);
+
if(TMath::Abs(vtxBC) > 0 && vtxBC!=AliVTrack::kTOFBCNA)
fhPtTOFSignalVtxOutBC0->Fill(pt, tof);
else
public:
AliAnaChargedParticles() ; // default ctor
virtual ~AliAnaChargedParticles() { ; } //virtual dtor
-
- Bool_t AcceptDCA(const Float_t pt, const Float_t dca) ;
TList * GetCreateOutputObjects();
-
- Int_t GetVertexBC(const AliVVertex * vtx);
-
+
void Init();
void InitParameters();
void SwitchOnFillVertexBC0Histograms() { fFillVertexBC0Histograms = kTRUE ; }
void SwitchOffFillVertexBC0Histograms() { fFillVertexBC0Histograms = kFALSE ; }
- void SwitchOnRecalculateVertexBC() { fRecalculateVertexBC = kTRUE ; }
- void SwitchOffRecalculateVertexBC() { fRecalculateVertexBC = kFALSE ; }
-
- void SetDCACutParameters(Int_t i, Float_t par) { if(i >= 0 && i < 3) fDCACutParam[i] = par ; }
-
private:
Bool_t fFillPileUpHistograms; // Fill pile-up related histograms
Bool_t fFillVertexBC0Histograms; // Fill histograms for tracks with vertex BC=0 or not related histograms
- Bool_t fRecalculateVertexBC; // Recalculate vertex BC for older AODs
- Float_t fDCACutParam[3]; // DCA cut function parameters
//Histograms
TH1F * fhNtracks; //! track multiplicity distribution
TH1F * fhTOFSignalPtCut; //! TOF signal pt and acceptance cut
TH1F * fhTOFSignalBCOK; //! TOF signal pt and acceptance cut
TH2F * fhPtTOFSignal; //! TOF signal vs track pT, good status
+ TH2F * fhPtTOFSignalDCACut; //! TOF signal vs track pT, good status
TH2F * fhPtTOFSignalPileUp[7]; //! TOF signal vs track pT, good status, pile-up
TH2F * fhPtTOFSignalVtxOutBC0; //! TOF signal vs track pT, good status
TH2F * fhPtTOFSignalVtxOutBC0PileUp[7];//! TOF signal vs track pT, good status, pile-up
fFillPileUpHistograms(0),
//Histograms
fhPtInput(0), fhPtFidCut(0),
- fhPtLeading(0), fhPtLeadingPileUp(),
+ fhPtLeading(0), fhPtLeadingVtxBC0(0),
fhPtLeadingVzBin(0), fhPtLeadingBin(0),
fhPhiLeading(0), fhEtaLeading(0),
fhPtLeadingMC(),
fhXEChargedBC0(), fhXEUeChargedBC0(),
fhZTChargedBC0(), fhZTUeChargedBC0(),
fhPtTrigChargedBC0(),
+ fhDeltaPhiChargedVtxBC0(), fhDeltaPhiChargedPtA3GeVVtxBC0(),
+ fhXEChargedVtxBC0(), fhXEUeChargedVtxBC0(),
+ fhZTChargedVtxBC0(), fhZTUeChargedVtxBC0(),
+ fhPtTrigChargedVtxBC0(),
fhDeltaPhiUeLeftCharged(0), fhDeltaPhiUeRightCharged(0),
fhDeltaPhiUeLeftUpCharged(0), fhDeltaPhiUeRightUpCharged(0),
fhDeltaPhiUeLeftDownCharged(0), fhDeltaPhiUeRightDownCharged(0),
if(ptAssoc > 3 ) fhDeltaPhiChargedPtA3GeVBC0->Fill(ptTrig ,deltaPhi) ;
}
+ Int_t vtxBC = GetReader()->GetVertexBC();
+ if(vtxBC == 0 || vtxBC==AliVTrack::kTOFBCNA)
+ {
+ fhDeltaPhiChargedVtxBC0->Fill(ptTrig ,deltaPhi) ;
+ if(ptAssoc > 3 ) fhDeltaPhiChargedPtA3GeVVtxBC0->Fill(ptTrig ,deltaPhi) ;
+ }
+
if(GetReader()->IsPileUpFromSPD()) { fhDeltaEtaChargedPileUp[0]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[0]->Fill(ptTrig ,deltaPhi) ; }
if(GetReader()->IsPileUpFromEMCal()) { fhDeltaEtaChargedPileUp[1]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[1]->Fill(ptTrig ,deltaPhi) ; }
if(GetReader()->IsPileUpFromSPDOrEMCal()) { fhDeltaEtaChargedPileUp[2]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[2]->Fill(ptTrig ,deltaPhi) ; }
if(GetReader()->IsPileUpFromEMCalAndNotSPD()) { fhDeltaEtaChargedPileUp[5]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[5]->Fill(ptTrig ,deltaPhi) ; }
if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) { fhDeltaEtaChargedPileUp[6]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPileUp[6]->Fill(ptTrig ,deltaPhi) ; }
-
-
if(ptAssoc > 3 )
{
if(GetReader()->IsPileUpFromSPD()) { fhDeltaEtaChargedPtA3GeVPileUp[0]->Fill(ptTrig ,deltaEta) ; fhDeltaPhiChargedPtA3GeVPileUp[0]->Fill(ptTrig ,deltaPhi) ; }
fhPtTrigChargedBC0->Fill(ptTrig,ptAssoc);
}
+ Int_t vtxBC = GetReader()->GetVertexBC();
+ if(vtxBC == 0 || vtxBC==AliVTrack::kTOFBCNA)
+ {
+ fhXEChargedVtxBC0 ->Fill(ptTrig,xE);
+ fhZTChargedVtxBC0 ->Fill(ptTrig,zT);
+ fhPtTrigChargedVtxBC0->Fill(ptTrig,ptAssoc);
+ }
+
if(GetReader()->IsPileUpFromSPD()) { fhXEChargedPileUp[0]->Fill(ptTrig,xE); fhZTChargedPileUp[0]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[0]->Fill(ptTrig,ptAssoc); }
if(GetReader()->IsPileUpFromEMCal()) { fhXEChargedPileUp[1]->Fill(ptTrig,xE); fhZTChargedPileUp[1]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[1]->Fill(ptTrig,ptAssoc); }
if(GetReader()->IsPileUpFromSPDOrEMCal()) { fhXEChargedPileUp[2]->Fill(ptTrig,xE); fhZTChargedPileUp[2]->Fill(ptTrig,zT); fhPtTrigChargedPileUp[2]->Fill(ptTrig,ptAssoc); }
fhZTUeChargedBC0->Fill(ptTrig,uezT);
}
+ Int_t vtxBC = GetReader()->GetVertexBC();
+ if(vtxBC == 0 || vtxBC==AliVTrack::kTOFBCNA)
+ {
+ fhXEUeChargedVtxBC0->Fill(ptTrig,uexE);
+ fhZTUeChargedVtxBC0->Fill(ptTrig,uezT);
+ }
+
if(GetReader()->IsPileUpFromSPD()) { fhXEUeChargedPileUp[0]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[0]->Fill(ptTrig,uezT);}
if(GetReader()->IsPileUpFromEMCal()) { fhXEUeChargedPileUp[1]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[1]->Fill(ptTrig,uezT);}
if(GetReader()->IsPileUpFromSPDOrEMCal()) { fhXEUeChargedPileUp[2]->Fill(ptTrig,uexE); fhZTUeChargedPileUp[2]->Fill(ptTrig,uezT);}
outputContainer->Add(fhZTUeChargedBC0) ;
outputContainer->Add(fhPtTrigChargedBC0) ;
+ fhPtLeadingVtxBC0 = new TH1F("hPtLeadingVtxBC0","p_{T} distribution of leading particles", nptbins,ptmin,ptmax);
+ fhPtLeadingVtxBC0->SetXTitle("p_{T}^{trig} (GeV/c)");
+
+ fhDeltaPhiChargedVtxBC0 = new TH2F
+ ("hDeltaPhiChargedVtxBC0","#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}, track BC==0",
+ nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
+ fhDeltaPhiChargedVtxBC0->SetYTitle("#Delta #phi (rad)");
+ fhDeltaPhiChargedVtxBC0->SetXTitle("p_{T trigger} (GeV/c)");
+
+ fhDeltaPhiChargedPtA3GeVVtxBC0 = new TH2F
+ ("hDeltaPhiChargedPtA3GeVVtxBC0","#phi_{trigger} - #phi_{h^{#pm}} vs p_{T trigger}, p_{TA}>3 GeV/c, track BC==0",
+ nptbins,ptmin,ptmax, ndeltaphibins ,deltaphimin,deltaphimax);
+ fhDeltaPhiChargedPtA3GeVVtxBC0->SetYTitle("#Delta #phi (rad)");
+ fhDeltaPhiChargedPtA3GeVVtxBC0->SetXTitle("p_{T trigger} (GeV/c)");
+
+ fhPtTrigChargedVtxBC0 =
+ new TH2F("hPtTrigChargedVtxBC0","trigger and charged tracks pt distribution, track BC==0",
+ nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
+ fhPtTrigChargedVtxBC0->SetYTitle("p_{T h^{#pm}} (GeV/c)");
+ fhPtTrigChargedVtxBC0->SetXTitle("p_{T trigger} (GeV/c)");
+
+ fhXEChargedVtxBC0 =
+ new TH2F("hXEChargedVtxBC0","x_{E} for charged tracks, track BC==0",
+ nptbins,ptmin,ptmax,200,0.,2.);
+ fhXEChargedVtxBC0->SetYTitle("x_{E}");
+ fhXEChargedVtxBC0->SetXTitle("p_{T trigger} (GeV/c)");
+
+ fhXEUeChargedVtxBC0 =
+ new TH2F("hXEUeChargedVtxBC0","x_{E} for Underlying Event, track BC==0",
+ nptbins,ptmin,ptmax,200,0.,2.);
+ fhXEUeChargedVtxBC0->SetYTitle("x_{E}");
+ fhXEUeChargedVtxBC0->SetXTitle("p_{T trigger} (GeV/c)");
+
+ fhZTChargedVtxBC0 =
+ new TH2F("hZTChargedVtxBC0","z_{T} for charged tracks, track BC==0",
+ nptbins,ptmin,ptmax,200,0.,2.);
+ fhZTChargedVtxBC0->SetYTitle("z_{T}");
+ fhZTChargedVtxBC0->SetXTitle("p_{T trigger}");
+
+ fhZTUeChargedVtxBC0 =
+ new TH2F("hZTUeChargedVtxBC0","z_{T} for Underlying Event, track BC==0",
+ nptbins,ptmin,ptmax,200,0.,2.);
+ fhZTUeChargedVtxBC0->SetYTitle("z_{T}");
+ fhZTUeChargedVtxBC0->SetXTitle("p_{T trigger} (GeV/c)");
+
+ outputContainer->Add(fhPtLeadingVtxBC0);
+ outputContainer->Add(fhDeltaPhiChargedVtxBC0) ;
+ outputContainer->Add(fhDeltaPhiChargedPtA3GeVVtxBC0) ;
+ outputContainer->Add(fhXEChargedVtxBC0) ;
+ outputContainer->Add(fhXEUeChargedVtxBC0) ;
+ outputContainer->Add(fhZTChargedVtxBC0) ;
+ outputContainer->Add(fhZTUeChargedVtxBC0) ;
+ outputContainer->Add(fhPtTrigChargedVtxBC0) ;
for(Int_t i = 0 ; i < 7 ; i++)
{
if(fFillPileUpHistograms)
{
+ Int_t vtxBC = GetReader()->GetVertexBC();
+ if(vtxBC == 0 || vtxBC==AliVTrack::kTOFBCNA) fhPtLeadingVtxBC0->Fill(pt);
+
if(GetReader()->IsPileUpFromSPD()) fhPtLeadingPileUp[0]->Fill(pt);
if(GetReader()->IsPileUpFromEMCal()) fhPtLeadingPileUp[1]->Fill(pt);
if(GetReader()->IsPileUpFromSPDOrEMCal()) fhPtLeadingPileUp[2]->Fill(pt);
TH1F * fhPtInput; //! pT distribution of trigger particles before selection
TH1F * fhPtFidCut; //! pT distribution of trigger particles before leading selection, after fiducial selection
TH1F * fhPtLeading; //! pT distribution of leading particles
+ TH1F * fhPtLeadingVtxBC0; //! pT distribution of leading particles
TH1F * fhPtLeadingPileUp[7]; //! pT distribution of leading particles
TH2F * fhPtLeadingVzBin; //! pT distribution of leading particles vs vz bin
TH2F * fhPtLeadingBin; //! pT distribution of leading particles, vs mixing bin
TH2F * fhZTUeChargedBC0 ; //! Trigger particle -charged hadron momentum imbalance histogram
TH2F * fhPtTrigChargedBC0 ; //! trigger and correlated particl pt, to be used for mean value for kt
+ TH2F * fhDeltaPhiChargedVtxBC0 ; //! Difference of charged particle phi and trigger particle phi as function of trigger particle pT
+ TH2F * fhDeltaPhiChargedPtA3GeVVtxBC0 ; //! Difference of charged particle phi and trigger particle phi as function of trigger particle pT, pTa > 3 GeV
+ TH2F * fhXEChargedVtxBC0 ; //! Trigger particle -charged hadron momentum imbalance histogram
+ TH2F * fhXEUeChargedVtxBC0 ; //! Trigger particle -charged hadron momentum imbalance histogram
+ TH2F * fhZTChargedVtxBC0 ; //! Trigger particle -charged hadron momentum imbalance histogram
+ TH2F * fhZTUeChargedVtxBC0 ; //! Trigger particle -charged hadron momentum imbalance histogram
+ TH2F * fhPtTrigChargedVtxBC0 ; //! trigger and correlated particl pt, to be used for mean value for kt
+
//if several UE calculation is on, most useful for jet-jet events contribution
TH2F * fhDeltaPhiUeLeftCharged ; //! Difference of charged particle from underlying events phi and trigger particle phi as function of charged particle pT
TH2F * fhDeltaPhiUeRightCharged ; //! Difference of charged particle from underlying events phi and trigger particle phi
AliAnaParticleHadronCorrelation( const AliAnaParticleHadronCorrelation & ph) ; // cpy ctor
AliAnaParticleHadronCorrelation & operator = (const AliAnaParticleHadronCorrelation & ph) ; // cpy assignment
- ClassDef(AliAnaParticleHadronCorrelation,28)
+ ClassDef(AliAnaParticleHadronCorrelation,29)
} ;
fhConeSumPt(0), fhPtInCone(0),
fhPtTrackInCone(0),
fhPtTrackInConeOtherBC(0), fhPtTrackInConeOtherBCPileUpSPD(0),
-fhPtTrackInConeBC0(0), fhPtTrackInConeBC0PileUpSPD(0),
+fhPtTrackInConeBC0(0), fhPtTrackInConeVtxBC0(0),
+fhPtTrackInConeBC0PileUpSPD(0),
fhPtInConePileUp(), fhPtInConeCent(0),
fhFRConeSumPt(0), fhPtInFRCone(0), fhPhiUEConeSumPt(0),
fhEtaUEConeSumPt(0), fhEtaBand(0), fhPhiBand(0),
fhPtTrackInConeBC0->SetXTitle("p_{T} (GeV/c)");
outputContainer->Add(fhPtTrackInConeBC0) ;
+ fhPtTrackInConeVtxBC0 = new TH2F("hPtTrackInConeVtxBC0",
+ Form("p_{T} of tracks in isolation cone for R = %2.2f, TOF from BC==0",r),
+ nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
+ fhPtTrackInConeVtxBC0->SetYTitle("p_{T in cone} (GeV/c)");
+ fhPtTrackInConeVtxBC0->SetXTitle("p_{T} (GeV/c)");
+ outputContainer->Add(fhPtTrackInConeVtxBC0) ;
+
+
fhPtTrackInConeBC0PileUpSPD = new TH2F("hPtTrackInConeBC0PileUpSPD",
Form("p_{T} of tracks in isolation cone for R = %2.2f, TOF from BC==0, pile-up from SPD",r),
nptbins,ptmin,ptmax,nptinconebins,ptinconemin,ptinconemax);
if ( okTOF && trackBC!=0 )fhPtTrackInConeOtherBC->Fill(pt,pTtrack);
else if( okTOF && trackBC==0 )fhPtTrackInConeBC0 ->Fill(pt,pTtrack);
+ Int_t vtxBC = GetReader()->GetVertexBC();
+ if(vtxBC == 0 || vtxBC==AliVTrack::kTOFBCNA) fhPtTrackInConeVtxBC0->Fill(pt,pTtrack);
+
if(GetReader()->IsPileUpFromSPD()) { fhPtInConePileUp[0]->Fill(pt,pTtrack);
if(okTOF && trackBC!=0 ) fhPtTrackInConeOtherBCPileUpSPD->Fill(pt,pTtrack);
if(okTOF && trackBC==0 ) fhPtTrackInConeBC0PileUpSPD ->Fill(pt,pTtrack); }
TH2F * fhPtTrackInConeOtherBC ; //! Track Pt in the cone, tracks out of main BC Time window
TH2F * fhPtTrackInConeOtherBCPileUpSPD ; //! Track Pt in the cone, tracks out of main BC Time window
TH2F * fhPtTrackInConeBC0 ; //! Track Pt in the cone, tracks in BC=0
+ TH2F * fhPtTrackInConeVtxBC0 ; //! Track Pt in the cone, tracks in BC=0
TH2F * fhPtTrackInConeBC0PileUpSPD ; //! Track Pt in the cone, tracks in BC=0
TH2F * fhPtInConePileUp[7] ; //! Particle Pt in the cone, if event is from pile-up (SPD method)
TH2F * fhPtInConeCent ; //! Particle Pt in the cone versus centrality
AliAnaParticleIsolation( const AliAnaParticleIsolation & iso) ; // cpy ctor
AliAnaParticleIsolation & operator = (const AliAnaParticleIsolation & iso) ; // cpy assignment
- ClassDef(AliAnaParticleIsolation,20)
+ ClassDef(AliAnaParticleIsolation,21)
} ;
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff