#include "AliGenCocktailEventHeader.h"
#include "AliInputEventHandler.h"
#include "AliPhysicsSelection.h"
-
+#include "AliTriggerAnalysis.h"
#include "AliAnalysisHelperJetTasks.h"
AliAnalysisTaskJetServices::AliAnalysisTaskJetServices(): AliAnalysisTaskSE(),
fUseAODInput(kFALSE),
fUsePhysicsSelection(kFALSE),
- fRealData(kFALSE),
+ fMC(kFALSE),
+ fSelectionInfoESD(0),
+ fEventCutInfoESD(0),
fAvgTrials(1),
fVtxXMean(0),
fVtxYMean(0),
fVtxZMean(0),
fVtxRCut(1.),
fVtxZCut(8.),
+ fPtMinCosmic(5.),
+ fRIsolMinCosmic(3.),
+ fMaxCosmicAngle(0.01),
fh1Xsec(0x0),
fh1Trials(0x0),
fh1PtHard(0x0),
fh1PtHardTrials(0x0),
+ fh1SelectionInfoESD(0x0),
+ fh1EventCutInfoESD(0),
fh2TriggerCount(0x0),
fh2ESDTriggerCount(0x0),
fh2TriggerVtx(0x0),
fh2ESDTriggerVtx(0x0),
fh2ESDTriggerRun(0x0),
fh2VtxXY(0x0),
+ fh1NCosmicsPerEvent(0x0),
+ fTriggerAnalysis(0x0),
fHistList(0x0)
{
fRunRange[0] = fRunRange[1] = 0;
AliAnalysisTaskSE(name),
fUseAODInput(kFALSE),
fUsePhysicsSelection(kFALSE),
- fRealData(kFALSE),
+ fMC(kFALSE),
+ fSelectionInfoESD(0),
+ fEventCutInfoESD(0),
fAvgTrials(1),
fVtxXMean(0),
fVtxYMean(0),
fVtxZMean(0),
fVtxRCut(1.),
fVtxZCut(8.),
+ fPtMinCosmic(5.),
+ fRIsolMinCosmic(3.),
+ fMaxCosmicAngle(0.01),
fh1Xsec(0x0),
fh1Trials(0x0),
fh1PtHard(0x0),
fh1PtHardTrials(0x0),
+ fh1SelectionInfoESD(0x0),
+ fh1EventCutInfoESD(0),
fh2TriggerCount(0x0),
fh2ESDTriggerCount(0x0),
fh2TriggerVtx(0x0),
fh2ESDTriggerVtx(0x0),
fh2ESDTriggerRun(0x0),
fh2VtxXY(0x0),
+ fh1NCosmicsPerEvent(0x0),
+ fTriggerAnalysis(0x0),
fHistList(0x0)
{
fRunRange[0] = fRunRange[1] = 0;
fHistList->Add(fh1PtHard);
fh1PtHardTrials = new TH1F("fh1PtHardTrials","PYTHIA Pt hard weight with trials;p_{T,hard}",nBinPt,binLimitsPt);
fHistList->Add(fh1PtHardTrials);
+ fh1SelectionInfoESD = new TH1F("fh1SelectionInfoESD","Bit Masks that satisfy the selection info",
+ AliAnalysisHelperJetTasks::kTotalSelections,0.5,AliAnalysisHelperJetTasks::kTotalSelections+0.5);
+ fHistList->Add(fh1SelectionInfoESD);
+
+ fh1EventCutInfoESD = new TH1F("fh1EventCutInfoESD","Bit Masks that for the events after each step of cuts",
+ kTotalEventCuts,0.5,kTotalEventCuts+0.5);
+ fHistList->Add(fh1EventCutInfoESD);
// 3 decisions, 0 trigger X, X + SPD vertex, X + SPD vertex in range
// 3 triggers BB BE/EB EE
if(hn)hn->Sumw2();
}
+ fh1NCosmicsPerEvent = new TH1F("fh1NCosmicsPerEvent","Number of cosmic candidates per event",10,0.,10.);
+ fHistList->Add(fh1NCosmicsPerEvent),
+
TH1::AddDirectory(oldStatus);
}
AliAODEvent *aod = 0;
AliESDEvent *esd = 0;
-
+
AliAnalysisHelperJetTasks::Selected(kTRUE,kFALSE); // set slection to false
+ fSelectionInfoESD = 0; // reset
+ fEventCutInfoESD = 0; // reset
+ AliAnalysisHelperJetTasks::SelectInfo(kTRUE,fSelectionInfoESD); // set slection to false
+
if(fUseAODInput){
aod = dynamic_cast<AliAODEvent*>(InputEvent());
esd = dynamic_cast<AliESDEvent*>(InputEvent());
}
+ fSelectionInfoESD |= kNoEventCut;
+ fEventCutInfoESD |= kNoEventCut;
+
+ Bool_t esdVtxValid = false;
+ Bool_t esdVtxIn = false;
+ Bool_t aodVtxValid = false;
+ Bool_t aodVtxIn = false;
+
if(esd){
+ // trigger analyisis
+ if(!fTriggerAnalysis){
+ fTriggerAnalysis = new AliTriggerAnalysis;
+ fTriggerAnalysis->SetAnalyzeMC(fMC);
+ fTriggerAnalysis->SetSPDGFOThreshhold(1);
+ }
+ // fTriggerAnalysis->FillTriggerClasses(esd);
+ Bool_t v0A = fTriggerAnalysis->IsOfflineTriggerFired(esd, AliTriggerAnalysis::kV0A);
+ Bool_t v0C = fTriggerAnalysis->IsOfflineTriggerFired(esd, AliTriggerAnalysis::kV0C);
+ Bool_t v0ABG = fTriggerAnalysis->IsOfflineTriggerFired(esd, AliTriggerAnalysis::kV0ABG);
+ Bool_t v0CBG = fTriggerAnalysis->IsOfflineTriggerFired(esd, AliTriggerAnalysis::kV0CBG);
+ Bool_t spdFO = fTriggerAnalysis->SPDFiredChips(esd, 0);;
+ if(v0A)fSelectionInfoESD |= AliAnalysisHelperJetTasks::kV0A;
+ if(v0C)fSelectionInfoESD |= AliAnalysisHelperJetTasks::kV0C;
+ if(!(v0ABG||v0CBG))fSelectionInfoESD |= AliAnalysisHelperJetTasks::kNoV0BG;
+ if(spdFO)fSelectionInfoESD |= AliAnalysisHelperJetTasks::kSPDFO;
+
Float_t run = (Float_t)esd->GetRunNumber();
const AliESDVertex *vtxESD = esd->GetPrimaryVertex();
+ esdVtxValid =
+ esdVtxIn = IsVertexIn(vtxESD);
Float_t zvtx = -999;
Float_t xvtx = -999;
Float_t yvtx = -999;
- if(vtxESD->GetNContributors()>0){
+ if(esdVtxValid){
zvtx = vtxESD->GetZ();
yvtx = vtxESD->GetY();
xvtx = vtxESD->GetX();
}
+ // CKB this can be cleaned up a bit...
+
Int_t iTrig = -1;
if(esd->GetFiredTriggerClasses().Contains("CINT1B")
||esd->GetFiredTriggerClasses().Contains("CSMBB")
||esd->GetFiredTriggerClasses().Contains("MB1")
||esd->GetFiredTriggerClasses().Contains("CINT6B")){
iTrig = 0;
+ fSelectionInfoESD |= AliAnalysisHelperJetTasks::kBunchBunch;
}
else if(esd->GetFiredTriggerClasses().Contains("CINT1A")
||esd->GetFiredTriggerClasses().Contains("CSMBA")
||esd->GetFiredTriggerClasses().Contains("CINT6C")){
// empty bunch or bunch empty
iTrig = 1;
+ fSelectionInfoESD |= AliAnalysisHelperJetTasks::kBunchEmpty;
}
- if(esd->GetFiredTriggerClasses().Contains("CINT1-E")
+ else if(esd->GetFiredTriggerClasses().Contains("CINT1-E")
||esd->GetFiredTriggerClasses().Contains("CINT6-E")){
iTrig = 2;
+ fSelectionInfoESD |= AliAnalysisHelperJetTasks::kEmptyEmpty;
}
if(iTrig>=0){
iTrig *= 3;
fh2ESDTriggerRun->Fill(run,iTrig+1);
- if(vtxESD->GetNContributors()>0){
+ if(vtxESD->GetNContributors()>2){
fh2ESDTriggerRun->Fill(run,iTrig+2);
fh2VtxXY->Fill(xvtx,yvtx);
}
yvtx -= fVtxYMean;
zvtx -= fVtxZMean;
Float_t r2 = xvtx *xvtx + yvtx *yvtx;
- if(TMath::Abs(zvtx)<fVtxZCut&&r2<fVtxRCut)fh2ESDTriggerRun->Fill(run,iTrig+3);
+ if(TMath::Abs(zvtx)<fVtxZCut&&r2<(fVtxRCut*fVtxRCut))fh2ESDTriggerRun->Fill(run,iTrig+3);
}
else{
fh2ESDTriggerRun->Fill(run,0);
}
-
-
+ // BKC
}
// Apply additional constraints
- Bool_t esdEventSelected = IsEventSelectedESD(esd);
- Bool_t aodEventSelected = IsEventSelectedAOD(aod);
-
+ Bool_t esdEventSelected = IsEventSelected(esd);
+ Bool_t esdEventPileUp = IsEventPileUp(esd);
+ Bool_t esdEventCosmic = IsEventCosmic(esd);
+
+ Bool_t aodEventSelected = IsEventSelected(aod);
+
+ Bool_t physicsSelection = ((fInputHandler->IsEventSelected())&AliVEvent::kMB);
+ fEventCutInfoESD |= kPhysicsSelectionCut; // other alreay set via IsEventSelected
+ fh1EventCutInfoESD->Fill(fEventCutInfoESD);
+
+ if(esdEventSelected) fSelectionInfoESD |= AliAnalysisHelperJetTasks::kVertexIn;
+ if(esdEventPileUp) fSelectionInfoESD |= AliAnalysisHelperJetTasks::kIsPileUp;
+ if(esdEventCosmic) fSelectionInfoESD |= AliAnalysisHelperJetTasks::kIsCosmic;
+ if(physicsSelection) fSelectionInfoESD |= AliAnalysisHelperJetTasks::kPhysicsSelection;
+
+
+ // here we have all selection information, fill histogram
+ for(unsigned int i = 1;i<(UInt_t)fh1SelectionInfoESD->GetNbinsX();i++){
+ if((i&fSelectionInfoESD)==i)fh1SelectionInfoESD->Fill(i);
+ }
+ AliAnalysisHelperJetTasks::SelectInfo(kTRUE,fSelectionInfoESD);
if(esd&&aod&&fDebug){
if(esdEventSelected&&!aodEventSelected){
Bool_t esdTrig = kFALSE;
esdTrig = AliAnalysisHelperJetTasks::IsTriggerFired(esd,(AliAnalysisHelperJetTasks::Trigger)it);
if(esdTrig)fh2ESDTriggerCount->Fill(it,kAllTriggered);
- Bool_t cand = fInputHandler->IsEventSelected();
+ Bool_t cand = physicsSelection;
if(cand){
fh2ESDTriggerCount->Fill(it,kSelectedALICE);
}
if(!fUsePhysicsSelection)cand = AliAnalysisHelperJetTasks::IsTriggerFired(esd,AliAnalysisHelperJetTasks::kMB1);
- if(vtxESD->GetNContributors()>0&&!vtxName.Contains("TPCVertex")){
+ if(vtxESD->GetNContributors()>2&&!vtxName.Contains("TPCVertex")){
if(esdTrig)fh2ESDTriggerCount->Fill(it,kTriggeredVertex);
Float_t zvtx = vtxESD->GetZ();
if(esdEventSelected&&esdTrig){
fh2ESDTriggerCount->Fill(it,kTriggeredVertexIn);
fh2ESDTriggerVtx->Fill(it,zvtx);
}
+ if(cand)fh2ESDTriggerCount->Fill(it,kSelectedALICEVertexValid);
}
if(cand&&esdEventSelected){
fh2ESDTriggerCount->Fill(it,kSelectedALICEVertexIn);
if(aod){
const AliAODVertex *vtxAOD = aod->GetPrimaryVertex();
- // Printf(">> AODvtx %s %s",vtxAOD->GetName(),vtxAOD->GetTitle());vtxAOD->Print();
- TString vtxTitle(vtxAOD->GetTitle());
+ aodVtxValid = IsVertexValid(vtxAOD);
+ aodVtxIn = IsVertexIn(vtxAOD);
+
for(int it = AliAnalysisHelperJetTasks::kAcceptAll;it < AliAnalysisHelperJetTasks::kTrigger;it++){
Bool_t aodTrig = kFALSE;
aodTrig = AliAnalysisHelperJetTasks::IsTriggerFired(aod,(AliAnalysisHelperJetTasks::Trigger)it);
+ Bool_t cand = aod->GetHeader()->GetOfflineTrigger()&AliVEvent::kMB;
if(aodTrig)fh2TriggerCount->Fill(it,kAllTriggered);
- if(vtxAOD->GetNContributors()>0&&!vtxTitle.Contains("TPCVertex")){
+ if(aodVtxValid){
if(aodTrig)fh2TriggerCount->Fill(it,kTriggeredVertex);
Float_t zvtx = vtxAOD->GetZ();
+ if(cand&&aodEventSelected){
+ fh2TriggerCount->Fill(it,kSelected);
+ }
if(aodTrig&&aodEventSelected){
fh2TriggerVtx->Fill(it,zvtx);
fh2TriggerCount->Fill(it,kTriggeredVertexIn);
}
+ if(cand){
+ fh2TriggerCount->Fill(it,kSelectedALICEVertexValid);
+ if(aodEventSelected)fh2TriggerCount->Fill(it,kSelectedALICEVertexIn);
+ }
}
}
}
PostData(1, fHistList);
}
-Bool_t AliAnalysisTaskJetServices::IsEventSelectedESD(AliESDEvent* esd){
+Bool_t AliAnalysisTaskJetServices::IsEventSelected(const AliESDEvent* esd){
if(!esd)return kFALSE;
const AliESDVertex *vtx = esd->GetPrimaryVertex();
+ return IsVertexIn(vtx); // vertex in calls vertex valid
+}
+
+
+Bool_t AliAnalysisTaskJetServices::IsEventSelected(const AliAODEvent* aod) const {
+ if(!aod)return kFALSE;
+ const AliAODVertex *vtx = aod->GetPrimaryVertex();
+ return IsVertexIn(vtx); // VertexIn calls VertexValid
+}
+
+Bool_t AliAnalysisTaskJetServices::IsVertexValid ( const AliESDVertex* vtx) {
+
// We can check the type of the vertex by its name and title
// if vertexer failed title is empty (default c'tor) and ncontributors is 0
// vtx name title
// Tracks PrimaryVertex VertexerTracksNoConstraint
+ // Tracks PrimaryVertex VertexerTracksWithConstraint
// TPC TPCVertex VertexerTracksNoConstraint
+ // TPC TPCVertex VertexerTracksWithConstraint
// SPD SPDVertex vertexer: 3D
// SPD SPDVertex vertexer: Z
-
-
- if(vtx->GetNContributors()<2)return kFALSE;
+ Int_t nCont = vtx->GetNContributors();
+
+ if(nCont>=1){
+ fEventCutInfoESD |= kContributorsCut1;
+ if(nCont>=2){
+ fEventCutInfoESD |= kContributorsCut2;
+ if(nCont>=3){
+ fEventCutInfoESD |= kContributorsCut3;
+ }
+ }
+ }
+
+ if(nCont<3)return kFALSE;
// do not want tpc only primary vertex
TString vtxName(vtx->GetName());
- if(vtxName.Contains("TPCVertex"))return kFALSE;
- Float_t zvtx = vtx->GetZ();
- Float_t yvtx = vtx->GetY();
- Float_t xvtx = vtx->GetX();
+ if(vtxName.Contains("TPCVertex")){
+ fEventCutInfoESD |= kVertexTPC;
+ return kFALSE;
+ }
+ if(vtxName.Contains("SPDVertex"))fEventCutInfoESD |= kVertexSPD;
+ if(vtxName.Contains("PrimaryVertex"))fEventCutInfoESD |= kVertexGlobal;
- // here we may fill the histos for run dependence....
- xvtx -= fVtxXMean;
- yvtx -= fVtxYMean;
- zvtx -= fVtxZMean;
+ TString vtxTitle(vtx->GetTitle());
+ if(vtxTitle.Contains("vertexer: Z")){
+ if(vtx->GetDispersion()>0.02)return kFALSE;
+ }
+ fEventCutInfoESD |= kSPDDispersionCut;
+ return kTRUE;
+}
- Float_t r2 = yvtx*yvtx+xvtx*xvtx;
- Bool_t eventSel = TMath::Abs(zvtx)<fVtxZCut&&r2<(fVtxRCut*fVtxRCut);
- return eventSel;
-}
+Bool_t AliAnalysisTaskJetServices::IsVertexValid ( const AliAODVertex* vtx) const {
-Bool_t AliAnalysisTaskJetServices::IsEventSelectedAOD(AliAODEvent* aod){
- if(!aod)return kFALSE;
- const AliAODVertex *vtx = aod->GetPrimaryVertex();
// We can check the type of the vertex by its name and title
// if vertexer failed title is empty (default c'tor) and ncontributors is 0
// vtx name title
// SPD SPDVertex vertexer: 3D
// SPD SPDVertex vertexer: Z
-
-
- if(vtx->GetNContributors()<2)return kFALSE;
-
+ if(vtx->GetNContributors()<3)return kFALSE;
// do not want tpc only primary vertex
TString vtxName(vtx->GetName());
if(vtxName.Contains("TPCVertex"))return kFALSE;
+ // no dispersion yet...
+ /*
+ TString vtxTitle(vtx->GetTitle());
+ if(vtxTitle.Contains("vertexer: Z")){
+ if(vtx->GetDispersion()>0.02)return kFALSE;
+ }
+ */
+ return kTRUE;
+}
+
+
+Bool_t AliAnalysisTaskJetServices::IsVertexIn (const AliESDVertex* vtx) {
+
+ if(!IsVertexValid(vtx))return kFALSE;
+
Float_t zvtx = vtx->GetZ();
Float_t yvtx = vtx->GetY();
Float_t xvtx = vtx->GetX();
- // here we may fill the histos for run dependence....
+ xvtx -= fVtxXMean;
+ yvtx -= fVtxYMean;
+ zvtx -= fVtxZMean;
+
+
+
+ if(TMath::Abs(zvtx)>fVtxZCut){
+ return kFALSE;
+ }
+ fEventCutInfoESD |= kVertexZCut;
+ Float_t r2 = yvtx*yvtx+xvtx*xvtx;
+ if(r2>(fVtxRCut*fVtxRCut)){
+ return kFALSE;
+ }
+ fEventCutInfoESD |= kVertexRCut;
+ return kTRUE;
+}
+
+
+Bool_t AliAnalysisTaskJetServices::IsVertexIn (const AliAODVertex* vtx) const {
+
+ if(!IsVertexValid(vtx))return kFALSE;
+
+ Float_t zvtx = vtx->GetZ();
+ Float_t yvtx = vtx->GetY();
+ Float_t xvtx = vtx->GetX();
xvtx -= fVtxXMean;
yvtx -= fVtxYMean;
zvtx -= fVtxZMean;
Float_t r2 = yvtx*yvtx+xvtx*xvtx;
- Bool_t eventSel = TMath::Abs(zvtx)<fVtxZCut&&r2<(fVtxRCut*fVtxRCut);
- return eventSel;
+
+ Bool_t vertexIn = TMath::Abs(zvtx)<fVtxZCut&&r2<(fVtxRCut*fVtxRCut);
+ return vertexIn;
}
+Bool_t AliAnalysisTaskJetServices::IsEventPileUp(const AliESDEvent* esd) const{
+ if(!esd)return kFALSE;
+ return esd->IsPileupFromSPD();
+}
+
+Bool_t AliAnalysisTaskJetServices::IsEventCosmic(const AliESDEvent* esd) const {
+ if(!esd)return kFALSE;
+ // add track cuts for which we look for cosmics...
+
+ Bool_t isCosmic = kFALSE;
+ Int_t nTracks = esd->GetNumberOfTracks();
+ Int_t nCosmicCandidates = 0;
+
+ for (Int_t iTrack1 = 0; iTrack1 < nTracks; iTrack1++) {
+ AliESDtrack* track1 = (AliESDtrack*)esd->GetTrack(iTrack1);
+ if (!track1) continue;
+ UInt_t status1 = track1->GetStatus();
+ //If track is ITS stand alone track, skip the track
+ if (((status1 & AliESDtrack::kITSin) == 0 || (status1 & AliESDtrack::kTPCin))) continue;
+ if(track1->Pt()<fPtMinCosmic) continue;
+ //Start 2nd track loop to look for correlations
+ for (Int_t iTrack2 = iTrack1+1; iTrack2 < nTracks; iTrack2++) {
+ AliESDtrack* track2 = (AliESDtrack*)esd->GetTrack(iTrack2);
+ if(!track2) continue;
+ UInt_t status2 = track2->GetStatus();
+ //If track is ITS stand alone track, skip the track
+ if (((status2 & AliESDtrack::kITSin) == 0 || (status2 & AliESDtrack::kTPCin))) continue;
+ if(track2->Pt()<fPtMinCosmic) continue;
+ //Check if back-to-back
+ Double_t mom1[3],mom2[3];
+ track1->GetPxPyPz(mom1);
+ track2->GetPxPyPz(mom2);
+ TVector3 momv1(mom1[0],mom1[1],mom1[2]);
+ TVector3 momv2(mom2[0],mom2[1],mom2[2]);
+ Float_t theta = (float)(momv1.Phi()-momv2.Phi());
+ if(theta<-0.5*TMath::Pi()) theta+=2.*TMath::Pi();
+
+ Float_t deltaPhi = track1->Phi()-track2->Phi();
+ if(deltaPhi<-0.5*TMath::Pi()) deltaPhi+=2.*TMath::Pi();
+
+ Float_t rIsol = (float)(TMath::Sqrt( deltaPhi*deltaPhi+(track1->Eta()-track2->Eta())*(track1->Eta()-track2->Eta()) ));
+ if(rIsol<fRIsolMinCosmic) continue;
+
+ if(TMath::Abs(TMath::Pi()-theta)<fMaxCosmicAngle) {
+ nCosmicCandidates+=1;
+ isCosmic = kTRUE;
+ }
+
+ }
+ }
+
+ fh1NCosmicsPerEvent->Fill((float)nCosmicCandidates);
+
+ return isCosmic;
+}
+
+
void AliAnalysisTaskJetServices::Terminate(Option_t */*option*/)
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff