#include "TChain.h"
-#include "TTree.h"
+#include "TList.h"
#include "TCanvas.h"
#include "TLorentzVector.h"
#include "TGraphErrors.h"
+#include "TH1F.h"
-#include "AliAnalysisTask.h"
+#include "AliAnalysisTaskSE.h"
#include "AliAnalysisManager.h"
+#include "AliESDVertex.h"
#include "AliESDEvent.h"
#include "AliESDInputHandler.h"
#include "AliAODEvent.h"
//________________________________________________________________________
AliAnalysisTaskBF::AliAnalysisTaskBF(const char *name)
- : AliAnalysisTask(name, ""), fESD(0), fAOD(0), fMC(0), fBalance(0) {
+ : AliAnalysisTaskSE(name),
+ fBalance(0),
+ fList(0),
+ fHistEventStats(0) {
// Constructor
// Define input and output slots here
// Input slot #0 works with a TChain
DefineInput(0, TChain::Class());
// Output slot #0 writes into a TH1 container
- DefineOutput(0, AliBalance::Class());
+ DefineOutput(1, AliBalance::Class());
+ DefineOutput(2, TList::Class());
}
//________________________________________________________________________
-void AliAnalysisTaskBF::ConnectInputData(Option_t *) {
- // Connect ESD or AOD here
+void AliAnalysisTaskBF::UserCreateOutputObjects() {
+ // Create histograms
// Called once
- TString gAnalysisLevel = fBalance->GetAnalysisLevel();
-
- TTree* tree = dynamic_cast<TTree*> (GetInputData(0));
- if (!tree) {
- Printf("ERROR: Could not read chain from input slot 0");
- }
- else {
- if(gAnalysisLevel == "ESD") {
- AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
-
- if (!esdH) {
- Printf("ERROR: Could not get ESDInputHandler");
- }
- else
- fESD = esdH->GetEvent();
- }//ESD
- else if(gAnalysisLevel == "AOD") {
- AliAODInputHandler *aodH = dynamic_cast<AliAODInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
-
- if (!aodH) {
- Printf("ERROR: Could not get AODInputHandler");
- } else
- fAOD = aodH->GetEvent();
- }//AOD
- else if(gAnalysisLevel == "MC") {
- AliMCEventHandler* mcH = dynamic_cast<AliMCEventHandler*> (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
- if (!mcH) {
- Printf("ERROR: Could not retrieve MC event handler");
- }
- else
- fMC = mcH->MCEvent();
- }//MC
- else
- Printf("Wrong analysis type: Only ESD, AOD and MC types are allowed!");
+ if(!fBalance) {
+ fBalance = new AliBalance();
+ fBalance->SetAnalysisLevel("ESD");
+ fBalance->SetAnalysisType(1);
+ fBalance->SetNumberOfBins(18);
+ fBalance->SetInterval(-0.9,0.9);
}
-}
-//________________________________________________________________________
-void AliAnalysisTaskBF::CreateOutputObjects() {
- // Create histograms
- // Called once
-
+ fList = new TList();
+ fList->SetName("listQA");
+
+ TString gCutName[4] = {"Total","Offline trigger",
+ "Vertex","Analyzed"};
+ fHistEventStats = new TH1F("fHistEventStats",
+ "Event statistics;;N_{events}",
+ 4,0.5,4.5);
+ for(Int_t i = 1; i <= 4; i++)
+ fHistEventStats->GetXaxis()->SetBinLabel(i,gCutName[i-1].Data());
+ fList->Add(fHistEventStats);
+
+ // Post output data.
+ PostData(1, fBalance);
+ PostData(2, fList);
}
//________________________________________________________________________
-void AliAnalysisTaskBF::Exec(Option_t *) {
+void AliAnalysisTaskBF::UserExec(Option_t *) {
// Main loop
// Called for each event
TString gAnalysisLevel = fBalance->GetAnalysisLevel();
//ESD analysis
if(gAnalysisLevel == "ESD") {
- if (!fESD) {
- Printf("ERROR: fESD not available");
+ AliESDEvent* gESD = dynamic_cast<AliESDEvent*>(InputEvent()); // from TaskSE
+ if (!gESD) {
+ Printf("ERROR: gESD not available");
return;
}
-
- Printf("There are %d tracks in this event", fESD->GetNumberOfTracks());
- for (Int_t iTracks = 0; iTracks < fESD->GetNumberOfTracks(); iTracks++) {
- AliESDtrack* track = fESD->GetTrack(iTracks);
- if (!track) {
- Printf("ERROR: Could not receive track %d", iTracks);
- continue;
- }
- array->Add(track);
- } //track loop
+
+ fHistEventStats->Fill(1); //all events
+ Bool_t isSelected = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();
+ if(isSelected) {
+ fHistEventStats->Fill(2); //triggered events
+
+ const AliESDVertex *vertex = gESD->GetPrimaryVertex();
+ if(vertex) {
+ fHistEventStats->Fill(3); //events with a proper vertex
+ fHistEventStats->Fill(4); //analayzed events
+
+ Printf("There are %d tracks in this event", gESD->GetNumberOfTracks());
+ for (Int_t iTracks = 0; iTracks < gESD->GetNumberOfTracks(); iTracks++) {
+ AliESDtrack* track = gESD->GetTrack(iTracks);
+ if (!track) {
+ Printf("ERROR: Could not receive track %d", iTracks);
+ continue;
+ }
+ array->Add(track);
+ } //track loop
+ }//vertex object valid
+ }//triggered event
}//ESD analysis
//AOD analysis
else if(gAnalysisLevel == "AOD") {
- if (!fAOD) {
- Printf("ERROR: fAOD not available");
+ AliAODEvent* gAOD = dynamic_cast<AliAODEvent*>(InputEvent()); // from TaskSE
+ if(!gAOD) {
+ Printf("ERROR: gAOD not available");
return;
}
-
- Printf("There are %d tracks in this event", fAOD->GetNumberOfTracks());
- for (Int_t iTracks = 0; iTracks < fAOD->GetNumberOfTracks(); iTracks++) {
- AliAODTrack* track = fAOD->GetTrack(iTracks);
+
+ Printf("There are %d tracks in this event", gAOD->GetNumberOfTracks());
+ for (Int_t iTracks = 0; iTracks < gAOD->GetNumberOfTracks(); iTracks++) {
+ AliAODTrack* track = gAOD->GetTrack(iTracks);
if (!track) {
Printf("ERROR: Could not receive track %d", iTracks);
continue;
}//AOD analysis
//MC analysis
else if(gAnalysisLevel == "MC") {
- if (!fMC) {
- Printf("ERROR: fMC not available");
+
+ AliMCEvent* mcEvent = MCEvent();
+ if (!mcEvent) {
+ Printf("ERROR: mcEvent not available");
return;
}
- Printf("There are %d tracks in this event", fMC->GetNumberOfPrimaries());
- for (Int_t iTracks = 0; iTracks < fMC->GetNumberOfPrimaries(); iTracks++) {
- AliMCParticle* track = dynamic_cast<AliMCParticle *>(fMC->GetTrack(iTracks));
+ Printf("There are %d tracks in this event", mcEvent->GetNumberOfPrimaries());
+ for (Int_t iTracks = 0; iTracks < mcEvent->GetNumberOfPrimaries(); iTracks++) {
+ AliMCParticle* track = dynamic_cast<AliMCParticle *>(mcEvent->GetTrack(iTracks));
if (!track) {
Printf("ERROR: Could not receive particle %d", iTracks);
continue;
fBalance->CalculateBalance(array);
delete array;
-
- // Post output data.
- PostData(0, fBalance);
+
}
//________________________________________________________________________
void AliAnalysisTaskBF::Terminate(Option_t *) {
// Draw result to the screen
// Called once at the end of the query
-
- fBalance = dynamic_cast<AliBalance*> (GetOutputData(0));
+ fBalance = dynamic_cast<AliBalance*> (GetOutputData(1));
if (!fBalance) {
Printf("ERROR: fBalance not available");
return;
// Analysis task for the BF code\r
// Authors: Panos Cristakoglou@cern.ch\r
\r
+class TList;\r
+class TH1F;\r
+\r
class AliBalance;\r
class AliESDEvent;\r
class AliAODEvent;\r
class AliMCEvent;\r
\r
-#include "AliAnalysisTask.h"\r
+#include "AliAnalysisTaskSE.h"\r
\r
-class AliAnalysisTaskBF : public AliAnalysisTask {\r
+class AliAnalysisTaskBF : public AliAnalysisTaskSE {\r
public:\r
AliAnalysisTaskBF(const char *name = "AliAnalysisTaskBF");\r
virtual ~AliAnalysisTaskBF() {}\r
\r
- virtual void ConnectInputData(Option_t *);\r
- virtual void CreateOutputObjects();\r
- virtual void Exec(Option_t *option);\r
+ virtual void UserCreateOutputObjects();\r
+ virtual void UserExec(Option_t *option);\r
virtual void Terminate(Option_t *);\r
\r
void SetAnalysisObject(AliBalance *const analysis) {\r
fBalance = analysis;}\r
\r
private:\r
- AliESDEvent *fESD; //ESD object\r
- AliAODEvent *fAOD; //AOD object\r
- AliMCEvent *fMC; //MC object\r
-\r
AliBalance *fBalance; //BF object\r
- \r
+ TList *fList; //fList object\r
+ TH1F *fHistEventStats; //event stats\r
+\r
AliAnalysisTaskBF(const AliAnalysisTaskBF&); // not implemented\r
AliAnalysisTaskBF& operator=(const AliAnalysisTaskBF&); // not implemented\r
\r
- ClassDef(AliAnalysisTaskBF, 1); // example of analysis\r
+ ClassDef(AliAnalysisTaskBF, 2); // example of analysis\r
};\r
\r
#endif\r
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff