[u/mrichter/AliRoot.git] / PWG / EMCAL / AliAnalysisTaskEmcal.cxx

// $Id: AliAnalysisTaskEmcal.cxx 56756 2012-05-30 05:03:02Z loizides $
//
// Emcal base analysis task.
//
// Author: S.Aiola

#include "AliAnalysisTaskEmcal.h"

#include <TChain.h>
#include <TClonesArray.h>
#include <TList.h>
#include <TObject.h>

#include "AliAODEvent.h"
#include "AliAnalysisManager.h"
#include "AliCentrality.h"
#include "AliEMCALGeometry.h"
#include "AliESDEvent.h"
#include "AliEmcalParticle.h"
#include "AliEventplane.h"
#include "AliInputEventHandler.h"
#include "AliLog.h"
#include "AliMCParticle.h"
#include "AliVCluster.h"
#include "AliVEventHandler.h"
#include "AliVParticle.h"

ClassImp(AliAnalysisTaskEmcal)

//________________________________________________________________________
AliAnalysisTaskEmcal::AliAnalysisTaskEmcal() : 
  AliAnalysisTaskSE("AliAnalysisTaskEmcal"),
  fAnaType(kTPC),
  fInitialized(kFALSE),
  fCreateHisto(kTRUE),
  fTracksName(),
  fCaloName(),
  fMinCent(-999),
  fMaxCent(-999),
  fMinVz(-999),
  fMaxVz(-999),
  fOffTrigger(AliVEvent::kAny),
  fTrigClass(),
  fNbins(500),
  fMinBinPt(0),
  fMaxBinPt(250),
  fClusPtCut(0.15),
  fTrackPtCut(0.15),
  fMinTrackEta(-0.9),
  fMaxTrackEta(0.9),
  fMinTrackPhi(-10),
  fMaxTrackPhi(10),
  fClusTimeCutLow(-10),
  fClusTimeCutUp(10),
  fTracks(0),
  fCaloClusters(0),
  fCent(0),
  fCentBin(-1),
  fEPV0(-1.0),
  fEPV0A(-1.0),
  fEPV0C(-1.0),
  fNVertCont(0),
  fBeamType(kNA),
  fOutput(0)
{
  // Default constructor.

  fVertex[0] = 0;
  fVertex[1] = 0;
  fVertex[2] = 0;
}

//________________________________________________________________________
AliAnalysisTaskEmcal::AliAnalysisTaskEmcal(const char *name, Bool_t histo) : 
  AliAnalysisTaskSE(name),
  fAnaType(kTPC),
  fInitialized(kFALSE),
  fCreateHisto(histo),
  fTracksName(),
  fCaloName(),
  fMinCent(-999),
  fMaxCent(-999),
  fMinVz(-999),
  fMaxVz(-999),
  fOffTrigger(AliVEvent::kAny),
  fTrigClass(),
  fNbins(500),
  fMinBinPt(0),
  fMaxBinPt(250),
  fClusPtCut(0.15),
  fTrackPtCut(0.15),
  fMinTrackEta(-0.9),
  fMaxTrackEta(0.9),
  fMinTrackPhi(-10),
  fMaxTrackPhi(10),
  fClusTimeCutLow(-10),
  fClusTimeCutUp(10),
  fTracks(0),
  fCaloClusters(0),
  fCent(0),
  fCentBin(-1),
  fEPV0(-1.0),
  fEPV0A(-1.0),
  fEPV0C(-1.0),
  fNVertCont(0),
  fBeamType(kNA),
  fOutput(0)
{
  // Standard constructor.

  fVertex[0] = 0;
  fVertex[1] = 0;
  fVertex[2] = 0;

  if (fCreateHisto) {
    DefineOutput(1, TList::Class()); 
  }
}

//________________________________________________________________________
AliAnalysisTaskEmcal::~AliAnalysisTaskEmcal()
{
  // Destructor
}

//________________________________________________________________________
void AliAnalysisTaskEmcal::UserExec(Option_t *) 
{
  // Main loop, called for each event.

  if (!fInitialized)
    ExecOnce();

  if (!fInitialized)
    return;

  if (!RetrieveEventObjects())
    return;

  if (!IsEventSelected()) 
    return;

  if (!Run())
    return;

  if (!FillHistograms())
    return;
    
  if (fCreateHisto && fOutput) {
    // information for this iteration of the UserExec in the container
    PostData(1, fOutput);
  }
}

//________________________________________________________________________
Bool_t AliAnalysisTaskEmcal::AcceptCluster(AliVCluster *clus, Bool_t acceptMC) const
{
  // Return true if cluster is accepted.

  if (!clus)
    return kFALSE;

  if (!clus->IsEMCAL())
    return kFALSE;

  if (!acceptMC && clus->Chi2() == 100)
    return kFALSE;

  if (clus->GetTOF() > fClusTimeCutUp || clus->GetTOF() < fClusTimeCutLow)
    return kFALSE;

  TLorentzVector nPart;
  clus->GetMomentum(nPart, const_cast<Double_t*>(fVertex));

  if (nPart.Et() < fClusPtCut)
    return kFALSE;

  return kTRUE;
}

//________________________________________________________________________
Bool_t AliAnalysisTaskEmcal::AcceptEmcalPart(AliEmcalParticle *part, Bool_t acceptMC) const
{
  // Return true if EMCal particle is accepted.

  if (!part)
    return kFALSE;

  if (fAnaType == kEMCAL && !part->IsEMCAL())
    return kFALSE;

  if ((part->IsTrack() && part->Pt() < fTrackPtCut) || (part->IsCluster() && part->Pt() < fClusPtCut))
    return kFALSE;

  if (!acceptMC && part->IsMC())
    return kFALSE;

  return kTRUE;
}

//________________________________________________________________________
Bool_t AliAnalysisTaskEmcal::AcceptTrack(AliVTrack *track, Bool_t acceptMC) const
{
  // Return true if track is accepted.

  if (!track)
    return kFALSE;

  if (!acceptMC && track->GetLabel() == 100)
    return kFALSE;

  if (track->Pt() < fTrackPtCut)
    return kFALSE;

  if (track->Eta() < fMinTrackEta || track->Eta() > fMaxTrackEta || 
      track->Phi() < fMinTrackPhi || track->Phi() > fMaxTrackPhi)
    return kFALSE;
  
  return kTRUE;
}

//________________________________________________________________________
void AliAnalysisTaskEmcal::ExecOnce()
{
  // Init the analysis.

  if (!InputEvent()) {
    AliError(Form("%s: Could not retrieve event! Returning!", GetName()));
    return;
  }

  if (!fCaloName.IsNull() && (fAnaType == kEMCAL || fAnaType == kEMCALOnly) && !fCaloClusters) {
    fCaloClusters =  dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fCaloName));
    if (!fCaloClusters) {
      AliError(Form("%s: Could not retrieve clusters %s!", GetName(), fCaloName.Data())); 
      return;
    } else {
      TClass *cl = fCaloClusters->GetClass();
      if (!cl->GetBaseClass("AliVCluster") && !cl->GetBaseClass("AliEmcalParticle")) {
	AliError(Form("%s: Collection %s does not contain AliVCluster nor AliEmcalParticle objects!", GetName(), fCaloName.Data())); 
	fCaloClusters = 0;
	return;
      }
    }
  }

  if (!fTracksName.IsNull() && fAnaType != kEMCALOnly && !fTracks) {
    fTracks = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fTracksName));
    if (!fTracks) {
      AliError(Form("%s: Could not retrieve tracks %s!", GetName(), fTracksName.Data())); 
      return;
    } else {
      TClass *cl = fTracks->GetClass();
      if (!cl->GetBaseClass("AliVParticle") && !cl->GetBaseClass("AliEmcalParticle")) {
	AliError(Form("%s: Collection %s does not contain AliVParticle nor AliEmcalParticle objects!", GetName(), fTracksName.Data())); 
	fTracks = 0;
	return;
      }
    }
  }
  SetInitialized();
}

//_____________________________________________________
AliAnalysisTaskEmcal::BeamType AliAnalysisTaskEmcal::GetBeamType()
{
  // Get beam type : pp-AA-pA
  // ESDs have it directly, AODs get it from hardcoded run number ranges

  AliESDEvent *esd = dynamic_cast<AliESDEvent*>(InputEvent());
  if (esd) {
    const AliESDRun *run = esd->GetESDRun();
    TString beamType = run->GetBeamType();
    if (beamType == "p-p")
      return kpp;
    else if (beamType == "A-A")
      return kAA;
    else if (beamType == "p-A")
      return kpA;
    else
      return kNA;
  } else {
    Int_t runNumber = InputEvent()->GetRunNumber();
    if ((runNumber >= 136851 && runNumber <= 139517) ||  // LHC10h
	(runNumber >= 166529 && runNumber <= 170593))    // LHC11h
    {
      return kAA;
    } else {
      return kpp;
    }
  }  
}

//________________________________________________________________________
Bool_t AliAnalysisTaskEmcal::IsEventSelected()
{
  // Check if event is selected

  if (fOffTrigger != AliVEvent::kAny) {
    UInt_t res = 0;
    const AliESDEvent *eev = dynamic_cast<const AliESDEvent*>(InputEvent());
    if (eev) {
      res = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();
    } else {
      const AliAODEvent *aev = dynamic_cast<const AliAODEvent*>(InputEvent());
      if (aev) {
        res = aev->GetHeader()->GetOfflineTrigger();
      }
    }
    if ((res & fOffTrigger) == 0)
      return kFALSE;
  }

  if (!fTrigClass.IsNull()) {
    TString fired;
    const AliESDEvent *eev = dynamic_cast<const AliESDEvent*>(InputEvent());
    if (eev) {
      fired = eev->GetFiredTriggerClasses();
    } else {
      const AliAODEvent *aev = dynamic_cast<const AliAODEvent*>(InputEvent());
      if (aev) {
        fired = aev->GetFiredTriggerClasses();
      }
    }
    if (!fired.Contains("-B-"))
      return kFALSE;
    TObjArray *arr = fTrigClass.Tokenize("|");
    if (!arr)
      return kFALSE;
    Bool_t match = 0;
    for (Int_t i=0;i<arr->GetEntriesFast();++i) {
      TObject *obj = arr->At(i);
      if (!obj)
        continue;
      if (fired.Contains(obj->GetName())) {
        match = 1;
        break;
      }
    }
    delete arr;
    if (!match)
      return kFALSE;
  }

  if ((fMinCent != -999) && (fMaxCent != -999)) {
    if (fCent<fMinCent)
      return kFALSE;
    if (fCent>fMaxCent)
      return kFALSE;
  }

  if ((fMinVz != -999) && (fMaxVz != -999)) {
    if (fNVertCont == 0 )
      return kFALSE;
    Double_t vz = fVertex[2];
    if (vz<fMinVz)
      return kFALSE;
    if (vz>fMaxVz)
      return kFALSE;
  }

  return kTRUE;
}

//________________________________________________________________________
TClonesArray *AliAnalysisTaskEmcal::GetArrayFromEvent(const char *name, const char *clname)
{
  // Get array from event.

  TClonesArray *arr = 0;
  TString sname(name);
  if (!sname.IsNull()) {
    arr = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(sname));
    if (!arr) {
      AliWarning(Form("%s: Could not retrieve array with name %s!", GetName(), name)); 
      return 0;
    }
  } else {
    return 0;
  }

  if (!clname)
    return arr;

  TString objname(arr->GetClass()->GetName());
  TClass cls(objname);
  if (!cls.InheritsFrom(clname)) {
    AliWarning(Form("%s: Objects of type %s in %s are not inherited from %s!", 
                    GetName(), cls.GetName(), name, clname)); 
    return 0;
  }
  return arr;
}

//________________________________________________________________________
Bool_t AliAnalysisTaskEmcal::RetrieveEventObjects()
{
  // Retrieve objects from event.

  fVertex[0] = 0;
  fVertex[1] = 0;
  fVertex[2] = 0;
  fNVertCont = 0;

  const AliVVertex *vert = InputEvent()->GetPrimaryVertex();
  if (vert) {
    vert->GetXYZ(fVertex);
    fNVertCont = vert->GetNContributors();
  }

  fBeamType = GetBeamType();

  if (fBeamType == kAA) {
    AliCentrality *aliCent = InputEvent()->GetCentrality();
    if (aliCent) {
      fCent = aliCent->GetCentralityPercentile("V0M");
      if      (fCent >=  0 && fCent <   10) fCentBin = 0;
      else if (fCent >= 10 && fCent <   30) fCentBin = 1;
      else if (fCent >= 30 && fCent <   50) fCentBin = 2;
      else if (fCent >= 50 && fCent <= 100) fCentBin = 3; 
      else {
	AliWarning(Form("%s: Negative centrality: %f. Assuming 99", GetName(), fCent));
	fCentBin = 3;
      }
    } else {
      AliWarning(Form("%s: Could not retrieve centrality information! Assuming 99", GetName()));
      fCentBin = 3;
    }
    AliEventplane *aliEP = InputEvent()->GetEventplane();
    if (aliEP) {
      fEPV0  = aliEP->GetEventplane("V0" ,InputEvent());
      fEPV0A = aliEP->GetEventplane("V0A",InputEvent());
      fEPV0C = aliEP->GetEventplane("V0C",InputEvent());
    } else {
      AliWarning(Form("%s: Could not retrieve event plane information!", GetName()));
    }
  } else {
    fCent = 99;
    fCentBin = 0;
  }

  return kTRUE;
}
Commit	Line	Data
2da09763	1	// $Id: AliAnalysisTaskEmcal.cxx 56756 2012-05-30 05:03:02Z loizides $
	2	//
	3	// Emcal base analysis task.
	4	//
	5	// Author: S.Aiola
	6
	7	#include "AliAnalysisTaskEmcal.h"
	8
2da09763	9	#include <TChain.h>
	10	#include <TClonesArray.h>
	11	#include <TList.h>
09ca054b	12	#include <TObject.h>
2da09763	13
d29ed625	14	#include "AliAODEvent.h"
2da09763	15	#include "AliAnalysisManager.h"
2da09763	16	#include "AliCentrality.h"
09ca054b	17	#include "AliEMCALGeometry.h"
09ca054b	18	#include "AliESDEvent.h"
09ca054b	19	#include "AliEmcalParticle.h"
d29ed625	20	#include "AliEventplane.h"
d29ed625	21	#include "AliInputEventHandler.h"
2da09763	22	#include "AliLog.h"
09ca054b	23	#include "AliMCParticle.h"
	24	#include "AliVCluster.h"
	25	#include "AliVEventHandler.h"
	26	#include "AliVParticle.h"
2da09763	27
	28	ClassImp(AliAnalysisTaskEmcal)
	29
	30	//________________________________________________________________________
	31	AliAnalysisTaskEmcal::AliAnalysisTaskEmcal() :
	32	AliAnalysisTaskSE("AliAnalysisTaskEmcal"),
	33	fAnaType(kTPC),
	34	fInitialized(kFALSE),
	35	fCreateHisto(kTRUE),
20f79d37	36	fTracksName(),
20f79d37	37	fCaloName(),
2ac8ca4f	38	fMinCent(-999),
	39	fMaxCent(-999),
	40	fMinVz(-999),
	41	fMaxVz(-999),
	42	fOffTrigger(AliVEvent::kAny),
b4339010	43	fTrigClass(),
2da09763	44	fNbins(500),
	45	fMinBinPt(0),
	46	fMaxBinPt(250),
e44e8726	47	fClusPtCut(0.15),
e44e8726	48	fTrackPtCut(0.15),
9733b37f	49	fMinTrackEta(-0.9),
	50	fMaxTrackEta(0.9),
	51	fMinTrackPhi(-10),
	52	fMaxTrackPhi(10),
8210e4cb	53	fClusTimeCutLow(-10),
8210e4cb	54	fClusTimeCutUp(10),
2da09763	55	fTracks(0),
	56	fCaloClusters(0),
	57	fCent(0),
	58	fCentBin(-1),
3c124212	59	fEPV0(-1.0),
	60	fEPV0A(-1.0),
	61	fEPV0C(-1.0),
b4339010	62	fNVertCont(0),
1f6fff78	63	fBeamType(kNA),
2da09763	64	fOutput(0)
	65	{
	66	// Default constructor.
	67
	68	fVertex[0] = 0;
	69	fVertex[1] = 0;
	70	fVertex[2] = 0;
2da09763	71	}
	72
	73	//________________________________________________________________________
	74	AliAnalysisTaskEmcal::AliAnalysisTaskEmcal(const char *name, Bool_t histo) :
	75	AliAnalysisTaskSE(name),
	76	fAnaType(kTPC),
	77	fInitialized(kFALSE),
	78	fCreateHisto(histo),
20f79d37	79	fTracksName(),
20f79d37	80	fCaloName(),
2ac8ca4f	81	fMinCent(-999),
	82	fMaxCent(-999),
	83	fMinVz(-999),
	84	fMaxVz(-999),
	85	fOffTrigger(AliVEvent::kAny),
b4339010	86	fTrigClass(),
2da09763	87	fNbins(500),
	88	fMinBinPt(0),
	89	fMaxBinPt(250),
e44e8726	90	fClusPtCut(0.15),
e44e8726	91	fTrackPtCut(0.15),
9733b37f	92	fMinTrackEta(-0.9),
	93	fMaxTrackEta(0.9),
	94	fMinTrackPhi(-10),
	95	fMaxTrackPhi(10),
8210e4cb	96	fClusTimeCutLow(-10),
8210e4cb	97	fClusTimeCutUp(10),
2da09763	98	fTracks(0),
	99	fCaloClusters(0),
	100	fCent(0),
	101	fCentBin(-1),
3c124212	102	fEPV0(-1.0),
	103	fEPV0A(-1.0),
	104	fEPV0C(-1.0),
b4339010	105	fNVertCont(0),
1f6fff78	106	fBeamType(kNA),
2da09763	107	fOutput(0)
	108	{
	109	// Standard constructor.
	110
	111	fVertex[0] = 0;
	112	fVertex[1] = 0;
	113	fVertex[2] = 0;
	114
	115	if (fCreateHisto) {
2da09763	116	DefineOutput(1, TList::Class());
	117	}
	118	}
	119
	120	//________________________________________________________________________
	121	AliAnalysisTaskEmcal::~AliAnalysisTaskEmcal()
	122	{
	123	// Destructor
	124	}
	125
	126	//________________________________________________________________________
629c7ac0	127	void AliAnalysisTaskEmcal::UserExec(Option_t *)
	128	{
	129	// Main loop, called for each event.
	130
e44e8726	131	if (!fInitialized)
b3376347	132	ExecOnce();
629c7ac0	133
e44e8726	134	if (!fInitialized)
	135	return;
	136
629c7ac0	137	if (!RetrieveEventObjects())
	138	return;
	139
2ac8ca4f	140	if (!IsEventSelected())
	141	return;
	142
629c7ac0	143	if (!Run())
	144	return;
	145
	146	if (!FillHistograms())
	147	return;
	148
2ac8ca4f	149	if (fCreateHisto && fOutput) {
629c7ac0	150	// information for this iteration of the UserExec in the container
	151	PostData(1, fOutput);
	152	}
	153	}
	154
	155	//________________________________________________________________________
	156	Bool_t AliAnalysisTaskEmcal::AcceptCluster(AliVCluster *clus, Bool_t acceptMC) const
2da09763	157	{
629c7ac0	158	// Return true if cluster is accepted.
	159
	160	if (!clus)
	161	return kFALSE;
	162
	163	if (!clus->IsEMCAL())
	164	return kFALSE;
	165
	166	if (!acceptMC && clus->Chi2() == 100)
	167	return kFALSE;
	168
090a0c3e	169	if (clus->GetTOF() > fClusTimeCutUp \|\| clus->GetTOF() < fClusTimeCutLow)
	170	return kFALSE;
	171
629c7ac0	172	TLorentzVector nPart;
	173	clus->GetMomentum(nPart, const_cast<Double_t*>(fVertex));
	174
e44e8726	175	if (nPart.Et() < fClusPtCut)
629c7ac0	176	return kFALSE;
	177
	178	return kTRUE;
	179	}
	180
	181	//________________________________________________________________________
	182	Bool_t AliAnalysisTaskEmcal::AcceptEmcalPart(AliEmcalParticle *part, Bool_t acceptMC) const
	183	{
	184	// Return true if EMCal particle is accepted.
	185
	186	if (!part)
	187	return kFALSE;
	188
	189	if (fAnaType == kEMCAL && !part->IsEMCAL())
	190	return kFALSE;
	191
e44e8726	192	if ((part->IsTrack() && part->Pt() < fTrackPtCut) \|\| (part->IsCluster() && part->Pt() < fClusPtCut))
629c7ac0	193	return kFALSE;
	194
	195	if (!acceptMC && part->IsMC())
	196	return kFALSE;
	197
	198	return kTRUE;
	199	}
	200
	201	//________________________________________________________________________
	202	Bool_t AliAnalysisTaskEmcal::AcceptTrack(AliVTrack *track, Bool_t acceptMC) const
	203	{
	204	// Return true if track is accepted.
	205
	206	if (!track)
	207	return kFALSE;
	208
	209	if (!acceptMC && track->GetLabel() == 100)
	210	return kFALSE;
	211
e44e8726	212	if (track->Pt() < fTrackPtCut)
629c7ac0	213	return kFALSE;
9733b37f	214
	215	if (track->Eta() < fMinTrackEta \|\| track->Eta() > fMaxTrackEta \|\|
	216	track->Phi() < fMinTrackPhi \|\| track->Phi() > fMaxTrackPhi)
	217	return kFALSE;
629c7ac0	218
629c7ac0	219	return kTRUE;
2da09763	220	}
2da09763	221
629c7ac0	222	//________________________________________________________________________
b3376347	223	void AliAnalysisTaskEmcal::ExecOnce()
8a28ded1	224	{
8a28ded1	225	// Init the analysis.
2ac8ca4f	226
b3376347	227	if (!InputEvent()) {
	228	AliError(Form("%s: Could not retrieve event! Returning!", GetName()));
	229	return;
	230	}
	231
a5621834	232	if (!fCaloName.IsNull() && (fAnaType == kEMCAL \|\| fAnaType == kEMCALOnly) && !fCaloClusters) {
b3376347	233	fCaloClusters = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fCaloName));
	234	if (!fCaloClusters) {
	235	AliError(Form("%s: Could not retrieve clusters %s!", GetName(), fCaloName.Data()));
	236	return;
	237	} else {
	238	TClass *cl = fCaloClusters->GetClass();
	239	if (!cl->GetBaseClass("AliVCluster") && !cl->GetBaseClass("AliEmcalParticle")) {
	240	AliError(Form("%s: Collection %s does not contain AliVCluster nor AliEmcalParticle objects!", GetName(), fCaloName.Data()));
	241	fCaloClusters = 0;
	242	return;
	243	}
	244	}
	245	}
	246
a5621834	247	if (!fTracksName.IsNull() && fAnaType != kEMCALOnly && !fTracks) {
b3376347	248	fTracks = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fTracksName));
	249	if (!fTracks) {
	250	AliError(Form("%s: Could not retrieve tracks %s!", GetName(), fTracksName.Data()));
	251	return;
	252	} else {
	253	TClass *cl = fTracks->GetClass();
	254	if (!cl->GetBaseClass("AliVParticle") && !cl->GetBaseClass("AliEmcalParticle")) {
	255	AliError(Form("%s: Collection %s does not contain AliVParticle nor AliEmcalParticle objects!", GetName(), fTracksName.Data()));
	256	fTracks = 0;
	257	return;
	258	}
	259	}
	260	}
8a28ded1	261	SetInitialized();
	262	}
	263
2ac8ca4f	264	//_____________________________________________________
	265	AliAnalysisTaskEmcal::BeamType AliAnalysisTaskEmcal::GetBeamType()
	266	{
	267	// Get beam type : pp-AA-pA
	268	// ESDs have it directly, AODs get it from hardcoded run number ranges
	269
	270	AliESDEvent esd = dynamic_cast<AliESDEvent>(InputEvent());
	271	if (esd) {
	272	const AliESDRun *run = esd->GetESDRun();
	273	TString beamType = run->GetBeamType();
	274	if (beamType == "p-p")
	275	return kpp;
	276	else if (beamType == "A-A")
	277	return kAA;
	278	else if (beamType == "p-A")
	279	return kpA;
	280	else
	281	return kNA;
	282	} else {
	283	Int_t runNumber = InputEvent()->GetRunNumber();
	284	if ((runNumber >= 136851 && runNumber <= 139517) \|\| // LHC10h
	285	(runNumber >= 166529 && runNumber <= 170593)) // LHC11h
	286	{
	287	return kAA;
	288	} else {
	289	return kpp;
	290	}
	291	}
	292	}
	293
	294	//________________________________________________________________________
d29ed625	295	Bool_t AliAnalysisTaskEmcal::IsEventSelected()
2ac8ca4f	296	{
	297	// Check if event is selected
	298
	299	if (fOffTrigger != AliVEvent::kAny) {
d29ed625	300	UInt_t res = 0;
	301	const AliESDEvent eev = dynamic_cast<const AliESDEvent>(InputEvent());
	302	if (eev) {
	303	res = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();
	304	} else {
	305	const AliAODEvent aev = dynamic_cast<const AliAODEvent>(InputEvent());
	306	if (aev) {
	307	res = aev->GetHeader()->GetOfflineTrigger();
	308	}
	309	}
b4339010	310	if ((res & fOffTrigger) == 0)
	311	return kFALSE;
	312	}
	313
	314	if (!fTrigClass.IsNull()) {
	315	TString fired;
	316	const AliESDEvent eev = dynamic_cast<const AliESDEvent>(InputEvent());
	317	if (eev) {
	318	fired = eev->GetFiredTriggerClasses();
	319	} else {
	320	const AliAODEvent aev = dynamic_cast<const AliAODEvent>(InputEvent());
	321	if (aev) {
	322	fired = aev->GetFiredTriggerClasses();
	323	}
	324	}
	325	if (!fired.Contains("-B-"))
	326	return kFALSE;
	327	TObjArray *arr = fTrigClass.Tokenize("\|");
	328	if (!arr)
	329	return kFALSE;
	330	Bool_t match = 0;
	331	for (Int_t i=0;i<arr->GetEntriesFast();++i) {
	332	TObject *obj = arr->At(i);
	333	if (!obj)
	334	continue;
	335	if (fired.Contains(obj->GetName())) {
	336	match = 1;
	337	break;
	338	}
	339	}
	340	delete arr;
	341	if (!match)
2ac8ca4f	342	return kFALSE;
	343	}
	344
	345	if ((fMinCent != -999) && (fMaxCent != -999)) {
	346	if (fCent<fMinCent)
	347	return kFALSE;
	348	if (fCent>fMaxCent)
	349	return kFALSE;
	350	}
	351
	352	if ((fMinVz != -999) && (fMaxVz != -999)) {
b4339010	353	if (fNVertCont == 0 )
b4339010	354	return kFALSE;
2ac8ca4f	355	Double_t vz = fVertex[2];
	356	if (vz<fMinVz)
	357	return kFALSE;
	358	if (vz>fMaxVz)
	359	return kFALSE;
	360	}
	361
	362	return kTRUE;
	363	}
	364
c596bd28	365	//________________________________________________________________________
	366	TClonesArray AliAnalysisTaskEmcal::GetArrayFromEvent(const char name, const char *clname)
	367	{
	368	// Get array from event.
	369
	370	TClonesArray *arr = 0;
	371	TString sname(name);
	372	if (!sname.IsNull()) {
	373	arr = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(sname));
	374	if (!arr) {
	375	AliWarning(Form("%s: Could not retrieve array with name %s!", GetName(), name));
	376	return 0;
	377	}
af0280a9	378	} else {
af0280a9	379	return 0;
c596bd28	380	}
af0280a9	381
c596bd28	382	if (!clname)
	383	return arr;
	384
	385	TString objname(arr->GetClass()->GetName());
	386	TClass cls(objname);
	387	if (!cls.InheritsFrom(clname)) {
	388	AliWarning(Form("%s: Objects of type %s in %s are not inherited from %s!",
	389	GetName(), cls.GetName(), name, clname));
	390	return 0;
	391	}
	392	return arr;
	393	}
	394
2da09763	395	//________________________________________________________________________
	396	Bool_t AliAnalysisTaskEmcal::RetrieveEventObjects()
	397	{
	398	// Retrieve objects from event.
	399
2da09763	400	fVertex[0] = 0;
	401	fVertex[1] = 0;
	402	fVertex[2] = 0;
b4339010	403	fNVertCont = 0;
	404
	405	const AliVVertex *vert = InputEvent()->GetPrimaryVertex();
	406	if (vert) {
	407	vert->GetXYZ(fVertex);
	408	fNVertCont = vert->GetNContributors();
	409	}
2da09763	410
1f6fff78	411	fBeamType = GetBeamType();
	412
	413	if (fBeamType == kAA) {
2da09763	414	AliCentrality *aliCent = InputEvent()->GetCentrality();
	415	if (aliCent) {
	416	fCent = aliCent->GetCentralityPercentile("V0M");
	417	if (fCent >= 0 && fCent < 10) fCentBin = 0;
	418	else if (fCent >= 10 && fCent < 30) fCentBin = 1;
	419	else if (fCent >= 30 && fCent < 50) fCentBin = 2;
	420	else if (fCent >= 50 && fCent <= 100) fCentBin = 3;
	421	else {
901cc837	422	AliWarning(Form("%s: Negative centrality: %f. Assuming 99", GetName(), fCent));
2da09763	423	fCentBin = 3;
2da09763	424	}
901cc837	425	} else {
901cc837	426	AliWarning(Form("%s: Could not retrieve centrality information! Assuming 99", GetName()));
2da09763	427	fCentBin = 3;
2da09763	428	}
3c124212	429	AliEventplane *aliEP = InputEvent()->GetEventplane();
	430	if (aliEP) {
	431	fEPV0 = aliEP->GetEventplane("V0" ,InputEvent());
	432	fEPV0A = aliEP->GetEventplane("V0A",InputEvent());
	433	fEPV0C = aliEP->GetEventplane("V0C",InputEvent());
	434	} else {
	435	AliWarning(Form("%s: Could not retrieve event plane information!", GetName()));
	436	}
901cc837	437	} else {
2da09763	438	fCent = 99;
	439	fCentBin = 0;
	440	}
	441
2da09763	442	return kTRUE;
2da09763	443	}