[u/mrichter/AliRoot.git] / PWG3 / dielectron / AliAnalysisTaskMultiDielectron.cxx

/*************************************************************************
* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
*                                                                        *
* Author: The ALICE Off-line Project.                                    *
* Contributors are mentioned in the code where appropriate.              *
*                                                                        *
* Permission to use, copy, modify and distribute this software and its   *
* documentation strictly for non-commercial purposes is hereby granted   *
* without fee, provided that the above copyright notice appears in all   *
* copies and that both the copyright notice and this permission notice   *
* appear in the supporting documentation. The authors make no claims     *
* about the suitability of this software for any purpose. It is          *
* provided "as is" without express or implied warranty.                  *
**************************************************************************/

///////////////////////////////////////////////////////////////////////////
//                                                                       //
//                        Basic Analysis Task                            //
//                                                                       //
///////////////////////////////////////////////////////////////////////////

#include <TChain.h>
#include <TH1D.h>

#include <AliCFContainer.h>
#include <AliInputEventHandler.h>
#include <AliESDInputHandler.h>
#include <AliAODInputHandler.h>
#include <AliAnalysisManager.h>
#include <AliVEvent.h>
#include <AliTriggerAnalysis.h>

#include "AliDielectron.h"
#include "AliDielectronHistos.h"
#include "AliDielectronCF.h"
#include "AliDielectronMC.h"
#include "AliAnalysisTaskMultiDielectron.h"

ClassImp(AliAnalysisTaskMultiDielectron)

//_________________________________________________________________________________
AliAnalysisTaskMultiDielectron::AliAnalysisTaskMultiDielectron() :
  AliAnalysisTaskSE(),
  fListDielectron(),
  fListHistos(),
  fListCF(),
  fSelectPhysics(kFALSE),
  fTriggerMask(AliVEvent::kMB),
  fTriggerOnV0AND(kFALSE),
  fRejectPileup(kFALSE),
  fTriggerAnalysis(0x0),
  fEventFilter(0x0),
  fEventStat(0x0)
{
  //
  // Constructor
  //
}

//_________________________________________________________________________________
AliAnalysisTaskMultiDielectron::AliAnalysisTaskMultiDielectron(const char *name) :
  AliAnalysisTaskSE(name),
  fListDielectron(),
  fListHistos(),
  fListCF(),
  fSelectPhysics(kFALSE),
  fTriggerMask(AliVEvent::kMB),
  fTriggerOnV0AND(kFALSE),
  fRejectPileup(kFALSE),
  fTriggerAnalysis(0x0),
  fEventFilter(0x0),
  fEventStat(0x0)
{
  //
  // Constructor
  //
  DefineInput(0,TChain::Class());
  DefineOutput(1, TList::Class());
  DefineOutput(2, TList::Class());
  DefineOutput(3, TH1D::Class());
  fListHistos.SetName("Dielectron_Histos_Multi");
  fListCF.SetName("Dielectron_CF_Multi");
  fListDielectron.SetOwner();
  fListHistos.SetOwner();
  fListCF.SetOwner();
}


//_________________________________________________________________________________
void AliAnalysisTaskMultiDielectron::UserCreateOutputObjects()
{
  //
  // Add all histogram manager histogram lists to the output TList
  //

  if (!fListHistos.IsEmpty()||!fListCF.IsEmpty()) return; //already initialised

  AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
  Bool_t isESD=man->GetInputEventHandler()->IsA()==AliESDInputHandler::Class();
//   Bool_t isAOD=man->GetInputEventHandler()->IsA()==AliAODInputHandler::Class();
  
  TIter nextDie(&fListDielectron);
  AliDielectron *die=0;
  while ( (die=static_cast<AliDielectron*>(nextDie())) ){
    die->Init();
    if (die->GetHistogramList()) fListHistos.Add(const_cast<THashList*>(die->GetHistogramList()));
    if (die->GetCFManagerPair()) fListCF.Add(const_cast<AliCFContainer*>(die->GetCFManagerPair()->GetContainer()));
  }

  Int_t cuts=fListDielectron.GetEntries();
  Int_t nbins=kNbinsEvent+2*cuts;
  if (!fEventStat){
    fEventStat=new TH1D("hEventStat","Event statistics",nbins,0,nbins);
    fEventStat->GetXaxis()->SetBinLabel(1,"Before Phys. Sel.");
    fEventStat->GetXaxis()->SetBinLabel(2,"After Phys. Sel.");

    //default names
    fEventStat->GetXaxis()->SetBinLabel(3,"Bin3 not used");
    fEventStat->GetXaxis()->SetBinLabel(4,"Bin4 not used");
    fEventStat->GetXaxis()->SetBinLabel(5,"Bin5 not used");
    
    if (fTriggerOnV0AND&&isESD) fEventStat->GetXaxis()->SetBinLabel(3,"V0and triggers");
    if (fEventFilter) fEventStat->GetXaxis()->SetBinLabel(4,"After Event Filter");
    if (fRejectPileup) fEventStat->GetXaxis()->SetBinLabel(5,"After Pileup rejection");
    
    for (Int_t i=0; i<cuts; ++i){
      fEventStat->GetXaxis()->SetBinLabel((kNbinsEvent+1)+2*i,Form("#splitline{1 candidate}{%s}",fListDielectron.At(i)->GetName()));
      fEventStat->GetXaxis()->SetBinLabel((kNbinsEvent+2)+2*i,Form("#splitline{With >1 candidate}{%s}",fListDielectron.At(i)->GetName()));
    }
  }

  if (!fTriggerAnalysis) fTriggerAnalysis=new AliTriggerAnalysis;
  fTriggerAnalysis->EnableHistograms();
  fTriggerAnalysis->SetAnalyzeMC(AliDielectronMC::Instance()->HasMC());
  
  PostData(1, &fListHistos);
  PostData(2, &fListCF);
  PostData(3, fEventStat);
}

//_________________________________________________________________________________
void AliAnalysisTaskMultiDielectron::UserExec(Option_t *)
{
  //
  // Main loop. Called for every event
  //

  if (fListHistos.IsEmpty()&&fListCF.IsEmpty()) return;

  AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
  Bool_t isESD=man->GetInputEventHandler()->IsA()==AliESDInputHandler::Class();
  Bool_t isAOD=man->GetInputEventHandler()->IsA()==AliAODInputHandler::Class();
  
  AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
  if (!inputHandler) return;
  
  if ( inputHandler->GetPIDResponse() ){
    AliDielectronVarManager::SetPIDResponse( inputHandler->GetPIDResponse() );
  } else {
    //load esd pid bethe bloch parameters depending on the existance of the MC handler
    // yes: MC parameters
    // no:  data parameters

    //ESD case
    if (isESD){
      if (!AliDielectronVarManager::GetESDpid()){
        
        if (AliDielectronMC::Instance()->HasMC()) {
          AliDielectronVarManager::InitESDpid();
        } else {
          AliDielectronVarManager::InitESDpid(1);
        }
      }
    }
    //AOD case
    if (isAOD){
      if (!AliDielectronVarManager::GetAODpidUtil()){
        if (AliDielectronMC::Instance()->HasMC()) {
          AliDielectronVarManager::InitAODpidUtil();
        } else {
          AliDielectronVarManager::InitAODpidUtil(1);
        }
      }
    }
  } 
  // Was event selected ?
  UInt_t isSelected = AliVEvent::kAny;
  if( fSelectPhysics && inputHandler && inputHandler->GetEventSelection() ) {
    isSelected = inputHandler->IsEventSelected();
    isSelected&=fTriggerMask;
  }
  
  //Before physics selection
  fEventStat->Fill(kAllEvents);
  if (isSelected==0) {
    PostData(3,fEventStat);
    return;
  }
  //after physics selection
  fEventStat->Fill(kSelectedEvents);

  //V0and
  if (fTriggerOnV0AND&&isESD){
    if (!fTriggerAnalysis->IsOfflineTriggerFired(static_cast<AliESDEvent*>(InputEvent()), AliTriggerAnalysis::kV0AND)) return;
  }
  fEventStat->Fill(kV0andEvents);
  
  //event filter
  if (fEventFilter) {
    if (!fEventFilter->IsSelected(InputEvent())) return;
  }
  fEventStat->Fill(kFilteredEvents);
  
  //pileup
  if (fRejectPileup){
    if (InputEvent()->IsPileupFromSPD(3,0.8,3.,2.,5.)) return;
  }
  fEventStat->Fill(kPileupEvents);
  
  //bz for AliKF
  Double_t bz = InputEvent()->GetMagneticField();
  AliKFParticle::SetField( bz );

  AliDielectronPID::SetCorrVal((Double_t)InputEvent()->GetRunNumber());
  
  //Process event in all AliDielectron instances
  TIter nextDie(&fListDielectron);
  AliDielectron *die=0;
  Int_t idie=0;
  while ( (die=static_cast<AliDielectron*>(nextDie())) ){
    die->Process(InputEvent());
    if (die->HasCandidates()){
      Int_t ncandidates=die->GetPairArray(1)->GetEntriesFast();
      if (ncandidates==1) fEventStat->Fill((kNbinsEvent)+2*idie);
      else if (ncandidates>1) fEventStat->Fill((kNbinsEvent+1)+2*idie);
    }
    ++idie;
  }
  
  PostData(1, &fListHistos);
  PostData(2, &fListCF);
  PostData(3,fEventStat);
}

//_________________________________________________________________________________
void AliAnalysisTaskMultiDielectron::FinishTaskOutput()
{
  //
  // Write debug tree
  //
  TIter nextDie(&fListDielectron);
  AliDielectron *die=0;
  while ( (die=static_cast<AliDielectron*>(nextDie())) ){
    die->SaveDebugTree();
  }
}
Commit	Line	Data
b2a297fa	1	/*************************************************************************
	2	* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	///////////////////////////////////////////////////////////////////////////
	17	// //
	18	// Basic Analysis Task //
	19	// //
	20	///////////////////////////////////////////////////////////////////////////
	21
	22	#include <TChain.h>
61d106d3	23	#include <TH1D.h>
b2a297fa	24
b2a297fa	25	#include <AliCFContainer.h>
572b0139	26	#include <AliInputEventHandler.h>
572b0139	27	#include <AliESDInputHandler.h>
ffbede40	28	#include <AliAODInputHandler.h>
572b0139	29	#include <AliAnalysisManager.h>
b2a297fa	30	#include <AliVEvent.h>
2a14a7b1	31	#include <AliTriggerAnalysis.h>
b2a297fa	32
	33	#include "AliDielectron.h"
	34	#include "AliDielectronHistos.h"
	35	#include "AliDielectronCF.h"
572b0139	36	#include "AliDielectronMC.h"
b2a297fa	37	#include "AliAnalysisTaskMultiDielectron.h"
	38
	39	ClassImp(AliAnalysisTaskMultiDielectron)
	40
	41	//_________________________________________________________________________________
	42	AliAnalysisTaskMultiDielectron::AliAnalysisTaskMultiDielectron() :
	43	AliAnalysisTaskSE(),
	44	fListDielectron(),
	45	fListHistos(),
572b0139	46	fListCF(),
61d106d3	47	fSelectPhysics(kFALSE),
61d106d3	48	fTriggerMask(AliVEvent::kMB),
2a14a7b1	49	fTriggerOnV0AND(kFALSE),
	50	fRejectPileup(kFALSE),
	51	fTriggerAnalysis(0x0),
	52	fEventFilter(0x0),
61d106d3	53	fEventStat(0x0)
b2a297fa	54	{
	55	//
	56	// Constructor
	57	//
	58	}
	59
	60	//_________________________________________________________________________________
	61	AliAnalysisTaskMultiDielectron::AliAnalysisTaskMultiDielectron(const char *name) :
	62	AliAnalysisTaskSE(name),
	63	fListDielectron(),
	64	fListHistos(),
572b0139	65	fListCF(),
61d106d3	66	fSelectPhysics(kFALSE),
61d106d3	67	fTriggerMask(AliVEvent::kMB),
2a14a7b1	68	fTriggerOnV0AND(kFALSE),
	69	fRejectPileup(kFALSE),
	70	fTriggerAnalysis(0x0),
	71	fEventFilter(0x0),
61d106d3	72	fEventStat(0x0)
b2a297fa	73	{
	74	//
	75	// Constructor
	76	//
	77	DefineInput(0,TChain::Class());
	78	DefineOutput(1, TList::Class());
	79	DefineOutput(2, TList::Class());
61d106d3	80	DefineOutput(3, TH1D::Class());
b2a297fa	81	fListHistos.SetName("Dielectron_Histos_Multi");
b2a297fa	82	fListCF.SetName("Dielectron_CF_Multi");
2a14a7b1	83	fListDielectron.SetOwner();
	84	fListHistos.SetOwner();
	85	fListCF.SetOwner();
b2a297fa	86	}
	87
	88
	89	//_________________________________________________________________________________
	90	void AliAnalysisTaskMultiDielectron::UserCreateOutputObjects()
	91	{
	92	//
	93	// Add all histogram manager histogram lists to the output TList
	94	//
	95
572b0139	96	if (!fListHistos.IsEmpty()\|\|!fListCF.IsEmpty()) return; //already initialised
b2a297fa	97
2a14a7b1	98	AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
2a14a7b1	99	Bool_t isESD=man->GetInputEventHandler()->IsA()==AliESDInputHandler::Class();
ffbede40	100	// Bool_t isAOD=man->GetInputEventHandler()->IsA()==AliAODInputHandler::Class();
2a14a7b1	101
b2a297fa	102	TIter nextDie(&fListDielectron);
	103	AliDielectron *die=0;
	104	while ( (die=static_cast<AliDielectron*>(nextDie())) ){
	105	die->Init();
	106	if (die->GetHistogramList()) fListHistos.Add(const_cast<THashList*>(die->GetHistogramList()));
	107	if (die->GetCFManagerPair()) fListCF.Add(const_cast<AliCFContainer*>(die->GetCFManagerPair()->GetContainer()));
	108	}
61d106d3	109
48609e3d	110	Int_t cuts=fListDielectron.GetEntries();
2a14a7b1	111	Int_t nbins=kNbinsEvent+2*cuts;
61d106d3	112	if (!fEventStat){
48609e3d	113	fEventStat=new TH1D("hEventStat","Event statistics",nbins,0,nbins);
61d106d3	114	fEventStat->GetXaxis()->SetBinLabel(1,"Before Phys. Sel.");
61d106d3	115	fEventStat->GetXaxis()->SetBinLabel(2,"After Phys. Sel.");
ba15fdfb	116
	117	//default names
	118	fEventStat->GetXaxis()->SetBinLabel(3,"Bin3 not used");
	119	fEventStat->GetXaxis()->SetBinLabel(4,"Bin4 not used");
	120	fEventStat->GetXaxis()->SetBinLabel(5,"Bin5 not used");
	121
2a14a7b1	122	if (fTriggerOnV0AND&&isESD) fEventStat->GetXaxis()->SetBinLabel(3,"V0and triggers");
	123	if (fEventFilter) fEventStat->GetXaxis()->SetBinLabel(4,"After Event Filter");
	124	if (fRejectPileup) fEventStat->GetXaxis()->SetBinLabel(5,"After Pileup rejection");
	125
48609e3d	126	for (Int_t i=0; i<cuts; ++i){
2a14a7b1	127	fEventStat->GetXaxis()->SetBinLabel((kNbinsEvent+1)+2*i,Form("#splitline{1 candidate}{%s}",fListDielectron.At(i)->GetName()));
2a14a7b1	128	fEventStat->GetXaxis()->SetBinLabel((kNbinsEvent+2)+2*i,Form("#splitline{With >1 candidate}{%s}",fListDielectron.At(i)->GetName()));
48609e3d	129	}
61d106d3	130	}
2a14a7b1	131
	132	if (!fTriggerAnalysis) fTriggerAnalysis=new AliTriggerAnalysis;
	133	fTriggerAnalysis->EnableHistograms();
	134	fTriggerAnalysis->SetAnalyzeMC(AliDielectronMC::Instance()->HasMC());
61d106d3	135
	136	PostData(1, &fListHistos);
	137	PostData(2, &fListCF);
	138	PostData(3, fEventStat);
b2a297fa	139	}
	140
	141	//_________________________________________________________________________________
	142	void AliAnalysisTaskMultiDielectron::UserExec(Option_t *)
	143	{
	144	//
	145	// Main loop. Called for every event
	146	//
	147
572b0139	148	if (fListHistos.IsEmpty()&&fListCF.IsEmpty()) return;
	149
	150	AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
2a14a7b1	151	Bool_t isESD=man->GetInputEventHandler()->IsA()==AliESDInputHandler::Class();
ffbede40	152	Bool_t isAOD=man->GetInputEventHandler()->IsA()==AliAODInputHandler::Class();
ba15fdfb	153
ba15fdfb	154	AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
c8f0f810	155	if (!inputHandler) return;
ba15fdfb	156
	157	if ( inputHandler->GetPIDResponse() ){
	158	AliDielectronVarManager::SetPIDResponse( inputHandler->GetPIDResponse() );
572b0139	159	} else {
	160	//load esd pid bethe bloch parameters depending on the existance of the MC handler
	161	// yes: MC parameters
	162	// no: data parameters
2a14a7b1	163
	164	//ESD case
	165	if (isESD){
	166	if (!AliDielectronVarManager::GetESDpid()){
	167
	168	if (AliDielectronMC::Instance()->HasMC()) {
	169	AliDielectronVarManager::InitESDpid();
	170	} else {
	171	AliDielectronVarManager::InitESDpid(1);
	172	}
	173	}
	174	}
	175	//AOD case
	176	if (isAOD){
	177	if (!AliDielectronVarManager::GetAODpidUtil()){
	178	if (AliDielectronMC::Instance()->HasMC()) {
	179	AliDielectronVarManager::InitAODpidUtil();
	180	} else {
	181	AliDielectronVarManager::InitAODpidUtil(1);
	182	}
572b0139	183	}
	184	}
	185	}
	186	// Was event selected ?
61d106d3	187	UInt_t isSelected = AliVEvent::kAny;
572b0139	188	if( fSelectPhysics && inputHandler && inputHandler->GetEventSelection() ) {
572b0139	189	isSelected = inputHandler->IsEventSelected();
61d106d3	190	isSelected&=fTriggerMask;
572b0139	191	}
572b0139	192
61d106d3	193	//Before physics selection
2a14a7b1	194	fEventStat->Fill(kAllEvents);
61d106d3	195	if (isSelected==0) {
	196	PostData(3,fEventStat);
	197	return;
	198	}
	199	//after physics selection
2a14a7b1	200	fEventStat->Fill(kSelectedEvents);
	201
	202	//V0and
	203	if (fTriggerOnV0AND&&isESD){
	204	if (!fTriggerAnalysis->IsOfflineTriggerFired(static_cast<AliESDEvent*>(InputEvent()), AliTriggerAnalysis::kV0AND)) return;
	205	}
	206	fEventStat->Fill(kV0andEvents);
	207
	208	//event filter
	209	if (fEventFilter) {
	210	if (!fEventFilter->IsSelected(InputEvent())) return;
	211	}
	212	fEventStat->Fill(kFilteredEvents);
	213
	214	//pileup
	215	if (fRejectPileup){
	216	if (InputEvent()->IsPileupFromSPD(3,0.8,3.,2.,5.)) return;
	217	}
	218	fEventStat->Fill(kPileupEvents);
b2a297fa	219
	220	//bz for AliKF
	221	Double_t bz = InputEvent()->GetMagneticField();
	222	AliKFParticle::SetField( bz );
	223
2a14a7b1	224	AliDielectronPID::SetCorrVal((Double_t)InputEvent()->GetRunNumber());
2a14a7b1	225
b2a297fa	226	//Process event in all AliDielectron instances
	227	TIter nextDie(&fListDielectron);
	228	AliDielectron *die=0;
48609e3d	229	Int_t idie=0;
b2a297fa	230	while ( (die=static_cast<AliDielectron*>(nextDie())) ){
b2a297fa	231	die->Process(InputEvent());
48609e3d	232	if (die->HasCandidates()){
48609e3d	233	Int_t ncandidates=die->GetPairArray(1)->GetEntriesFast();
ffbede40	234	if (ncandidates==1) fEventStat->Fill((kNbinsEvent)+2*idie);
ffbede40	235	else if (ncandidates>1) fEventStat->Fill((kNbinsEvent+1)+2*idie);
48609e3d	236	}
48609e3d	237	++idie;
b2a297fa	238	}
	239
	240	PostData(1, &fListHistos);
	241	PostData(2, &fListCF);
61d106d3	242	PostData(3,fEventStat);
b2a297fa	243	}
b2a297fa	244
572b0139	245	//_________________________________________________________________________________
	246	void AliAnalysisTaskMultiDielectron::FinishTaskOutput()
	247	{
	248	//
	249	// Write debug tree
	250	//
	251	TIter nextDie(&fListDielectron);
	252	AliDielectron *die=0;
	253	while ( (die=static_cast<AliDielectron*>(nextDie())) ){
	254	die->SaveDebugTree();
	255	}
	256	}
	257