From 296dd2625d31e73ab7c9cbd53f19276958b3b973 Mon Sep 17 00:00:00 2001 From: jgrosseo Date: Mon, 14 Dec 2009 16:02:13 +0000 Subject: [PATCH] update of iPhysicsSelection supporting histograms for all trigger types adding new class AliBackgroundSelection (Michele) adding task for event statistics --- PWG0/AliBackgroundSelection.cxx | 225 ++++++++++++++++ PWG0/AliBackgroundSelection.h | 51 ++++ PWG0/AliPhysicsSelection.cxx | 360 +++++++++++++++++--------- PWG0/AliPhysicsSelection.h | 29 ++- PWG0/AliTriggerAnalysis.cxx | 6 + PWG0/AliTriggerAnalysis.h | 3 +- PWG0/PWG0selectorsLinkDef.h | 1 + PWG0/eventStats/AliEventStatsTask.cxx | 119 +++++++++ PWG0/eventStats/AliEventStatsTask.h | 35 +++ PWG0/eventStats/run.C | 162 ++++++++++++ PWG0/libPWG0base.pkg | 2 + PWG0/libPWG0dep.pkg | 3 +- PWG0/libPWG0selectors.pkg | 3 +- 13 files changed, 860 insertions(+), 139 deletions(-) create mode 100644 PWG0/AliBackgroundSelection.cxx create mode 100644 PWG0/AliBackgroundSelection.h create mode 100644 PWG0/eventStats/AliEventStatsTask.cxx create mode 100644 PWG0/eventStats/AliEventStatsTask.h create mode 100644 PWG0/eventStats/run.C diff --git a/PWG0/AliBackgroundSelection.cxx b/PWG0/AliBackgroundSelection.cxx new file mode 100644 index 00000000000..6d6db438ea0 --- /dev/null +++ b/PWG0/AliBackgroundSelection.cxx @@ -0,0 +1,225 @@ +#include "AliBackgroundSelection.h" +#include "TH2F.h" +#include "TList.h" +#include "AliLog.h" +#include "TString.h" +#include "AliESDInputHandlerRP.h" +#include "AliAnalysisManager.h" +#include "TTree.h" +#include "../ITS/AliITSRecPoint.h" +#include "AliMultiplicity.h" + +ClassImp(AliBackgroundSelection) + +AliBackgroundSelection::AliBackgroundSelection(): + AliAnalysisCuts(), fOutputHist(0), fACut(0), fBCut(0) +{ + + + +} + +AliBackgroundSelection::AliBackgroundSelection(const char* name, const char* title): + AliAnalysisCuts(name,title), fOutputHist(0), fACut(0), fBCut(0) +{ + + fOutputHist = new TList(); + fOutputHist->SetOwner(); +} + +AliBackgroundSelection::AliBackgroundSelection(const AliBackgroundSelection& obj) : AliAnalysisCuts(obj), +fOutputHist(0), fACut(0), fBCut(0) +{ + + fOutputHist = obj.fOutputHist; + fACut = obj.fACut; + fBCut = obj.fBCut; + +} + +AliBackgroundSelection::~AliBackgroundSelection() { + if(fOutputHist) delete fOutputHist; + +} + +Bool_t AliBackgroundSelection::IsSelected(TObject* obj){ + + // reset fSelected + SetSelected(kFALSE); + // Get rec points + AliESDInputHandlerRP* handlerRP = dynamic_cast (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()); + if (!handlerRP) + AliFatal("Cannot get the AliESDInputHandlerRP"); + + TTree* itsClusterTree = handlerRP->GetTreeR("ITS"); + if (!itsClusterTree){ + AliError("Cannot get the ITS Cluster tree"); + return kFALSE; + } + // AliFatal("Cannot get the ITS Cluster tree"); + + TClonesArray* itsClusters = new TClonesArray("AliITSRecPoint"); + TBranch* itsClusterBranch=itsClusterTree->GetBranch("ITSRecPoints"); + + itsClusterBranch->SetAddress(&itsClusters); + + Int_t nItsSubs = (Int_t)itsClusterTree->GetEntries(); + + + AliESDEvent * esdEv = (AliESDEvent*) obj; + + // Get # spd clusters and of tracklets + Int_t spdClusters=0; + + + // loop over the its subdetectors + for (Int_t iIts=0; iIts < nItsSubs; iIts++) { + + if (!itsClusterTree->GetEvent(iIts)) + continue; + + Int_t nClusters = itsClusters->GetEntriesFast(); + + // loop over clusters + while (nClusters--) { + AliITSRecPoint* cluster = (AliITSRecPoint*) itsClusters->UncheckedAt(nClusters); + + Int_t layer = cluster->GetLayer(); + + if (layer < 3) { // SPD + spdClusters++; + } + } + } + + const AliMultiplicity* mult = esdEv->GetMultiplicity(); + if (!mult){ + AliFatal("No multiplicity object"); // TODO: Should this be fatal? + } + Int_t ntracklet = mult->GetNumberOfTracklets(); + + Float_t limit = fACut + ntracklet * fBCut; + + if (spdClusters > limit) SetSelected(kFALSE); + else SetSelected(kTRUE ); + + + // Fill control histos for all trigger classes + TString trgClasses = esdEv->GetFiredTriggerClasses(); + TObjArray * tokens = trgClasses.Tokenize(" "); + TIter iter(tokens); + while(TObjString * tok = (TObjString*) iter.Next()){ + TString trg = tok->GetString(); + trg.Strip(TString::kTrailing, ' '); + trg.Strip(TString::kLeading, ' '); + Printf("TRG: [%s]\n",trg.Data()); + TH2F * hCvsT = GetClusterVsTrackletsHisto(trg.Data()); + if(!hCvsT) { + // if histo does not exist, book it on the fly (also books accepted histo) + BookClusterVsTrackletsHisto(trg.Data()); + hCvsT = GetClusterVsTrackletsHisto(trg.Data()); + } + TH2F * hCvsTa = GetClusterVsTrackletsHistoAccepted(trg.Data()); + hCvsT->Fill(ntracklet,spdClusters); + if(Selected()) hCvsTa->Fill(ntracklet,spdClusters); + + } + + // return decision + + return Selected(); +} + + +void AliBackgroundSelection::Init(){ + + fACut = 45; + fBCut = 6.5; + +} + + +void AliBackgroundSelection::BookClusterVsTrackletsHisto(const char * trigger_name){ + + TH2F * h1 = new TH2F(GetClusterVsTrackletsHistoName(trigger_name),trigger_name, 50, -0.5, 49.5, 1000, -0.5, 999.5); + h1->SetXTitle("Tracklets"); + h1->SetYTitle("SPD Clusters"); + AliInfo(Form("Creating histos: %s, all and accepted", GetClusterVsTrackletsHistoName(trigger_name))); + + TH2F * h2 = new TH2F(GetClusterVsTrackletsHistoNameAccepted(trigger_name),TString(trigger_name)+ "(accepted)", + 50, -0.5, 49.5, 1000, -0.5, 999.5); + h2->SetXTitle("Tracklets"); + h2->SetYTitle("SPD Clusters"); + + fOutputHist->Add(h1); + fOutputHist->Add(h2); +} + +TH2F * AliBackgroundSelection::GetClusterVsTrackletsHisto(const char * trigger_name){ + if(!fOutputHist) {AliError("List of histos not initialized");return 0;} + return (TH2F*) fOutputHist->FindObject(GetClusterVsTrackletsHistoName(trigger_name)); + +} + +TH2F * AliBackgroundSelection::GetClusterVsTrackletsHistoAccepted(const char * trigger_name){ + + if(!fOutputHist) {AliError("List of histos not initialized");return 0;} + return (TH2F*) fOutputHist->FindObject(GetClusterVsTrackletsHistoNameAccepted(trigger_name)); + +} + +const char * AliBackgroundSelection::GetClusterVsTrackletsHistoName(const char * trigger_name){ + static TString str; + str = ("h"); + str = str+GetName()+"_"+trigger_name; + return str.Data(); +} + +const char * AliBackgroundSelection::GetClusterVsTrackletsHistoNameAccepted(const char * trigger_name){ + static TString str; + str = ("h"); + str = str+GetName()+"_"+trigger_name + "_accepted"; + return str.Data(); +} + +Long64_t AliBackgroundSelection::Merge(TCollection* list) +{ + // Merge a list of AliBackgroundSelection objects with this (needed for + // PROOF). + // Returns the number of merged objects (including this). + + if (!list) + return 0; + + if (list->IsEmpty()) + return 1; + + TIterator* iter = list->MakeIterator(); + TObject* obj; + + // collections of all histograms + const Int_t nHists = 1; + TList collections[nHists]; + + Int_t count = 0; + while ((obj = iter->Next())) { + + AliBackgroundSelection* entry = dynamic_cast (obj); + if (entry == 0) + continue; + + Int_t n = 0; + collections[n++].Add(entry->fOutputHist); + + count++; + } + + Int_t n = 0; + fOutputHist->Merge(&collections[n++]); + + delete iter; + + return count+1; +} + + diff --git a/PWG0/AliBackgroundSelection.h b/PWG0/AliBackgroundSelection.h new file mode 100644 index 00000000000..7efead22721 --- /dev/null +++ b/PWG0/AliBackgroundSelection.h @@ -0,0 +1,51 @@ +#ifndef ALIBACKGROUNDSELECTION_H +#define ALIBACKGROUNDSELECTION_H + + +// Select events which are not flagged as backgroud +// Author Michele Floris +// michele.floris@cern.ch + +#include +#include "AliAnalysisCuts.h" +#include "AliLog.h" + +class TList; +class TH2F; +class TCollection; + +class AliBackgroundSelection : public AliAnalysisCuts +{ +public: + AliBackgroundSelection(); + AliBackgroundSelection(const char* name, const char* title); + AliBackgroundSelection(const AliBackgroundSelection& obj); + virtual ~AliBackgroundSelection(); + virtual Bool_t IsSelected(TObject* obj); + virtual Bool_t IsSelected(TList* ) {AliFatal("Not implemented");return 0;} + virtual void Init(); + virtual TList * GetOutput() {return fOutputHist;} + + void BookClusterVsTrackletsHisto(const char * trigger_name); + TH2F * GetClusterVsTrackletsHisto(const char * trigger_name); + TH2F * GetClusterVsTrackletsHistoAccepted(const char * trigger_name); + const char * GetClusterVsTrackletsHistoName(const char * trigger_name); + const char * GetClusterVsTrackletsHistoNameAccepted(const char * trigger_name); + Long64_t Merge(TCollection* list); + void SetCutParameters(Float_t a,Float_t b) {fACut = a; fBCut =b;} + Float_t GetCutParameterA(){return fACut;} + Float_t GetCutParameterB(){return fBCut;} + + // TODO: implement cut on global vertex DCA? + +private: + TList * fOutputHist; // contains 2 histo Cluster vs Tracklets per trigger type (all and accepted) + Float_t fACut; // Cut on y = ax + b in the Cluster Vs Tracklets correlation. This is the "a" parameter of the cut + Float_t fBCut; // Cut on y = ax + b in the Cluster Vs Tracklets correlation. This is the "b" parameter of the cut + + AliBackgroundSelection& operator=(const AliBackgroundSelection&); + + ClassDef(AliBackgroundSelection, 1); +}; + +#endif diff --git a/PWG0/AliPhysicsSelection.cxx b/PWG0/AliPhysicsSelection.cxx index 358b2cd1259..db869010a23 100644 --- a/PWG0/AliPhysicsSelection.cxx +++ b/PWG0/AliPhysicsSelection.cxx @@ -45,6 +45,7 @@ #include #include #include +#include #include @@ -56,12 +57,21 @@ ClassImp(AliPhysicsSelection) AliPhysicsSelection::AliPhysicsSelection() : - fTriggerAnalysis(0), + AliAnalysisCuts("AliPhysicsSelection", "AliPhysicsSelection"), + fCurrentRun(-1), + fCollTrigClasses(), + fBGTrigClasses(), + fTriggerAnalysis(), + fBackgroundIdentification(0), fHistStatistics(0), fHistBunchCrossing(0) { // constructor + fCollTrigClasses.SetOwner(1); + fBGTrigClasses.SetOwner(1); + fTriggerAnalysis.SetOwner(1); + AliLog::SetClassDebugLevel("AliPhysicsSelection", AliLog::kWarning); } @@ -69,11 +79,9 @@ AliPhysicsSelection::~AliPhysicsSelection() { // destructor - if (fTriggerAnalysis) - { - delete fTriggerAnalysis; - fTriggerAnalysis = 0; - } + fCollTrigClasses.Delete(); + fBGTrigClasses.Delete(); + fTriggerAnalysis.Delete(); if (fHistStatistics) { @@ -87,14 +95,49 @@ AliPhysicsSelection::~AliPhysicsSelection() fHistBunchCrossing = 0; } } + +Bool_t AliPhysicsSelection::CheckTriggerClass(const AliESDEvent* aEsd, const char* trigger) const +{ + // checks if the given trigger class(es) are found for the current event + // format of trigger: +TRIGGER1 -TRIGGER2 + // requires TRIGGER1 and rejects TRIGGER2 + + TString str(trigger); + TObjArray* tokens = str.Tokenize(" "); + + for (Int_t i=0; i < tokens->GetEntries(); i++) + { + TString str2(((TObjString*) tokens->At(i))->String()); + + if (str2[0] != '+' && str2[0] != '-') + AliFatal(Form("Invalid trigger syntax: %s", trigger)); + + Bool_t flag = (str2[0] == '+'); + + str2.Remove(0, 1); + + if (flag && !aEsd->IsTriggerClassFired(str2)) + { + AliDebug(AliLog::kDebug, Form("Rejecting event because trigger class %s is not present", str2.Data())); + delete tokens; + return kFALSE; + } + if (!flag && aEsd->IsTriggerClassFired(str2)) + { + AliDebug(AliLog::kDebug, Form("Rejecting event because trigger class %s is present", str2.Data())); + delete tokens; + return kFALSE; + } + } + + delete tokens; + return kTRUE; +} Bool_t AliPhysicsSelection::IsCollisionCandidate(const AliESDEvent* aEsd) { // checks if the given event is a collision candidate - if (!fTriggerAnalysis) - AliFatal("Not initialized!"); - const AliESDHeader* esdHeader = aEsd->GetHeader(); if (!esdHeader) { @@ -105,72 +148,93 @@ Bool_t AliPhysicsSelection::IsCollisionCandidate(const AliESDEvent* aEsd) // check event type (should be PHYSICS = 7) if (esdHeader->GetEventType() != 7) return kFALSE; - - fHistStatistics->Fill(1); - - fTriggerAnalysis->FillTriggerClasses(aEsd); - for (Int_t i=0; i < fRequTrigClasses.GetEntries(); i++) + if (fCurrentRun != aEsd->GetRunNumber()) + if (!Initialize(aEsd->GetRunNumber())) + AliFatal(Form("Could not initialize for run %d", aEsd->GetRunNumber())); + + Bool_t accept = kFALSE; + + Int_t count = fCollTrigClasses.GetEntries() + fBGTrigClasses.GetEntries(); + for (Int_t i=0; i < count; i++) { - const char* triggerClass = ((TObjString*) fRequTrigClasses.At(i))->String(); - if (!aEsd->IsTriggerClassFired(triggerClass)) - { - AliDebug(AliLog::kDebug, Form("Rejecting event because trigger class %s is not present", triggerClass)); - return kFALSE; - } - } + const char* triggerClass = 0; + if (i < fCollTrigClasses.GetEntries()) + triggerClass = ((TObjString*) fCollTrigClasses.At(i))->String(); + else + triggerClass = ((TObjString*) fBGTrigClasses.At(i - fCollTrigClasses.GetEntries()))->String(); - for (Int_t i=0; i < fRejTrigClasses.GetEntries(); i++) - { - const char* triggerClass = ((TObjString*) fRejTrigClasses.At(i))->String(); - if (aEsd->IsTriggerClassFired(triggerClass)) - { - AliDebug(AliLog::kDebug, Form("Rejecting event because trigger class %s is present", triggerClass)); - return kFALSE; - } - } + AliDebug(AliLog::kDebug, Form("Processing trigger class %s", triggerClass)); - fTriggerAnalysis->FillHistograms(aEsd); + AliTriggerAnalysis* triggerAnalysis = static_cast (fTriggerAnalysis.At(i)); - fHistStatistics->Fill(2); + triggerAnalysis->FillTriggerClasses(aEsd); - Bool_t fastOR = fTriggerAnalysis->IsOfflineTriggerFired(aEsd, AliTriggerAnalysis::kSPDGFO); - Bool_t v0BB = fTriggerAnalysis->IsOfflineTriggerFired(aEsd, AliTriggerAnalysis::kV0A) || fTriggerAnalysis->IsOfflineTriggerFired(aEsd, AliTriggerAnalysis::kV0C); - Bool_t v0BG = fTriggerAnalysis->IsOfflineTriggerFired(aEsd, AliTriggerAnalysis::kV0ABG) || fTriggerAnalysis->IsOfflineTriggerFired(aEsd, AliTriggerAnalysis::kV0CBG); - - if (fastOR) - fHistStatistics->Fill(3); - if (v0BB) - fHistStatistics->Fill(4); - if (v0BG) - fHistStatistics->Fill(5); + if (CheckTriggerClass(aEsd, triggerClass)) + { + triggerAnalysis->FillHistograms(aEsd); + + fHistStatistics->Fill(1, i); - if (fastOR || v0BB) - fHistStatistics->Fill(6); + Int_t fastOR = triggerAnalysis->SPDFiredChips(aEsd, 0); + Bool_t v0A = triggerAnalysis->IsOfflineTriggerFired(aEsd, AliTriggerAnalysis::kV0A); + Bool_t v0C = triggerAnalysis->IsOfflineTriggerFired(aEsd, AliTriggerAnalysis::kV0C); + Bool_t v0BG = triggerAnalysis->IsOfflineTriggerFired(aEsd, AliTriggerAnalysis::kV0ABG) || triggerAnalysis->IsOfflineTriggerFired(aEsd, AliTriggerAnalysis::kV0CBG); - if (!fastOR && !v0BB) - { - AliDebug(AliLog::kDebug, "Rejecting event because neither FO nor V0 has triggered"); - return kFALSE; - } - - if (v0BG) - { - AliDebug(AliLog::kDebug, "Rejecting event because of V0 BG flag"); - return kFALSE; - } + if (fastOR > 0) + fHistStatistics->Fill(2, i); + if (fastOR > 1) + fHistStatistics->Fill(3, i); + + if (v0A) + fHistStatistics->Fill(4, i); + if (v0C) + fHistStatistics->Fill(5, i); + if (v0BG) + fHistStatistics->Fill(6, i); + + if ((fastOR > 0 || v0A || v0C) && !v0BG) + fHistStatistics->Fill(7, i); + + if (fastOR > 0 && (v0A || v0C) && !v0BG) + fHistStatistics->Fill(8, i); + + if (v0A && v0C && !v0BG) + fHistStatistics->Fill(9, i); + + if (fastOR > 1 || (fastOR > 0 && (v0A || v0C)) || (v0A && v0C)) + { + if (!v0BG) + { + fHistStatistics->Fill(10, i); - fHistStatistics->Fill(7); - - // TODO additional background identification - - fHistStatistics->Fill(9); - - fHistBunchCrossing->Fill(aEsd->GetBunchCrossNumber()); - - AliDebug(AliLog::kDebug, "Accepted event"); + if (fBackgroundIdentification && !fBackgroundIdentification->IsSelected(const_cast (aEsd))) + { + AliDebug(AliLog::kDebug, "Rejecting event because of background identification"); + fHistStatistics->Fill(11, i); + } + else + { + AliDebug(AliLog::kDebug, "Accepted event for histograms"); + + fHistStatistics->Fill(12, i); + fHistBunchCrossing->Fill(aEsd->GetBunchCrossNumber(), i); + if (count < fCollTrigClasses.GetEntries()) + accept = kTRUE; + } + } + else + AliDebug(AliLog::kDebug, "Rejecting event because of V0 BG flag"); + } + else + AliDebug(AliLog::kDebug, "Rejecting event because trigger condition is not fulfilled"); + } + } + + if (accept) + AliDebug(AliLog::kDebug, "Accepted event as collision candidate"); - return kTRUE; + return accept; } Bool_t AliPhysicsSelection::Initialize(UInt_t runNumber) @@ -178,51 +242,72 @@ Bool_t AliPhysicsSelection::Initialize(UInt_t runNumber) // initializes the object for the given run // TODO having the run number here and parameters hardcoded is clearly temporary, a way needs to be found to have a CDB-like configuration also for analysis + if (fCurrentRun != -1) + AliFatal("Processing several runs is not supported, yet"); + AliInfo(Form("Initializing for run %d", runNumber)); + fCurrentRun = runNumber; - fRequTrigClasses.Clear(); - fRejTrigClasses.Clear(); + fTriggerAnalysis.Delete(); + fCollTrigClasses.Delete(); + fBGTrigClasses.Delete(); - fRequTrigClasses.Add(new TObjString("CINT1B-ABCE-NOPF-ALL")); + fCollTrigClasses.Add(new TObjString("+CINT1B-ABCE-NOPF-ALL")); + fBGTrigClasses.Add(new TObjString("+CINT1A-ABCE-NOPF-ALL")); + fBGTrigClasses.Add(new TObjString("+CINT1C-ABCE-NOPF-ALL")); + fBGTrigClasses.Add(new TObjString("+CINT1-E-NOPF-ALL")); - if (!fTriggerAnalysis) + Int_t count = fCollTrigClasses.GetEntries() + fBGTrigClasses.GetEntries(); + + for (Int_t i=0; iEnableHistograms(); - } + AliTriggerAnalysis* triggerAnalysis = new AliTriggerAnalysis; + triggerAnalysis->EnableHistograms(); + triggerAnalysis->SetSPDGFOThreshhold(1); + triggerAnalysis->SetV0TimeOffset(0); - fTriggerAnalysis->SetSPDGFOThreshhold(1); - fTriggerAnalysis->SetV0TimeOffset(0); - - if (runNumber == 104321) - fTriggerAnalysis->SetV0TimeOffset(7.5); + switch (runNumber) + { + case 104316: + case 104320: + case 104321: //OK + case 104439: + triggerAnalysis->SetV0TimeOffset(7.5); + break; + } - if (fHistStatistics) - { - fHistStatistics->Reset(); + fTriggerAnalysis.Add(triggerAnalysis); } - else - { - fHistStatistics = new TH1F("fHistStatistics", "fHistStatistics;;event count", 10, 0.5, 10.5); + + if (fHistStatistics) + delete fHistStatistics; + + fHistStatistics = new TH2F("fHistStatistics", "fHistStatistics;;", 12, 0.5, 12.5, count, -0.5, -0.5 + count); - Int_t n = 1; - fHistStatistics->GetXaxis()->SetBinLabel(n++, "Total"); - fHistStatistics->GetXaxis()->SetBinLabel(n++, "Correct trigger class(es)"); - fHistStatistics->GetXaxis()->SetBinLabel(n++, "FO"); - fHistStatistics->GetXaxis()->SetBinLabel(n++, "V0 BB"); - fHistStatistics->GetXaxis()->SetBinLabel(n++, "V0 BG"); - fHistStatistics->GetXaxis()->SetBinLabel(n++, "FO | V0 BB"); - fHistStatistics->GetXaxis()->SetBinLabel(n++, "(FO | V0 BB) & !V0 BG"); - fHistStatistics->GetXaxis()->SetBinLabel(n++, "Background identification"); - fHistStatistics->GetXaxis()->SetBinLabel(n++, "Accepted"); - } + Int_t n = 1; + fHistStatistics->GetXaxis()->SetBinLabel(n++, "Correct trigger class(es)"); + fHistStatistics->GetXaxis()->SetBinLabel(n++, "FO >= 1"); + fHistStatistics->GetXaxis()->SetBinLabel(n++, "FO >= 2"); + fHistStatistics->GetXaxis()->SetBinLabel(n++, "V0A"); + fHistStatistics->GetXaxis()->SetBinLabel(n++, "V0C"); + fHistStatistics->GetXaxis()->SetBinLabel(n++, "V0 BG"); + fHistStatistics->GetXaxis()->SetBinLabel(n++, "(FO >= 1 | V0A | VOC) & !V0 BG"); + fHistStatistics->GetXaxis()->SetBinLabel(n++, "FO >= 1 & (V0A | VOC) & !V0 BG"); + fHistStatistics->GetXaxis()->SetBinLabel(n++, "V0A & VOC & !V0 BG"); + fHistStatistics->GetXaxis()->SetBinLabel(n++, "(FO >= 2 | (FO >= 1 & (V0A | VOC)) | (V0A & VOC)) & !V0 BG"); + fHistStatistics->GetXaxis()->SetBinLabel(n++, "Background identification"); + fHistStatistics->GetXaxis()->SetBinLabel(n++, "Accepted"); + + n = 1; + for (Int_t i=0; i < fCollTrigClasses.GetEntries(); i++) + fHistStatistics->GetYaxis()->SetBinLabel(n++, ((TObjString*) fCollTrigClasses.At(i))->String()); + for (Int_t i=0; i < fBGTrigClasses.GetEntries(); i++) + fHistStatistics->GetYaxis()->SetBinLabel(n++, ((TObjString*) fBGTrigClasses.At(i))->String()); if (fHistBunchCrossing) - { - fHistBunchCrossing->Reset(); - } - else - fHistBunchCrossing = new TH1F("fHistBunchCrossing", "fHistBunchCrossing;bunch crossing number;accepted events", 4000, -0.5, 3999.5); + delete fHistBunchCrossing; + + fHistBunchCrossing = new TH2F("fHistBunchCrossing", "fHistBunchCrossing;bunch crossing number;", 4000, -0.5, 3999.5, count, -0.5, -0.5 + count); return kTRUE; } @@ -231,33 +316,32 @@ void AliPhysicsSelection::Print(Option_t* /* option */) const { // print the configuration - AliInfo("Configuration:"); + Printf("Configuration:"); - TString str("Required trigger classes: "); - for (Int_t i=0; i < fRequTrigClasses.GetEntries(); i++) - str += ((TObjString*) fRequTrigClasses.At(i))->String() + " "; - AliInfo(str); + Printf("Collision trigger classes:"); + for (Int_t i=0; i < fCollTrigClasses.GetEntries(); i++) + Printf("%s", ((TObjString*) fCollTrigClasses.At(i))->String().Data()); - str = "Rejected trigger classes: "; - for (Int_t i=0; i < fRejTrigClasses.GetEntries(); i++) - str += ((TObjString*) fRejTrigClasses.At(i))->String() + " "; - AliInfo(str); - - AliInfo(Form("Requiring %d FO chips (offline) or V0A or V0C and no V0 BG flag", fTriggerAnalysis->GetSPDGFOThreshhold())); + Printf("Background trigger classes:"); + for (Int_t i=0; i < fBGTrigClasses.GetEntries(); i++) + Printf("%s", ((TObjString*) fBGTrigClasses.At(i))->String().Data()); + + AliTriggerAnalysis* triggerAnalysis = dynamic_cast (fTriggerAnalysis.At(0)); - if (fTriggerAnalysis->GetV0TimeOffset() > 0) - AliInfo(Form("V0 time offset active: %.2f ns", fTriggerAnalysis->GetV0TimeOffset())); + if (triggerAnalysis) + { + if (triggerAnalysis->GetV0TimeOffset() > 0) + Printf("V0 time offset active: %.2f ns", triggerAnalysis->GetV0TimeOffset()); - AliInfo(""); - - AliInfo("Selection statistics:"); + Printf("\nTotal available events:"); - AliInfo("Total available events:"); - fTriggerAnalysis->PrintTriggerClasses(); + triggerAnalysis->PrintTriggerClasses(); + } - AliInfo(Form("Total events: %d", (Int_t) fHistStatistics->GetBinContent(1))); - AliInfo(Form("Correct trigger class: %d", (Int_t) fHistStatistics->GetBinContent(2))); - AliInfo(Form("Selected collision candidates: %d", (Int_t) fHistStatistics->GetBinContent(9))); + Printf("\nSelection statistics for first collision trigger:"); + + Printf("Total events with correct trigger class: %d", (Int_t) fHistStatistics->GetBinContent(1, 1)); + Printf("Selected collision candidates: %d", (Int_t) fHistStatistics->GetBinContent(12, 1)); } Long64_t AliPhysicsSelection::Merge(TCollection* list) @@ -287,17 +371,21 @@ Long64_t AliPhysicsSelection::Merge(TCollection* list) continue; Int_t n = 0; - collections[n++].Add(entry->fTriggerAnalysis); + collections[n++].Add(&(entry->fTriggerAnalysis)); collections[n++].Add(entry->fHistStatistics); collections[n++].Add(entry->fHistBunchCrossing); + if (entry->fBackgroundIdentification) + collections[n++].Add(entry->fBackgroundIdentification); count++; } Int_t n = 0; - fTriggerAnalysis->Merge(&collections[n++]); + fTriggerAnalysis.Merge(&collections[n++]); fHistStatistics->Merge(&collections[n++]); fHistBunchCrossing->Merge(&collections[n++]); + if (fBackgroundIdentification) + fBackgroundIdentification->Merge(&collections[n++]); delete iter; @@ -320,12 +408,32 @@ void AliPhysicsSelection::SaveHistograms(const char* folder) const fHistStatistics->Write(); fHistBunchCrossing->Write(); - gDirectory->mkdir("trigger_histograms"); - gDirectory->cd("trigger_histograms"); + Int_t count = fCollTrigClasses.GetEntries() + fBGTrigClasses.GetEntries(); + for (Int_t i=0; i < count; i++) + { + TString triggerClass = "trigger_histograms_"; + if (i < fCollTrigClasses.GetEntries()) + triggerClass += ((TObjString*) fCollTrigClasses.At(i))->String(); + else + triggerClass += ((TObjString*) fBGTrigClasses.At(i - fCollTrigClasses.GetEntries()))->String(); - fTriggerAnalysis->SaveHistograms(); + gDirectory->mkdir(triggerClass); + gDirectory->cd(triggerClass); - gDirectory->cd(".."); + static_cast (fTriggerAnalysis.At(i))->SaveHistograms(); + + gDirectory->cd(".."); + } + + if (fBackgroundIdentification) + { + gDirectory->mkdir("background_identification"); + gDirectory->cd("background_identification"); + + fBackgroundIdentification->GetOutput()->Write(); + + gDirectory->cd(".."); + } if (folder) gDirectory->cd(".."); diff --git a/PWG0/AliPhysicsSelection.h b/PWG0/AliPhysicsSelection.h index 1e3c643bca8..8e701333dd4 100644 --- a/PWG0/AliPhysicsSelection.h +++ b/PWG0/AliPhysicsSelection.h @@ -15,7 +15,7 @@ // Origin: Jan Fiete Grosse-Oetringhaus, CERN //------------------------------------------------------------------------- -#include +#include #include class AliESDEvent; @@ -24,30 +24,41 @@ class TH2; class TCollection; class AliTriggerAnalysis; -class AliPhysicsSelection : public TObject +class AliPhysicsSelection : public AliAnalysisCuts { public: AliPhysicsSelection(); virtual ~AliPhysicsSelection(); + // AliAnalysisCuts interface + virtual Bool_t IsSelected(TObject* obj) { return IsCollisionCandidate((const AliESDEvent*) obj); } + virtual Bool_t IsSelected(TList*) { return kFALSE; } + Bool_t IsCollisionCandidate(const AliESDEvent* aEsd); Bool_t Initialize(UInt_t runNumber); + void AddBackgroundIdentification(AliAnalysisCuts* background) { fBackgroundIdentification = background; } + virtual void Print(Option_t* option = "") const; virtual Long64_t Merge(TCollection* list); void SaveHistograms(const char* folder = 0) const; - TList* GetRequiredTriggerClasses() { return &fRequTrigClasses; } - TList* GetRejectedTriggerClasses() { return &fRejTrigClasses; } + TList* GetCollisionTriggerClasses() { return &fCollTrigClasses; } + TList* GetBGTriggerClasses() { return &fBGTrigClasses; } protected: - AliTriggerAnalysis* fTriggerAnalysis; // offline trigger object + Bool_t CheckTriggerClass(const AliESDEvent* aEsd, const char* trigger) const; + + Int_t fCurrentRun; // run number for which the object is initialized + TList fCollTrigClasses; // trigger class identifying collision candidates + TList fBGTrigClasses; // trigger classes identifying background events + + TList fTriggerAnalysis; // list of offline trigger objects (several are needed to keep the control histograms separate per trigger class) - TList fRequTrigClasses; // list of trigger class required for collision candidates - TList fRejTrigClasses; // list of trigger classes not allowed for collision candidates + AliAnalysisCuts* fBackgroundIdentification; // class that performs additional background identification - TH1* fHistStatistics; // how many events are cut away why - TH1* fHistBunchCrossing; // histograms of accepted bunch crossing numbers + TH2* fHistStatistics; // how many events are cut away why + TH2* fHistBunchCrossing; // histograms of accepted bunch crossing numbers ClassDef(AliPhysicsSelection, 1) diff --git a/PWG0/AliTriggerAnalysis.cxx b/PWG0/AliTriggerAnalysis.cxx index 650e3642990..e53cdb7d901 100644 --- a/PWG0/AliTriggerAnalysis.cxx +++ b/PWG0/AliTriggerAnalysis.cxx @@ -131,6 +131,10 @@ void AliTriggerAnalysis::EnableHistograms() { // creates the monitoring histograms + // do not add this hists to the directory + Bool_t oldStatus = TH1::AddDirectoryStatus(); + TH1::AddDirectory(kFALSE); + fHistBitsSPD = new TH2F("fHistBitsSPD", "SPD GFO;number of fired chips (offline);number of fired chips (hardware)", 1202, -1.5, 1200.5, 1202, -1.5, 1200.5); fHistFiredBitsSPD = new TH1F("fHistFiredBitsSPD", "SPD GFO Hardware;chip number;events", 1200, -0.5, 1199.5); fHistV0A = new TH1F("fHistV0A", "V0A;leading time (ns);events", 200, 0, 100); @@ -145,6 +149,8 @@ void AliTriggerAnalysis::EnableHistograms() fTriggerClasses = new TMap; fTriggerClasses->SetOwner(); + + TH1::AddDirectory(oldStatus); } //____________________________________________________________________ diff --git a/PWG0/AliTriggerAnalysis.h b/PWG0/AliTriggerAnalysis.h index 5d869b6e1d1..d49f54224bc 100644 --- a/PWG0/AliTriggerAnalysis.h +++ b/PWG0/AliTriggerAnalysis.h @@ -47,6 +47,7 @@ class AliTriggerAnalysis : public TObject Bool_t IsTriggerClassFired(const AliESDEvent* aEsd, const Char_t* tclass) const; // some "raw" trigger functions + Int_t SPDFiredChips(const AliESDEvent* aEsd, Int_t origin, Bool_t fillHists = kFALSE); Bool_t SPDGFOTrigger(const AliESDEvent* aEsd, Int_t origin); V0Decision V0Trigger(const AliESDEvent* aEsd, AliceSide side, Bool_t fillHists = kFALSE); Bool_t ZDCTrigger(const AliESDEvent* aEsd, AliceSide side) const; @@ -77,8 +78,6 @@ class AliTriggerAnalysis : public TObject Bool_t IsL2InputFired(const AliESDEvent* aEsd, UInt_t input) const; Bool_t IsInputFired(const AliESDEvent* aEsd, Char_t level, UInt_t input) const; - Int_t SPDFiredChips(const AliESDEvent* aEsd, Int_t origin, Bool_t fillHists = kFALSE); - Float_t V0CorrectLeadingTime(Int_t i, Float_t time, Float_t adc) const; Int_t FMDHitCombinations(const AliESDEvent* aEsd, AliceSide side, Bool_t fillHists = kFALSE); diff --git a/PWG0/PWG0selectorsLinkDef.h b/PWG0/PWG0selectorsLinkDef.h index 46b92fa81c8..1d522658097 100644 --- a/PWG0/PWG0selectorsLinkDef.h +++ b/PWG0/PWG0selectorsLinkDef.h @@ -17,5 +17,6 @@ #pragma link C++ class AliTriggerTask+; #pragma link C++ class AlidNdEtaTask+; #pragma link C++ class AlidNdEtaCorrectionTask+; +#pragma link C++ class AliEventStatsTask+; #endif diff --git a/PWG0/eventStats/AliEventStatsTask.cxx b/PWG0/eventStats/AliEventStatsTask.cxx new file mode 100644 index 00000000000..3a9b6b05f06 --- /dev/null +++ b/PWG0/eventStats/AliEventStatsTask.cxx @@ -0,0 +1,119 @@ +/* $Id: AliEventStatsTask.cxx 35782 2009-10-22 11:54:31Z jgrosseo $ */ + +#include "AliEventStatsTask.h" + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include "AliPhysicsSelection.h" +#include "AliBackgroundSelection.h" + +ClassImp(AliEventStatsTask) + +AliEventStatsTask::AliEventStatsTask(const char* opt) : + AliAnalysisTaskSE("AliEventStatsTask"), + fOutput(0), + fOption(opt), + fPhysicsSelection(0) +{ + // + // Constructor. Initialization of pointers + // + + // Define input and output slots here + DefineOutput(1, TList::Class()); + + AliLog::SetClassDebugLevel("AliEventStatsTask", AliLog::kWarning); +} + +AliEventStatsTask::~AliEventStatsTask() +{ + // + // Destructor + // + + // histograms are in the output list and deleted when the output + // list is deleted by the TSelector dtor + + if (fOutput) { + delete fOutput; + fOutput = 0; + } +} + +void AliEventStatsTask::UserCreateOutputObjects() +{ + // create result objects and add to output list + + Printf("AliEventStatsTask::CreateOutputObjects"); + + fOutput = new TList; + fOutput->SetOwner(); + + fPhysicsSelection = new AliPhysicsSelection; + AliBackgroundSelection* background = new AliBackgroundSelection("AliBackgroundSelection", "AliBackgroundSelection"); + background->Init(); + //fPhysicsSelection->AddBackgroundIdentification(background); + //AliLog::SetClassDebugLevel("AliPhysicsSelection", AliLog::kDebug); + + fOutput->Add(fPhysicsSelection); +} + +void AliEventStatsTask::UserExec(Option_t*) +{ + // process the event + + // post the data already here + PostData(1, fOutput); + + AliESDEvent* esd = dynamic_cast (InputEvent()); + + if (!esd) + { + AliError("ESD branch not available"); + return; + } + + fPhysicsSelection->IsCollisionCandidate(esd); +} + +void AliEventStatsTask::Terminate(Option_t *) +{ + // The Terminate() function is the last function to be called during + // a query. It always runs on the client, it can be used to present + // the results graphically or save the results to file. + + fOutput = dynamic_cast (GetOutputData(1)); + if (!fOutput) + Printf("ERROR: fOutput not available"); + + if (fOutput) + { + fPhysicsSelection = dynamic_cast (fOutput->FindObject("AliPhysicsSelection")); + } + + TFile* fout = new TFile("event_stat.root", "RECREATE"); + + if (fPhysicsSelection) + { + fPhysicsSelection->Print(); + fPhysicsSelection->SaveHistograms("physics_selection"); + } + + fout->Write(); + fout->Close(); + + Printf("Writting result to event_stat.root"); +} diff --git a/PWG0/eventStats/AliEventStatsTask.h b/PWG0/eventStats/AliEventStatsTask.h new file mode 100644 index 00000000000..6d9872711bf --- /dev/null +++ b/PWG0/eventStats/AliEventStatsTask.h @@ -0,0 +1,35 @@ +/* $Id: AliEventStatsTask.h 35782 2009-10-22 11:54:31Z jgrosseo $ */ + +#ifndef ALIEVENTSTATSTASK_H +#define ALIEVENTSTATSTASK_H + +#include "AliAnalysisTaskSE.h" + +class AliPhysicsSelection; + +class AliEventStatsTask : public AliAnalysisTaskSE { + public: + AliEventStatsTask(const char* opt = ""); + virtual ~AliEventStatsTask(); + + virtual void UserCreateOutputObjects(); + virtual void UserExec(Option_t*); + virtual void Terminate(Option_t*); + + void SetOption(const char* opt) { fOption = opt; } + + protected: + TList* fOutput; //! list send on output slot 1 + + TString fOption; // option string + + AliPhysicsSelection* fPhysicsSelection; //! event selection class + + private: + AliEventStatsTask(const AliEventStatsTask&); + AliEventStatsTask& operator=(const AliEventStatsTask&); + + ClassDef(AliEventStatsTask, 1); +}; + +#endif diff --git a/PWG0/eventStats/run.C b/PWG0/eventStats/run.C new file mode 100644 index 00000000000..f91357824cd --- /dev/null +++ b/PWG0/eventStats/run.C @@ -0,0 +1,162 @@ +void Load(const char* taskName, Bool_t debug) +{ + TString compileTaskName; + compileTaskName.Form("%s.cxx++", taskName); + if (debug) + compileTaskName += "g"; + + if (gProof) { + gProof->Load(compileTaskName); + } else + gROOT->Macro(compileTaskName); + + // Enable debug printouts + if (debug) + { + AliLog::SetClassDebugLevel(taskName, AliLog::kDebug+2); + } + else + AliLog::SetClassDebugLevel(taskName, AliLog::kWarning); +} + +void run(const Char_t* data, Int_t nRuns=20, Int_t offset=0, Bool_t aDebug = kFALSE, Int_t aProof = kFALSE, const char* option = "") +{ + // aProof option: 0 no proof + // 1 proof with chain + // 2 proof with dataset + // + // option is passed to the task(s) + + if (nRuns < 0) + nRuns = 1234567890; + + if (aProof > 0) + { + TProof::Open("alicecaf"); + //gProof->SetParallel(2); + + // Enable the needed package + if (1) + { + gProof->UploadPackage("$ALICE_ROOT/STEERBase"); + gProof->EnablePackage("$ALICE_ROOT/STEERBase"); + gProof->UploadPackage("$ALICE_ROOT/ESD"); + gProof->EnablePackage("$ALICE_ROOT/ESD"); + gProof->UploadPackage("$ALICE_ROOT/AOD"); + gProof->EnablePackage("$ALICE_ROOT/AOD"); + gProof->UploadPackage("$ALICE_ROOT/ANALYSIS"); + gProof->EnablePackage("$ALICE_ROOT/ANALYSIS"); + gProof->UploadPackage("$ALICE_ROOT/ANALYSISalice"); + gProof->EnablePackage("$ALICE_ROOT/ANALYSISalice"); + } + else + { + gProof->UploadPackage("$ALICE_ROOT/AF-v4-18-12-AN.par"); + gProof->EnablePackage("AF-v4-18-12-AN"); + } + + gProof->UploadPackage("$ALICE_ROOT/PWG0base"); + gProof->EnablePackage("$ALICE_ROOT/PWG0base"); + } + else + { + gSystem->AddIncludePath("-I${ALICE_ROOT}/include/ -I${ALICE_ROOT}/PWG0/ -I${ALICE_ROOT}/PWG0/dNdEta/"); + gSystem->Load("libVMC"); + gSystem->Load("libTree"); + gSystem->Load("libProof"); + gSystem->Load("libSTEERBase"); + gSystem->Load("libESD"); + gSystem->Load("libAOD"); + gSystem->Load("libANALYSIS"); + gSystem->Load("libANALYSISalice"); + gSystem->Load("libPWG0base"); + gSystem->Load("libPWG0dep"); + } + + // Create the analysis manager + mgr = new AliAnalysisManager; + + // Add ESD handler + AliESDInputHandler* esdH = new AliESDInputHandler; + esdH->SetInactiveBranches("AliRawDataErrorLogs CaloClusters Cascades EMCALCells EMCALTrigger ESDfriend Kinks Kinks Cascades AliESDTZERO MuonTracks TrdTracks CaloClusters"); + mgr->SetInputEventHandler(esdH); + + cInput = mgr->GetCommonInputContainer(); + + Load("AliEventStatsTask", aDebug); + TString optStr(option); + + // remove SAVE option if set + Bool_t save = kFALSE; + if (optStr.Contains("SAVE")) + { + optStr = optStr(0,optStr.Index("SAVE")) + optStr(optStr.Index("SAVE")+4, optStr.Length()); + save = kTRUE; + } + + task = new AliEventStatsTask(optStr); + + mgr->AddTask(task); + + // Attach input + mgr->ConnectInput(task, 0, cInput); + + // Attach output + cOutput = mgr->CreateContainer("cOutput", TList::Class(), AliAnalysisManager::kOutputContainer); + mgr->ConnectOutput(task, 1, cOutput); + + // Enable debug printouts + if (aDebug) + mgr->SetDebugLevel(2); + + // Run analysis + mgr->InitAnalysis(); + mgr->PrintStatus(); + + if (aProof == 2) + { + // process dataset + + mgr->StartAnalysis("proof", data, nRuns, offset); + + if (save) + { + TString path("maps/"); + path += TString(data).Tokenize("/")->Last()->GetName(); + + gSystem->mkdir(path, kTRUE); + gSystem->Rename("event_stats.root", path + "/event_stats.root"); + + Printf(">>>>> Moved files to %s", path.Data()); + } + } + else if (aProof == 3) + { + gROOT->ProcessLine(".L CreateChainFromDataSet.C"); + ds = gProof->GetDataSet(data)->GetStagedSubset(); + file = TFile::Open("dataset.root", "RECREATE"); + ds->Write("dataset"); + file->Close(); + chain = CreateChainFromDataSet(ds); + mgr->StartAnalysis("local", chain, nRuns, offset); + } + else if (aProof == -1) + { + gROOT->ProcessLine(".L CreateChainFromDataSet.C"); + TFile::Open("dataset.root"); + ds = (TFileCollection*) gFile->Get("dataset"); + chain = CreateChainFromDataSet(ds); + mgr->StartAnalysis("local", chain, nRuns, offset); + } + else + { + // Create chain of input files + gROOT->LoadMacro("../CreateESDChain.C"); + + chain = CreateESDChain(data, nRuns, offset); + //chain = CreateChain("TE", data, nRuns, offset); + + mgr->StartAnalysis((aProof > 0) ? "proof" : "local", chain); + } + +} diff --git a/PWG0/libPWG0base.pkg b/PWG0/libPWG0base.pkg index a114d4cbed4..b4040cf761f 100644 --- a/PWG0/libPWG0base.pkg +++ b/PWG0/libPWG0base.pkg @@ -25,3 +25,5 @@ PACKSOFLAGS:= $(SOFLAGS) -L$(ALICE_ROOT)/lib/tgt_$(ALICE_TARGET) -lSTEERBase \ -lESD -lANALYSIS \ -L$(ROOTLIBDIR) -lEG endif + +EXPORT=AliPhysicsSelection.h AliTriggerAnalysis.h AliUnfolding.h \ No newline at end of file diff --git a/PWG0/libPWG0dep.pkg b/PWG0/libPWG0dep.pkg index 7e4f846679b..b60c3c77ba2 100644 --- a/PWG0/libPWG0dep.pkg +++ b/PWG0/libPWG0dep.pkg @@ -13,7 +13,8 @@ SRCS = TPC/AliTPCClusterHistograms.cxx \ dNdPt/AlidNdPtEventCuts.cxx \ dNdPt/AlidNdPt.cxx \ dNdPt/AlidNdPtCutAnalysis.cxx \ - dNdPt/AlidNdPtTask.cxx + dNdPt/AlidNdPtTask.cxx \ + AliBackgroundSelection.cxx HDRS = $(SRCS:.cxx=.h) diff --git a/PWG0/libPWG0selectors.pkg b/PWG0/libPWG0selectors.pkg index 9f09967f2c4..221657edeba 100644 --- a/PWG0/libPWG0selectors.pkg +++ b/PWG0/libPWG0selectors.pkg @@ -13,7 +13,8 @@ SRCS = dNdEta/AlidNdEtaTask.cxx \ highMultiplicity/AliHighMultiplicitySelector.cxx \ multiplicity/AliMultiplicityTask.cxx \ esdTrackCuts/AliCutTask.cxx \ - trigger/AliTriggerTask.cxx + trigger/AliTriggerTask.cxx \ + eventStats/AliEventStatsTask.cxx HDRS = $(SRCS:.cxx=.h) -- 2.39.3