ROOT logo
AliRoot » PWGJE » EMCALJETTASKS » USERTASKS » AliAnalysisTaskJetV2

class AliAnalysisTaskJetV2: public AliAnalysisTaskEmcalJet

Function Members (Methods)

public:
AliAnalysisTaskJetV2()
AliAnalysisTaskJetV2(const char* name, AliAnalysisTaskJetV2::runModeType type)
virtual~AliAnalysisTaskJetV2()
virtual voidTTask::Abort()MENU
voidTObject::AbstractMethod(const char* method) const
virtual voidTTask::Add(TTask* task)
virtual voidAliAnalysisTaskSE::AddAODBranch(const char* cname, void* addobj, const char* fname = "")
AliClusterContainer*AliAnalysisTaskEmcal::AddClusterContainer(const char* n)
AliJetContainer*AliAnalysisTaskEmcalJet::AddJetContainer(const char* n, TString defaultCutType = "", Float_t jetRadius = 0.4)
AliParticleContainer*AliAnalysisTaskEmcal::AddParticleContainer(const char* n)
virtual AliAODEvent*AliAnalysisTaskSE::AODEvent() const
virtual voidTObject::AppendPad(Option_t* option = "")
Bool_tAliAnalysisTask::AreSlotsConnected()
TH1F*BookTH1F(const char* name, const char* x, Int_t bins, Double_t min, Double_t max, Int_t c = -1, Bool_t append = kTRUE)
TH2F*BookTH2F(const char* name, const char* x, const char* y, Int_t binsx, Double_t minx, Double_t maxx, Int_t binsy, Double_t miny, Double_t maxy, Int_t c = -1, Bool_t append = kTRUE)
TH3F*BookTH3F(const char* name, const char* x, const char* y, const char* z, Int_t binsx, Double_t minx, Double_t maxx, Int_t binsy, Double_t miny, Double_t maxy, Int_t binsz, Double_t minz, Double_t maxz, Int_t c = -1, Bool_t append = kTRUE)
virtual voidTTask::Browse(TBrowser* b)
static Double_tCalculateEventPlaneChi(Double_t res)
voidCalculateEventPlaneCombinedVZERO(Double_t* comb) const
voidCalculateEventPlaneResolution(Double_t** vzero, Double_t* vzeroComb, Double_t* tpc)
voidCalculateEventPlaneTPC(Double_t* tpc)
voidCalculateEventPlaneVZERO(Double_t** vzero) const
Double_tCalculateQC2(Int_t harm)
Double_tCalculateQC4(Int_t harm)
voidCalculateQvectorCombinedVZERO(Double_t* Q2, Double_t* Q3) const
voidCalculateQvectorVZERO(Double_t* Qa2, Double_t* Qc2, Double_t* Qa3, Double_t* Qc3) const
voidCalculateRandomCone(Float_t& pt, Float_t& eta, Float_t& phi, AliParticleContainer* tracksCont, AliClusterContainer* clusterCont = 0x0, AliEmcalJet* jet = 0x0) const
Bool_tAliAnalysisTask::CheckCircularDeps()
voidAliAnalysisTask::CheckNotify(Bool_t init = kFALSE)
virtual Bool_tAliAnalysisTask::CheckOwnership() const
virtual Bool_tAliAnalysisTask::CheckPostData() const
static Double_tChiSquare(TH1& histo, TF1* func)
static Double_tChiSquareCDF(Int_t ndf, Double_t x)
static Double_tChiSquarePDF(Int_t ndf, Double_t x)
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidTTask::CleanTasks()
virtual voidTTask::Clear(Option_t* option = "")
virtual TObject*TNamed::Clone(const char* newname = "") const
virtual Int_tTNamed::Compare(const TObject* obj) const
Bool_tAliAnalysisTask::ConnectInput(Int_t islot, AliAnalysisDataContainer* cont)
virtual voidAliAnalysisTaskSE::ConnectInputData(Option_t* option = "")
Bool_tAliAnalysisTask::ConnectOutput(Int_t islot, AliAnalysisDataContainer* cont)
virtual voidTTask::Continue()MENU
virtual voidTNamed::Copy(TObject& named) const
TH1F*CorrectForResolutionDiff(TH1F* v, AliAnalysisTaskJetV2::detectorType detector, TArrayD* cen, Int_t c, Int_t h = 2)
TH1F*CorrectForResolutionInt(TH1F* v, AliAnalysisTaskJetV2::detectorType detector, TArrayD* cen, Int_t h = 2)
Bool_tCorrectRho(Double_t psi2, Double_t psi3)
virtual voidAliAnalysisTaskSE::CreateOutputObjects()
virtual const char*AliAnalysisTaskSE::CurrentFileName()
virtual Int_tAliAnalysisTaskSE::DebugLevel() const
virtual voidTObject::Delete(Option_t* option = "")MENU
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual voidTObject::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() constMENU
virtual TObject*TObject::DrawClone(Option_t* option = "") constMENU
virtual voidTObject::Dump() constMENU
virtual Long64_tAliAnalysisTaskSE::Entry() const
virtual voidTObject::Error(const char* method, const char* msgfmt) const
virtual AliESDfriend*AliAnalysisTaskSE::ESDfriend() const
virtual const AliEventTag*AliAnalysisTaskSE::EventTag() const
virtual voidExec(Option_t*)
voidExecMe()
virtual voidExecOnce()
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual voidTTask::ExecuteTask(Option_t* option = "0")MENU
virtual voidTTask::ExecuteTasks(Option_t* option)
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
voidFillAnalysisSummaryHistogram() const
virtual voidTNamed::FillBuffer(char*& buffer)
voidFillHistogramsAfterSubtraction(Double_t psi2, Double_t** vzero, Double_t* vzeroComb, Double_t* tpc)
voidFillQAHistograms(AliVTrack* vtrack) const
voidFillQAHistograms(AliVEvent* vevent)
voidFillWeightedClusterHistograms() const
voidFillWeightedDeltaPtHistograms(Double_t psi2) const
voidFillWeightedEventPlaneHistograms(Double_t** vzero, Double_t* vzeroComb, Double_t* tpc) const
voidFillWeightedJetHistograms(Double_t psi2)
voidFillWeightedQAHistograms(AliVTrack* vtrack) const
voidFillWeightedQAHistograms(AliVEvent* vevent)
voidFillWeightedRhoHistograms()
voidFillWeightedTrackHistograms() const
voidFillWeightedTriggerQA(Double_t dPhi, Double_t pt, UInt_t trigger)
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
virtual voidAliAnalysisTask::FinishTaskOutput()
voidAliAnalysisTask::GetBranches(const char* type, TString& result) const
Int_tTTask::GetBreakin() const
Int_tTTask::GetBreakout() const
TArrayD*GetCentralityClasses() const
AliClusterContainer*AliAnalysisTaskEmcal::GetClusterContainer(Int_t i = 0) const
AliClusterContainer*AliAnalysisTaskEmcal::GetClusterContainer(const char* name) const
virtual UInt_tAliAnalysisTaskSE::GetCollisionCandidates() const
TH1F*GetDifferentialQC(TProfile* refCumulants, TProfile* diffCumlants, TArrayD* ptBins, Int_t h)
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
static TH1F*GetEventPlaneWeights(TH1F* hist)
virtual const char*TObject::GetIconName() const
TObject*AliAnalysisTask::GetInputData(Int_t islot) const
AliAnalysisDataSlot*AliAnalysisTask::GetInputSlot(Int_t islot) const
TClass*AliAnalysisTask::GetInputType(Int_t islot) const
AliJetContainer*AliAnalysisTaskEmcalJet::GetJetContainer(Int_t i = 0) const
AliJetContainer*AliAnalysisTaskEmcalJet::GetJetContainer(const char* name) const
Double_tGetJetRadius() const
TStringGetJetsName() const
AliEmcalJet*GetLeadingJet(AliLocalRhoParameter* localRho = 0x0)
TList*TTask::GetListOfTasks() const
TStringGetLocalRhoName() const
AliLocalRhoParameter*GetLocalRhoParameter() const
virtual const char*TNamed::GetName() const
Int_tAliAnalysisTask::GetNinputs() const
Int_tAliAnalysisTask::GetNoutputs() const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Option_t*TObject::GetOption() const
TObject*AliAnalysisTask::GetOutputData(Int_t islot) const
TList*GetOutputList() const
AliAnalysisDataSlot*AliAnalysisTask::GetOutputSlot(Int_t islot) const
TClass*AliAnalysisTask::GetOutputType(Int_t islot) const
AliParticleContainer*AliAnalysisTaskEmcal::GetParticleContainer(Int_t i = 0) const
AliParticleContainer*AliAnalysisTaskEmcal::GetParticleContainer(const char* name) const
TObject*AliAnalysisTask::GetPublishedData() const
virtual TList*AliAnalysisTaskSE::GetQAHistos() const
TH1F*GetResolutionFromOuptutFile(AliAnalysisTaskJetV2::detectorType detector, Int_t h = 2, TArrayD* c = 0x0)
TProfile*GetResolutionParameters(Int_t h, Int_t c) const
const TString&AliAnalysisTaskEmcalJet::GetRhoName(Int_t c = 0) const
virtual const char*TNamed::GetTitle() const
TStringGetTracksName() const
virtual UInt_tTObject::GetUniqueID() const
Int_tGetVZEROCentralityBin() const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
Bool_tAliAnalysisTask::HasBranches() const
Bool_tAliAnalysisTask::HasExecuted() const
virtual ULong_tTNamed::Hash() const
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
virtual voidAliAnalysisTaskSE::Init()
Bool_tInitializeAnalysis()
virtual AliVEvent*AliAnalysisTaskSE::InputEvent() const
virtual voidTObject::Inspect() constMENU
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
Bool_tTTask::IsActive() const
Bool_tAliAnalysisTask::IsChecked() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tAliAnalysisTaskSE::IsEventInBinZero()
virtual Bool_tTTask::IsFolder() const
Bool_tAliAnalysisTask::IsInitialized() const
static Bool_tIsInPlane(Double_t dPhi)
Bool_tTObject::IsOnHeap() const
Bool_tAliAnalysisTask::IsOutputReady(Int_t islot) const
Bool_tAliAnalysisTask::IsPostEventLoop() const
Bool_tAliAnalysisTask::IsReady() const
virtual Bool_tTNamed::IsSortable() const
virtual Bool_tAliAnalysisTaskSE::IsStandardAOD() const
Bool_tAliAnalysisTask::IsUsed() const
Bool_tAliAnalysisTask::IsZombie() const
Double_tKolmogorovTest(TH1F& histo, TF1* func) const
voidAliAnalysisTaskSE::LoadBranches() const
virtual voidAliAnalysisTask::LocalInit()
virtual voidTTask::ls(Option_t* option = "*") constMENU
voidTObject::MayNotUse(const char* method) const
virtual AliMCEvent*AliAnalysisTaskSE::MCEvent() const
virtual Bool_tNotify()
virtual Bool_tAliAnalysisTask::NotifyBinChange()
virtual voidAliAnalysisTaskSE::NotifyRun()
static voidNumericalOverlap(Double_t x1, Double_t x2, Double_t psi2, Double_t& percIn, Double_t& percOut, Double_t& percLost)
voidTObject::Obsolete(const char* method, const char* asOfVers, const char* removedFromVers) const
static voidTObject::operator delete(void* ptr)
static voidTObject::operator delete(void* ptr, void* vp)
static voidTObject::operator delete[](void* ptr)
static voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new(size_t sz)
void*TObject::operator new(size_t sz, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
virtual TTree*AliAnalysisTaskSE::OutputTree() const
static Int_tOverlapsWithPlane(Double_t x1, Double_t x2, Double_t a, Double_t b, Double_t c, Double_t d, Double_t e, Double_t phi)
virtual voidTObject::Paint(Option_t* option = "")
Bool_tPassesCuts(AliVParticle* track) const
Bool_tPassesCuts(AliEmcalJet* jet)
Bool_tPassesCuts(AliVCluster* clus) const
Bool_tPassesCuts(AliVEvent* event)
Bool_tPassesCuts(const AliVCluster* track) const
Bool_tPassesSimpleCuts(AliEmcalJet* jet)
static Double_tPhaseShift(Double_t x)
static Double_tPhaseShift(Double_t x, Double_t n)
virtual voidTObject::Pop()
virtual voidTNamed::Print(Option_t* option = "") const
voidAliAnalysisTask::PrintContainers(Option_t* option = "all", Int_t indent = 0) const
virtual voidAliAnalysisTask::PrintTask(Option_t* option = "all", Int_t indent = 0) const
static voidPrintTriggerSummary(UInt_t trigger)
Bool_tAliAnalysisTask::ProducersTouched() const
voidQCnDiffentialFlowVectors(TClonesArray* pois, TArrayD* ptBins, Bool_t vpart, Double_t* repn, Double_t* impn, Double_t* mp, Double_t* reqn, Double_t* imqn, Double_t* mq, Int_t n)
Double_tQCnM()
Double_tQCnM11()
Double_tQCnM1111()
voidQCnQnk(Int_t n, Int_t k, Double_t& reQ, Double_t& imQ)
Bool_tQCnRecovery(Double_t psi2, Double_t psi3)
Double_tQCnS(Int_t i, Int_t j)
virtual Int_tTObject::Read(const char* name)
voidReadVZEROCalibration2010h()
virtual voidTObject::RecursiveRemove(TObject* obj)
voidAliAnalysisTaskEmcal::RemoveClusterContainer(Int_t i = 0)
voidAliAnalysisTaskEmcalJet::RemoveJetContainer(Int_t i)
voidAliAnalysisTaskEmcal::RemoveParticleContainer(Int_t i = 0)
virtual voidAliAnalysisTask::Reset()
voidTObject::ResetBit(UInt_t f)
AliAnalysisTaskJetV2*ReturnMe()
virtual Bool_tRun()
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
virtual voidTObject::SavePrimitive(basic_ostream<char,char_traits<char> >& out, Option_t* option = "")
virtual voidAliAnalysisTaskSE::SelectCollisionCandidates(UInt_t offlineTriggerMask = AliVEvent::kMB)
voidSetAbsVertexZ(Float_t v)
voidSetAcceptanceWeights(Bool_t w)
voidTTask::SetActive(Bool_t active = kTRUE)TOGGLE
voidSetAnalysisType(AliAnalysisTaskJetV2::analysisType type)
voidAliAnalysisTaskEmcalJet::SetAnaType(UInt_t t, Int_t c = 0)
voidAliAnalysisTaskEmcalJet::SetAreaEmcCut(Double_t a = 0.99, Int_t c = 0)
voidSetAttachToEvent(Bool_t b)
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
voidAliAnalysisTask::SetBranches(const char* names)
voidTTask::SetBreakin(Int_t breakin = 1)TOGGLE
voidTTask::SetBreakout(Int_t breakout = 1)TOGGLE
voidAliAnalysisTaskEmcal::SetCaloCellsName(const char* n)
voidAliAnalysisTaskEmcal::SetCaloTriggerPatchInfoName(const char* n)
voidAliAnalysisTaskEmcal::SetCaloTriggersName(const char* n)
voidSetCentralityClasses(TArrayD* c)
voidAliAnalysisTaskEmcal::SetCentralityEstimator(const char* c)
voidAliAnalysisTaskEmcal::SetCentRange(Double_t min, Double_t max)
voidAliAnalysisTask::SetChecked(Bool_t flag = kTRUE)
voidSetChi2VZEROA(TArrayD* a)
voidSetChi2VZEROC(TArrayD* a)
voidSetChi3VZEROA(TArrayD* a)
voidSetChi3VZEROC(TArrayD* a)
voidAliAnalysisTaskEmcal::SetClusName(const char* n)
voidAliAnalysisTaskEmcal::SetClusPtCut(Double_t cut, Int_t c = 0)
voidAliAnalysisTaskEmcal::SetClusTimeCut(Double_t min, Double_t max, Int_t c = 0)
voidSetCollisionType(AliAnalysisTaskJetV2::collisionType type)
virtual voidAliAnalysisTaskSE::SetDebugLevel(Int_t level)
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
voidAliAnalysisTaskEmcal::SetEventPlaneVsEmcal(Double_t ep)
voidSetEventPlaneWeights(TH1F* ep)
voidSetExcludeLeadingJetsFromFit(Float_t n)
voidSetExpectedRuns(TArrayI* r)
voidSetExpectedSemiGoodRuns(TArrayI* r)
voidSetFillHistograms(Bool_t b)
voidSetFillQAHistograms(Bool_t qa)
voidAliAnalysisTaskEmcal::SetForceBeamType(AliAnalysisTaskEmcal::BeamType f)
voidSetGoodnessTest(AliAnalysisTaskJetV2::fitGoodnessTest test)
voidAliAnalysisTaskEmcal::SetHistoBins(Int_t nbins, Double_t min, Double_t max)
voidSetIntegratedFlow(TH1F* i, TH1F* j)
voidAliAnalysisTaskEmcal::SetIsEmbedded(Bool_t i)
voidAliAnalysisTaskEmcalJet::SetIsParticleLevel(Bool_t b, Int_t c = 0)
voidAliAnalysisTaskEmcal::SetIsPythia(Bool_t i)
voidAliAnalysisTaskEmcalJet::SetJetAcceptanceType(UInt_t t, Int_t c = 0)
voidAliAnalysisTaskEmcalJet::SetJetAcceptanceType(TString cutType, Int_t c = 0)
voidAliAnalysisTaskEmcalJet::SetJetAreaCut(Float_t cut, Int_t c = 0)
voidAliAnalysisTaskEmcalJet::SetJetBitMap(UInt_t m, Int_t c = 0)
voidAliAnalysisTaskEmcalJet::SetJetEtaLimits(Float_t min, Float_t max, Int_t c = 0)
voidAliAnalysisTaskEmcalJet::SetJetPhiLimits(Float_t min, Float_t max, Int_t c = 0)
voidAliAnalysisTaskEmcalJet::SetJetPtCut(Float_t cut, Int_t c = 0)
voidAliAnalysisTaskEmcalJet::SetJetRadius(Float_t r, Int_t c = 0)
voidAliAnalysisTaskEmcalJet::SetJetsName(const char* n)
voidAliAnalysisTaskEmcalJet::SetJetTrigger(UInt_t t, Int_t c = 0)
voidAliAnalysisTaskEmcalJet::SetLeadingHadronType(Int_t t, Int_t c = 0)
virtual voidAliAnalysisTaskEmcalJet::SetLocalRhoName(const char* n)
voidAliAnalysisTaskEmcalJet::SetMaxClusterPt(Float_t b, Int_t c = 0)
voidSetMaxNoRandomCones(Int_t m)
voidAliAnalysisTaskEmcalJet::SetMaxTrackPt(Float_t b, Int_t c = 0)
voidAliAnalysisTaskEmcal::SetMCLabelShift(Int_t s)
voidSetMinDistanceRctoLJ(Float_t m)
voidAliAnalysisTaskEmcal::SetMinMCLabel(Int_t s)
voidAliAnalysisTaskEmcal::SetMinNTrack(Int_t min)
voidAliAnalysisTaskEmcal::SetMinPtTrackInEmcal(Double_t min)
voidSetModulationFit(TF1* fit)
voidSetModulationFitMinMaxP(Float_t m, Float_t n)
voidSetModulationFitOptions(TString opt)
voidSetModulationFitType(AliAnalysisTaskJetV2::fitModulationType type)
virtual voidTNamed::SetName(const char* name)MENU
voidSetNameRhoSmall(TString name)
virtual voidTNamed::SetNameTitle(const char* name, const char* title)
voidAliAnalysisTaskEmcal::SetNCentBins(Int_t n)
voidAliAnalysisTaskEmcal::SetNeedEmcalGeom(Bool_t n)
voidAliAnalysisTaskEmcalJet::SetNEFCut(Float_t min, Float_t max, Int_t c = 0)
voidAliAnalysisTaskEmcalJet::SetNLeadingJets(Int_t t, Int_t c = 0)
voidSetNoEventWeightsForQC(Bool_t e)
static voidTObject::SetObjectStat(Bool_t stat)
voidAliAnalysisTaskEmcal::SetOffTrigger(UInt_t t)
voidSetOnTheFlyResCorrection(TH1F* r2, TH1F* r3)
voidSetOutputList(TList* l)
voidAliAnalysisTaskEmcalJet::SetPercAreaCut(Float_t p, Int_t c = 0)
voidAliAnalysisTask::SetPostEventLoop(Bool_t flag = kTRUE)
voidAliAnalysisTaskEmcalJet::SetPtBiasJetClus(Float_t b, Int_t c = 0)
voidAliAnalysisTaskEmcalJet::SetPtBiasJetTrack(Float_t b, Int_t c = 0)
voidSetQCnRecoveryType(AliAnalysisTaskJetV2::qcRecovery type)
voidSetRandomSeed(TRandom3* r)
voidSetRebinSwapHistoOnTheFly(Bool_t r)
voidSetReduceBinsXYByFactor(Float_t x, Float_t y)
voidSetReferenceDetector(AliAnalysisTaskJetV2::detectorType type)
virtual voidAliAnalysisTaskEmcalJet::SetRhoName(const char* n, Int_t c = 0)
voidSetRunModeType(AliAnalysisTaskJetV2::runModeType type)
voidSetRunToyMC(Bool_t t)
voidSetSaveThisPercentageOfFits(Float_t p)
voidSetSemiGoodJetMinMaxPhi(Double_t a, Double_t b)
voidSetSemiGoodTrackMinMaxPhi(Double_t a, Double_t b)
voidSetSoftTrackMinMaxPt(Float_t min, Float_t max)
virtual voidTNamed::SetTitle(const char* title = "")MENU
voidAliAnalysisTaskEmcal::SetTrackEtaLimits(Double_t min, Double_t max, Int_t c = 0)
voidAliAnalysisTaskEmcal::SetTrackPhiLimits(Double_t min, Double_t max, Int_t c = 0)
voidAliAnalysisTaskEmcal::SetTrackPtCut(Double_t cut, Int_t c = 0)
voidAliAnalysisTaskEmcal::SetTracksName(const char* n)
voidAliAnalysisTaskEmcal::SetTrigClass(const char* n)
voidAliAnalysisTaskEmcal::SetTriggerTypeSel(AliAnalysisTaskEmcal::TriggerType t)
virtual voidTObject::SetUniqueID(UInt_t uid)
voidAliAnalysisTaskEmcal::SetUseAliAnaUtils(Bool_t b, Bool_t bRejPilup = kTRUE)
voidSetUseControlFit(Bool_t c)
voidAliAnalysisTask::SetUsed(Bool_t flag = kTRUE)
voidSetUsePtWeight(Bool_t w)
voidSetUsePtWeightErrorPropagation(Bool_t w)
voidAliAnalysisTaskEmcal::SetUseSPDTrackletVsClusterBG(Bool_t b)
voidSetUseVZERORing(Int_t i, Bool_t u)
voidSetVZEROApol(Int_t ring, Float_t f)
voidSetVZEROCpol(Int_t ring, Float_t f)
voidSetVZEROgainEqualizationPerRing(Bool_t s)
voidAliAnalysisTaskEmcal::SetVzRange(Double_t min, Double_t max)
voidAliAnalysisTaskEmcalJet::SetZLeadingCut(Float_t zemc, Float_t zch, Int_t c = 0)
voidAliAnalysisTask::SetZombie(Bool_t flag = kTRUE)
virtual voidShowMembers(TMemberInspector&)
virtual Int_tTNamed::Sizeof() const
virtual voidStreamer(TBuffer&)
voidStreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
virtual voidTerminate(Option_t* option)
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
virtual voidTObject::UseCurrentStyle()
virtual voidUserCreateOutputObjects()
virtual voidAliAnalysisTaskSE::UserExecMix(Option_t*)
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0) const
protected:
Bool_tAliAnalysisTaskEmcalJet::AcceptBiasJet(AliEmcalJet* jet, Int_t c = 0)
Bool_tAliAnalysisTaskEmcal::AcceptCluster(AliVCluster* clus, Int_t c = 0) const
virtual Bool_tAliAnalysisTaskEmcalJet::AcceptJet(AliEmcalJet* jet, Int_t c = 0)
Bool_tAliAnalysisTaskEmcal::AcceptTrack(AliVParticle* track, Int_t c = 0) const
voidAliAnalysisTaskEmcal::AddObjectToEvent(TObject* obj)
voidAliAnalysisTaskSE::ConnectMultiHandler()
voidAliAnalysisTask::DefineInput(Int_t islot, TClass* type)
voidAliAnalysisTask::DefineOutput(Int_t islot, TClass* type)
voidAliAnalysisTaskSE::DisconnectMultiHandler()
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
voidAliAnalysisTask::EnableBranch(Int_t islot, const char* bname) const
virtual Bool_tAliAnalysisTaskEmcal::FillGeneralHistograms()
virtual Bool_tAliAnalysisTaskEmcal::FillHistograms()
Double_t*AliAnalysisTaskEmcal::GenerateFixedBinArray(Int_t n, Double_t min, Double_t max) const
voidAliAnalysisTaskEmcal::GenerateFixedBinArray(Int_t n, Double_t min, Double_t max, Double_t* array) const
AliVCluster*AliAnalysisTaskEmcal::GetAcceptClusterFromArray(Int_t cl, Int_t c = 0) const
AliEmcalJet*AliAnalysisTaskEmcalJet::GetAcceptJetFromArray(Int_t j, Int_t c = 0) const
AliVParticle*AliAnalysisTaskEmcal::GetAcceptParticleFromArray(Int_t p, Int_t c = 0) const
TClonesArray*AliAnalysisTaskEmcal::GetArrayFromEvent(const char* name, const char* clname = 0)
AliAnalysisTaskEmcal::BeamTypeAliAnalysisTaskEmcal::GetBeamType()
char*AliAnalysisTask::GetBranchAddress(Int_t islot, const char* branch) const
TClonesArray*AliAnalysisTaskEmcal::GetClusterArray(Int_t i = 0) const
TClonesArray*AliAnalysisTaskEmcalJet::GetJetArray(Int_t i = 0) const
AliEmcalJet*AliAnalysisTaskEmcalJet::GetJetFromArray(Int_t j, Int_t c = 0) const
Double_tAliAnalysisTaskEmcalJet::GetLeadingHadronPt(AliEmcalJet* jet, Int_t c = 0)
AliLocalRhoParameter*AliAnalysisTaskEmcalJet::GetLocalRhoFromEvent(const char* name)
AliEmcalTriggerPatchInfo*AliAnalysisTaskEmcal::GetMainTriggerPatch(AliAnalysisTaskEmcal::TriggerCategory triggersel = kTriggerLevel1Jet, Bool_t doOfflinSimple = kFALSE)
Int_tAliAnalysisTaskEmcal::GetNClusters(Int_t i = 0) const
Int_tAliAnalysisTaskEmcalJet::GetNJets(Int_t i = 0) const
Int_tAliAnalysisTaskEmcal::GetNParticles(Int_t i = 0) const
TClonesArray*AliAnalysisTaskEmcal::GetParticleArray(Int_t i = 0) const
AliRhoParameter*AliAnalysisTaskEmcalJet::GetRhoFromEvent(const char* name)
Double_tAliAnalysisTaskEmcalJet::GetRhoVal(Int_t i = 0) const
ULong_tAliAnalysisTaskEmcal::GetTriggerList()
Bool_tAliAnalysisTaskEmcal::HasTriggerType(AliAnalysisTaskEmcal::TriggerType triggersel)
virtual Bool_tAliAnalysisTaskEmcal::IsEventSelected()
Bool_tAliAnalysisTaskEmcalJet::IsJetCluster(AliEmcalJet* jet, Int_t iclus, Bool_t sorted = kFALSE) const
Bool_tAliAnalysisTaskEmcalJet::IsJetTrack(AliEmcalJet* jet, Int_t itrack, Bool_t sorted = kFALSE) const
voidTObject::MakeZombie()
TFile*AliAnalysisTask::OpenFile(Int_t iout, Option_t* option = "RECREATE") const
Bool_tAliAnalysisTask::PostData(Int_t iout, TObject* data, Option_t* option = "")
Bool_tAliAnalysisTaskEmcal::PythiaInfoFromFile(const char* currFile, Float_t& fXsec, Float_t& fTrials, Int_t& pthard)
virtual Bool_tAliAnalysisTaskEmcalJet::RetrieveEventObjects()
Bool_tAliAnalysisTask::SetBranchAddress(Int_t islot, const char* branch, void* address) const
voidAliAnalysisTaskEmcal::SetMakeGeneralHistograms(Bool_t g)
voidAliAnalysisTaskEmcal::SetRejectionReasonLabels(TAxis* axis)
virtual voidAliAnalysisTaskEmcal::UserExec(Option_t* option)
virtual Bool_tAliAnalysisTaskEmcal::UserNotify()

Data Members

public:
enum fitModulationType { kNoFit
kV2
kV3
kCombined
kFourierSeries
kIntegratedFlow
kQC2
kQC4
};
enum fitGoodnessTest { kChi2ROOT
kChi2Poisson
kKolmogorov
kKolmogorovTOY
kLinearFit
};
enum collisionType { kPbPb
kPythia
kPbPb10h
kPbPb11h
kJetFlowMC
};
enum qcRecovery { kFixedRho
kNegativeVn
kTryFit
};
enum runModeType { kLocal
kGrid
};
enum dataType { kESD
kAOD
kESDMC
kAODMC
};
enum detectorType { kTPC
kVZEROA
kVZEROC
kVZEROComb
kFixedEP
};
enum analysisType { kCharged
kFull
};
enum AliAnalysisTaskEmcal::BeamType { kNA
kpp
kAA
kpA
};
enum AliAnalysisTaskEmcal::TriggerType { kND
kJ1
kJ2
kG1
kG2
kL0
};
enum AliAnalysisTaskEmcal::TriggerCategory { kTriggerLevel0
kTriggerLevel1Jet
kTriggerLevel1Gamma
kTriggerRecalcJet
kTriggerRecalcGamma
};
enum AliAnalysisTask::EAnalysisTaskFlags { kTaskUsed
kTaskZombie
kTaskChecked
kTaskPostEventLoop
};
enum TObject::EStatusBits { kCanDelete
kMustCleanup
kObjInCanvas
kIsReferenced
kHasUUID
kCannotPick
kNoContextMenu
kInvalidObject
};
enum TObject::[unnamed] { kIsOnHeap
kNotDeleted
kZombie
kBitMask
kSingleKey
kOverwrite
kWriteDelete
};
protected:
Bool_tTTask::fActivetrue if task is active
AliAnalysisUtils*AliAnalysisTaskEmcal::fAliAnalysisUtils! vertex selection (optional)
AliAnalysisTaskEmcal::BeamTypeAliAnalysisTaskEmcal::fBeamType!event beam type
TStringAliAnalysisTask::fBranchNamesList of input branches that need to be loaded for this task
Int_tTTask::fBreakin=1 if a break point set at task extry
Int_tTTask::fBreakout=1 if a break point set at task exit
AliVCaloCells*AliAnalysisTaskEmcal::fCaloCells!cells
TStringAliAnalysisTaskEmcal::fCaloCellsNamename of calo cell collection
TClonesArray*AliAnalysisTaskEmcal::fCaloClusters!clusters
TStringAliAnalysisTaskEmcal::fCaloTriggerPatchInfoNametrigger patch info array name
AliVCaloTrigger*AliAnalysisTaskEmcal::fCaloTriggers!calo triggers
TStringAliAnalysisTaskEmcal::fCaloTriggersNamename of calo triggers collection
Double_tAliAnalysisTaskEmcal::fCent!event centrality
Int_tAliAnalysisTaskEmcal::fCentBin!event centrality bin
TStringAliAnalysisTaskEmcal::fCentEstname of V0 centrality estimator
TObjArrayAliAnalysisTaskEmcal::fClusterCollArraycluster collection array
Bool_tAliAnalysisTaskEmcal::fCreateHistowhether or not create histograms
Int_tAliAnalysisTaskSE::fCurrentRunNumber! Current run number
Int_tAliAnalysisTaskSE::fDebugDebug flag
Double_tAliAnalysisTaskEmcal::fEPV0!event plane V0
Double_tAliAnalysisTaskEmcal::fEPV0A!event plane V0A
Double_tAliAnalysisTaskEmcal::fEPV0C!event plane V0C
AliESDfriend*AliAnalysisTaskSE::fESDfriend! ESD friend
Int_tAliAnalysisTaskSE::fEntryCurrent entry in the chain
Double_tAliAnalysisTaskEmcal::fEventPlaneVsEmcalselect events which have a certain event plane wrt the emcal
AliAnalysisTaskEmcal::BeamTypeAliAnalysisTaskEmcal::fForceBeamTypeforced beam type
Bool_tAliAnalysisTaskEmcal::fGeneralHistogramswhether or not it should fill some general histograms
AliEMCALGeometry*AliAnalysisTaskEmcal::fGeom!emcal geometry
Bool_tTTask::fHasExecutedTrue if task has executed
TH1*AliAnalysisTaskEmcal::fHistCentrality!event centrality distribution
TH1*AliAnalysisTaskEmcal::fHistEventCount!incoming and selected events
TH1*AliAnalysisTaskEmcal::fHistEventPlane!event plane distribution
TH1*AliAnalysisTaskEmcal::fHistEventRejection!book keep reasons for rejecting event
TH1*AliAnalysisTaskEmcal::fHistEvents!total number of events per pt hard bin
TH1*AliAnalysisTaskEmcal::fHistEventsAfterSel!total number of events per pt hard bin after selection
TH1*AliAnalysisTaskEmcal::fHistPtHard!pt hard distribution
TH1*AliAnalysisTaskEmcal::fHistTrials!trials from pyxsec.root
TH1*AliAnalysisTaskEmcal::fHistTrialsAfterSel!total number of trials per pt hard bin after selection
TProfile*AliAnalysisTaskEmcal::fHistXsection!x section from pyxsec.root
TProfile*AliAnalysisTaskEmcal::fHistXsectionAfterSel!x section from pythia header
TH1*AliAnalysisTaskEmcal::fHistZVertex!z vertex position
TList*AliAnalysisTaskSE::fHistosQA! Output histos for QA
Bool_tAliAnalysisTaskEmcal::fInitializedwhether or not the task has been already initialized
Bool_tAliAnalysisTask::fInitializedTrue if Init() was called
AliVEvent*AliAnalysisTaskSE::fInputEvent! VEvent Input
AliInputEventHandler*AliAnalysisTaskSE::fInputHandler! Input Handler
TObjArray*AliAnalysisTask::fInputsArray of input slots
Bool_tAliAnalysisTaskEmcal::fIsEmbeddedtrigger, embedded signal
Bool_tAliAnalysisTaskEmcal::fIsEsd!whether it's an ESD analysis
Bool_tAliAnalysisTaskEmcal::fIsPythiatrigger, if it is a PYTHIA production
TObjArrayAliAnalysisTaskEmcalJet::fJetCollArrayjet collection array
TClonesArray*AliAnalysisTaskEmcalJet::fJets!jets
AliLocalRhoParameter*AliAnalysisTaskEmcalJet::fLocalRho!local event rho
TStringAliAnalysisTaskEmcalJet::fLocalRhoNamename for local rho
AliMCEvent*AliAnalysisTaskSE::fMCEvent! MC
AliInputEventHandler*AliAnalysisTaskSE::fMCEventHandler! pointer to MCEventHandler
Int_tAliAnalysisTaskEmcal::fMCLabelShiftif MC label > fMCLabelShift, MC label -= fMCLabelShift
Double_tAliAnalysisTaskEmcal::fMaxBinPtmax pt in histograms
Double_tAliAnalysisTaskEmcal::fMaxCentmax centrality for event selection
Double_tAliAnalysisTaskEmcal::fMaxEventPlanemaximum event plane value
Double_tAliAnalysisTaskEmcal::fMaxVzmax vertex for event selection
Double_tAliAnalysisTaskEmcal::fMinBinPtmin pt in histograms
Double_tAliAnalysisTaskEmcal::fMinCentmin centrality for event selection
Double_tAliAnalysisTaskEmcal::fMinEventPlaneminimum event plane value
Int_tAliAnalysisTaskEmcal::fMinMCLabelminimum MC label value for the tracks/clusters being considered MC particles
Int_tAliAnalysisTaskEmcal::fMinNTrackminimum nr of tracks in event with pT>fTrackPtCut
Double_tAliAnalysisTaskEmcal::fMinPtTrackInEmcalmin pt track in emcal
Double_tAliAnalysisTaskEmcal::fMinVzmin vertex for event selection
AliMultiInputEventHandler*AliAnalysisTaskSE::fMultiInputHandler! pointer to multihandler
Int_tAliAnalysisTaskEmcal::fNTrials!event trials
Int_tAliAnalysisTaskEmcal::fNVertCont!event vertex number of contributors
TStringTNamed::fNameobject identifier
Int_tAliAnalysisTaskEmcal::fNbinsno. of pt bins
Int_tAliAnalysisTaskEmcal::fNcentBinshow many centrality bins
Bool_tAliAnalysisTaskEmcal::fNeedEmcalGeomwhether or not the task needs the emcal geometry
Int_tAliAnalysisTask::fNinputsNumber of inputs
Int_tAliAnalysisTask::fNoutputsNumber of outputs
UInt_tAliAnalysisTaskEmcal::fOffTriggeroffline trigger for event selection
UInt_tAliAnalysisTaskSE::fOfflineTriggerMaskTask processes collision candidates only
TStringTTask::fOptionOption specified in ExecuteTask
TList*AliAnalysisTaskEmcal::fOutput!output list
AliAODEvent*AliAnalysisTaskSE::fOutputAOD! AOD out
Bool_t*AliAnalysisTask::fOutputReady[fNoutputs] Flags for output readyness
TObjArray*AliAnalysisTask::fOutputsArray of output slots
TObjArrayAliAnalysisTaskEmcal::fParticleCollArrayparticle/track collection array
Double_tAliAnalysisTaskEmcal::fPtHard!event pt hard
Int_tAliAnalysisTaskEmcal::fPtHardBin!event pt hard bin
TObject*AliAnalysisTask::fPublishedData! published data
AliGenPythiaEventHeader*AliAnalysisTaskEmcal::fPythiaHeader!event Pythia header
Bool_tAliAnalysisTask::fReadyFlag if the task is ready
Bool_tAliAnalysisTaskEmcal::fRejectPileupReject pilup using function AliAnalysisUtils::IsPileUpEvent()
AliRhoParameter*AliAnalysisTaskEmcalJet::fRho!event rho
TStringAliAnalysisTaskEmcalJet::fRhoNamerho name
Double_tAliAnalysisTaskEmcalJet::fRhoVal!event rho value, same for local rho
Int_tAliAnalysisTaskEmcal::fSelectPtHardBinselect one pt hard bin for analysis
TList*TTask::fTasksList of Tasks
TStringTNamed::fTitleobject title
Bool_tAliAnalysisTaskEmcal::fTklVsClusSPDCutApply tracklet-vs-cluster SPD cut to reject background events in pp
Double_tAliAnalysisTaskEmcal::fTrackPtCutcut on track pt in event selection
TClonesArray*AliAnalysisTaskEmcal::fTracks!tracks
TTree*AliAnalysisTaskSE::fTreeAAOD output Tree
TStringAliAnalysisTaskEmcal::fTrigClasstrigger class name for event selection
TClonesArray*AliAnalysisTaskEmcal::fTriggerPatchInfo!trigger patch info array
AliAnalysisTaskEmcal::TriggerTypeAliAnalysisTaskEmcal::fTriggerTypeSeltrigger type to select based on trigger patches
ULong_tAliAnalysisTaskEmcal::fTriggerslist of fired triggers
Bool_tAliAnalysisTaskEmcal::fUseAliAnaUtilsused for LHC13* data: z-vtx, Ncontributors, z-vtx resolution cuts
Double_tAliAnalysisTaskEmcal::fVertex[3]!event vertex
Float_tAliAnalysisTaskEmcal::fXsection!x-section from pythia header
static TClonesArray*AliAnalysisTaskSE::fgAODCaloClusters! CaloClusters for replication
static TClonesArray*AliAnalysisTaskSE::fgAODDimuons! Dimuons replication
static AliAODCaloTrigger*AliAnalysisTaskSE::fgAODEMCALTrigger! Emcal Trigger for replication
static AliAODCaloCells*AliAnalysisTaskSE::fgAODEmcalCells! Emcal Cell replication
static TClonesArray*AliAnalysisTaskSE::fgAODFMDClusters! FMDClusters for replication
static AliVHeader*AliAnalysisTaskSE::fgAODHeader! Header for replication
static TClonesArray*AliAnalysisTaskSE::fgAODHmpidRings! HMPID replication
static TClonesArray*AliAnalysisTaskSE::fgAODJets! Jets for replication
static TClonesArray*AliAnalysisTaskSE::fgAODMCParticles! MC Particles for replicatio
static AliAODCaloTrigger*AliAnalysisTaskSE::fgAODPHOSTrigger! Phos Trigger for replication
static TClonesArray*AliAnalysisTaskSE::fgAODPMDClusters! PMDClusters for replication
static AliAODCaloCells*AliAnalysisTaskSE::fgAODPhosCells! Phos Cell replication
static AliAODTracklets*AliAnalysisTaskSE::fgAODTracklets! Tracklets for replication
static TClonesArray*AliAnalysisTaskSE::fgAODTracks! Tracks for replication
static TClonesArray*AliAnalysisTaskSE::fgAODV0s! V0s for replication
static AliAODVZERO*AliAnalysisTaskSE::fgAODVZERO! VZERO for replication
static TClonesArray*AliAnalysisTaskSE::fgAODVertices! Vertices for replication
static TTask*TTask::fgBeginTaskpointer to task initiator
static TTask*TTask::fgBreakPointpointer to current break point
static AliTOFHeader*AliAnalysisTaskSE::fgTOFHeader! TOFHeader for replication
private:
Float_tfAbsVertexZcut on zvertex
Bool_tfAcceptanceWeightsstore centrality dependent acceptance weights
AliAnalysisTaskJetV2::analysisTypefAnalysisTypeanalysis type (full or charged jets)
Bool_tfAttachToEventattach local rho to the event
AliRhoParameter*fCachedRho! temp cache for rho pointer
TArrayD*fCentralityClasses-> centrality classes (maximum 10)
TArrayD*fChi2Achi vs cent for vzero A ep_2
TArrayD*fChi2Cchi vs cent for vzero C ep_2
TArrayD*fChi3Achi vs cent for vzero A ep_3
TArrayD*fChi3Cchi vs cent for vzero C ep_3
AliClusterContainer*fClusterCont! cluster container
AliAnalysisTaskJetV2::collisionTypefCollisionTypecollision type
AliAnalysisTaskJetV2::dataTypefDataTypedatatype
AliAnalysisTaskJetV2::detectorTypefDetectorTypetype of detector used for modulation fit
Float_tfEventPlaneWeight! the actual weight of an event
TH1F*fEventPlaneWeightsweight histo for the event plane
Float_tfExcludeLeadingJetsFromFitexclude n leading jets from fit
TArrayI*fExpectedRuns-> array of expected run numbers, used for QA
TArrayI*fExpectedSemiGoodRuns-> array of expected semi-good runs, used for cuts and QA
Bool_tfFillHistogramsfill histograms
Bool_tfFillQAHistogramsfill qa histograms
TF1*fFitControl-> control fit
AliAnalysisTaskJetV2::fitGoodnessTestfFitGoodnessTestfit goodness test type
TF1*fFitModulation-> modulation fit for rho
TStringfFitModulationOptionsfit options for modulation fit
AliAnalysisTaskJetV2::fitModulationTypefFitModulationTypefit modulation type
TH1F*fHistAnalysisSummary! analysis summary
TH1F*fHistCentrality! accepted centrality
TProfile*fHistCentralityPercIn! centrality versus perc in
TProfile*fHistCentralityPercLost! centrality versus perc lost
TProfile*fHistCentralityPercOut! centrality versus perc out
TH2F*fHistChi2Cent! reduced chi2, centrlaity correlation
TH2F*fHistChi2ROOTCent! reduced chi2 from ROOT, centrality correlation
TH2F*fHistClusterEtaPhi[10]! eta phi emcal clusters
TH2F*fHistClusterEtaPhiWeighted[10]! eta phi emcal clusters, pt weighted
TH1F*fHistClusterPt[10]! pt emcal clusters
TH2F*fHistDeltaPtDeltaPhi2[10]! dpt vs dphi (psi2 - phi)
TH2F*fHistDeltaPtDeltaPhi2ExLJ[10]! dpt vs dphi, excl leading jet
TH2F*fHistDeltaPtDeltaPhi2ExLJRho0[10]! dpt vs dphi, excl leading jet, rho_0
TH2F*fHistDeltaPtDeltaPhi2Rho0[10]! dpt vs dphi, rho_0
TH2F*fHistJetEtaPhi[10]! eta and phi correlation
TH2F*fHistJetEtaRho[10]! jet eta versus rho
TH2F*fHistJetPsi2Pt[10]! event plane dependence of jet pt
TH2F*fHistJetPsi2PtRho0[10]! event plane dependence of jet pt vs rho_0
TH1F*fHistJetPt[10]! pt of found jets (background subtracted)
TH2F*fHistJetPtArea[10]! jet pt versus area
TH2F*fHistJetPtConstituents[10]! jet pt versus number of constituents
TH2F*fHistJetPtEta[10]! jet pt versus eta (temp control)
TH1F*fHistJetPtRaw[10]! jet pt - no background subtraction
TH1F*fHistKolmogorovTest! KolmogorovTest value
TH2F*fHistKolmogorovTestCent! KolmogorovTest value, centrality correlation
TH2F*fHistLeadingJetBackground[10]! geometric correlation of leading jet w/wo bkg subtraction
TH2F*fHistPChi2! correlation p value and reduced chi2
TH2F*fHistPChi2Root! correlation p value and reduced chi2
TH2F*fHistPKolmogorov! p value vs kolmogorov value
TH2F*fHistPicoCat1[10]! pico tracks spd hit and refit
TH2F*fHistPicoCat2[10]! pico tracks wo spd hit w refit, constrained
TH2F*fHistPicoCat3[10]! pico tracks wo spd hit wo refit, constrained
TH1F*fHistPicoTrackMult[10]! multiplicity of accepted pico tracks
TH1F*fHistPicoTrackPt[10]! pt of all charged tracks
TH3F*fHistPsi2Correlation[10]! correlation of event planes
TProfile*fHistPsiControl! event plane control histogram
TProfile*fHistPsiSpread! event plane spread histogram
TH1F*fHistPsiTPC! psi 2 from tpc
TH3F*fHistPsiTPCLeadingJet[10]! correlation tpc EP, LJ pt
TH2F*fHistPsiTPCTRK! psi 2 from tpc
TH2F*fHistPsiTPCV0M! psi 2 from tpc
TH1F*fHistPsiVZERO! psi 2 from combined vzero
TH1F*fHistPsiVZEROA! psi 2 from vzero a
TH3F*fHistPsiVZEROALeadingJet[10]! correlation vzeroa EP, LJ pt
TH2F*fHistPsiVZEROATRK! psi 2 from vzero a
TH2F*fHistPsiVZEROAV0M! psi 2 from vzero a
TH1F*fHistPsiVZEROC! psi 2 from vzero c
TH3F*fHistPsiVZEROCLeadingJet[10]! correlation vzeroc EP, LJ pt
TH2F*fHistPsiVZEROCTRK! psi 2 from vzero c
TH2F*fHistPsiVZEROCV0M! psi 2 from vzero c
TH3F*fHistPsiVZEROCombLeadingJet[10]! correlation vzerocomb EP, LJ pt
TH2F*fHistPsiVZEROTRK! psi 2 from combined vzero
TH2F*fHistPsiVZEROVV0M! psi 2 from combined vzero
TH1F*fHistPvalueCDF! cdf value of chisquare p
TH2F*fHistPvalueCDFCent! p value vs centrality
TH1F*fHistPvalueCDFROOT! pdf value of chisquare p
TH2F*fHistPvalueCDFROOTCent! p value versus centrlaity from root
TH2F*fHistRCPhiEta[10]! random cone eta and phi
TH2F*fHistRCPhiEtaExLJ[10]! random cone eta and phi, excl leading jet
TH1F*fHistRCPt[10]! rcpt
TH1F*fHistRCPtExLJ[10]! rcpt, excl leading jet
TH1F*fHistRho[10]! background
TH2F*fHistRhoAVsCent! rho * A vs centrality for all jets
TH2F*fHistRhoAVsMult! rho * A vs multiplicity for all jets
TH1F*fHistRhoPackage[10]! rho as estimated by emcal jet package
TH2F*fHistRhoStatusCent! status of rho as function of centrality
TH2F*fHistRhoVsCent! rho veruss centrality
TH2F*fHistRhoVsMult! rho versus multiplicity
TH2F*fHistRhoVsRCPt[10]! rho * A vs rcpt
TH2F*fHistRhoVsRCPtExLJ[10]! rho * A vs rcpt, excl leading jet
TH2F*fHistRunnumbersEta! run numbers averaged eta
TH2F*fHistRunnumbersPhi! run numbers averaged phi
TH1F*fHistSwap! swap histogram
TH2F*fHistTriggerQAIn[10]! trigger qa in plane
TH2F*fHistTriggerQAOut[10]! trigger qa out of plane
TH1F*fHistUndeterminedRunQA! undetermined run QA
TH1F*fHistVertexz! accepted verte
Int_tfInCentralitySelection! centrality bin
AliJetContainer*fJetsCont! jets
AliEmcalJet*fLeadingJet! leading jet
AliEmcalJet*fLeadingJetAfterSub! leading jet after background subtraction
Bool_tfLocalInit! is the analysis initialized?
Int_tfMappedRunNumber! mapped runnumer (for QA)
Int_tfMaxConesmax number of random cones
Float_tfMaxPvaluemaximum value of p
Float_tfMeanQ[9][2][2]! recentering
Float_tfMeanQv3[9][2][2]! recentering
Float_tfMinDisanceRCtoLJmin distance between rc and leading jet
Float_tfMinPvalueminimum value of p
Int_tfNAcceptedTracks! number of accepted tracks
Int_tfNAcceptedTracksQCn! accepted tracks for QCn
TStringfNameSmallRhoname of small rho
Bool_tfNoEventWeightsForQCdon't store event weights for qc analysis
TFile*fOADB! fOADB
TList*fOutputList! output list
TList*fOutputListBad! output list for local analysis
TList*fOutputListGood! output list for local analysis
Float_tfPercentageOfFitssave this percentage of fits
TProfile*fProfV2! extracted v2
TProfile*fProfV2Cumulant! v2 cumulant
TProfile*fProfV2Resolution[10]! resolution parameters for v2
TProfile*fProfV3! extracted v3
TProfile*fProfV3Cumulant! v3 cumulant
TProfile*fProfV3Resolution[10]! resolution parameters for v3
AliAnalysisTaskJetV2::qcRecoveryfQCRecoveryrecovery type for e-by-e qc method
TRandom3*fRandom-> dont use gRandom to not interfere with other tasks
Bool_tfRebinSwapHistoOnTheFlyrebin swap histo on the fly
Float_tfReduceBinsXByFactorreduce the bins on x-axis of histo's by this much
Float_tfReduceBinsYByFactorreduce the bins on y-axis of histo's by this much
AliAnalysisTaskJetV2::runModeTypefRunModeTyperun mode type
Int_tfRunNumber! current runnumber (for QA and jet, track selection)
Bool_tfRunToyMCrun toy mc for fit routine
Double_tfSemiGoodJetMaxPhimax phi for semi good tpc runs
Double_tfSemiGoodJetMinPhimin phi for semi good tpc runs
Double_tfSemiGoodTrackMaxPhimax phi for semi good tpc runs
Double_tfSemiGoodTrackMinPhimin phi for semi good tpc runs
Float_tfSoftTrackMaxPtmax pt for soft tracks
Float_tfSoftTrackMinPtmin pt for soft tracks
AliParticleContainer*fTracksCont! tracks
Bool_tfUsePtWeightuse dptdphi instead of dndphi
Bool_tfUsePtWeightErrorPropagationrecalculate the bin errors in case of pt weighting
Bool_tfUseVZERORing[8]kTRUE means the ring is included
TH1F*fUserSuppliedR2correct the extracted v2 with this r
TH1F*fUserSuppliedR3correct the extracted v3 with this r
TH1F*fUserSuppliedV2histo with integrated v2
TH1F*fUserSuppliedV3histo with integrated v3
Float_tfVZEROApol[4]! calibration info per ring
Float_tfVZEROCpol[4]! calibration info per ring
TH1*fVZEROgainEqualization! equalization histo
Bool_tfVZEROgainEqualizationPerRingper ring vzero gain calibration
Float_tfWidthQ[9][2][2]! recentering
Float_tfWidthQv3[9][2][2]! recentering

Class Charts

Inheritance Chart:
TTask
AliAnalysisTask
AliAnalysisTaskSE
AliAnalysisTaskEmcal
AliAnalysisTaskEmcalJet
AliAnalysisTaskJetV2

Function documentation

AliAnalysisTaskJetV2()
AliAnalysisTaskJetV2(const char* name, AliAnalysisTaskJetV2::runModeType type)
~AliAnalysisTaskJetV2()
 destructor
void ExecOnce()
 Init the analysis
Bool_t Notify()
 determine the run number to see if the track and jet cuts should be refreshed for semi-good TPC runs
Bool_t InitializeAnalysis()
 initialize the anaysis
TH1F* BookTH1F(const char* name, const char* x, Int_t bins, Double_t min, Double_t max, Int_t c = -1, Bool_t append = kTRUE)
 book a TH1F and connect it to the output container
TH2F* BookTH2F(const char* name, const char* x, const char* y, Int_t binsx, Double_t minx, Double_t maxx, Int_t binsy, Double_t miny, Double_t maxy, Int_t c = -1, Bool_t append = kTRUE)
 book a TH2F and connect it to the output container
TH3F* BookTH3F(const char* name, const char* x, const char* y, const char* z, Int_t binsx, Double_t minx, Double_t maxx, Int_t binsy, Double_t miny, Double_t maxy, Int_t binsz, Double_t minz, Double_t maxz, Int_t c = -1, Bool_t append = kTRUE)
 book a TH2F and connect it to the output container
void UserCreateOutputObjects()
 create output objects. also initializes some default values in case they aren't
 loaded via the AddTask macro
Bool_t Run()
 called for each accepted event (call made from user exec of parent class)
void Exec(Option_t* )
 for stand alone, avoid framework event setup
void NumericalOverlap(Double_t x1, Double_t x2, Double_t psi2, Double_t& percIn, Double_t& percOut, Double_t& percLost)
 numerically integrate with finite resolution
 idea is the following:
 1) choose a vector phi
 2) see if it is in a region of overlap between detector and in/out of plane spectrum
 3) bookkeep percentages over overlap
Int_t OverlapsWithPlane( Double_t x1, Double_t x2, // detector geometry relative to ep Double_t a, Double_t b, Double_t c, Double_t d, Double_t e, // in-plane, out-of-plane boundaries (see comments) Double_t phi)
 'numerical integration' of geometric overlap

 works as follows: for a given vector phi determines whether
 or not this vector points towards an overlap region of
 detector geometry and plane (in or out)

 returns
 1) if overlap with in plane
 2) if overlap with out of plane
 0) if no overlap at all
Double_t CalculateEventPlaneChi(Double_t res)
 return chi for given resolution to combine event plane estimates from two subevents
 see Phys. Rev. C no. CS6346 (http://arxiv.org/abs/nucl-ex/9805001)
void CalculateEventPlaneVZERO(Double_t** vzero) const
 get the vzero event plane (a and c separately)
void CalculateEventPlaneCombinedVZERO(Double_t* comb) const
 return the combined vzero event plane
void CalculateEventPlaneTPC(Double_t* tpc)
 grab the TPC event plane
void CalculateEventPlaneResolution(Double_t** vzero, Double_t* vzeroComb, Double_t* tpc)
 fill the profiles for the resolution parameters
void CalculateQvectorVZERO(Double_t* Qa2, Double_t* Qc2, Double_t* Qa3, Double_t* Qc3) const
 return the calibrated 2nd and 3rd order q-vectors for vzeroa and vzeroc
 function takes arrays as arguments, which correspond to vzero info in the following way

 Qa2[0] = Qx2 for vzero A         Qa2[1] = Qy2 for vzero A (etc)
void CalculateQvectorCombinedVZERO(Double_t* Q2, Double_t* Q3) const
 calculate calibrated q-vector of the combined vzeroa, vzeroc system
 this is somewhat ugly as CalculateQvectorCombinedVZERO is called more than once per event
 but for now it will have to do ...
void CalculateRandomCone(Float_t& pt, Float_t& eta, Float_t& phi, AliParticleContainer* tracksCont, AliClusterContainer* clusterCont = 0x0, AliEmcalJet* jet = 0x0) const
 get a random cone
Double_t CalculateQC2(Int_t harm)
 get the second order q-cumulant, a -999 return will be caught in the qa routine of CorrectRho
Double_t CalculateQC4(Int_t harm)
 get the fourth order q-cumulant, a -999 return will be caught in the qa routine of CorrectRho
void QCnQnk(Int_t n, Int_t k, Double_t& reQ, Double_t& imQ)
 get the weighted n-th order q-vector, pass real and imaginary part as reference
void QCnDiffentialFlowVectors(TClonesArray* pois, TArrayD* ptBins, Bool_t vpart, Double_t* repn, Double_t* impn, Double_t* mp, Double_t* reqn, Double_t* imqn, Double_t* mq, Int_t n)
 get  unweighted differential flow vectors
Double_t QCnS(Int_t i, Int_t j)
 get the weighted ij-th order autocorrelation correction
Double_t QCnM()
 get multiplicity for unweighted q-cumulants. function QCnQnk should be called first
Double_t QCnM11()
 get multiplicity weights for the weighted two particle cumulant
Double_t QCnM1111()
 get multiplicity weights for the weighted four particle cumulant
Bool_t QCnRecovery(Double_t psi2, Double_t psi3)
 decides how to deal with the situation where c2 or c3 is negative
 returns kTRUE depending on whether or not a modulated rho is used for the jet background
Bool_t CorrectRho(Double_t psi2, Double_t psi3)
 get rho' -> rho(phi)
 two routines are available, both can be used with or without pt weights
  [1] get vn from q-cumulants or as an integrated value from a user supplied histogram
      in case of cumulants, both cumulants and vn values are stored. in both cases, v2 and v3
      are expected. a check is performed to see if rho has no negative local minimum
      for full description, see Phys. Rev. C 83, 044913
      since the cn distribution has negative values, vn = sqrt(cn) can be imaginary sometimes
      in this case one can either roll back to the 'original' rixed rho, do a fit for vn or take use
      vn = - sqrt(|cn|)
  [2] fitting a fourier expansion to the de/dphi distribution
      the fit can be done with either v2, v3 or a combination.
      in all cases, a cut can be made on the p-value of the chi-squared value of the fit
      and a check can be performed to see if rho has no negative local minimum
Bool_t PassesCuts(AliVEvent* event)
 event cuts
void FillHistogramsAfterSubtraction(Double_t psi2, Double_t** vzero, Double_t* vzeroComb, Double_t* tpc)
 fill histograms
void FillQAHistograms(AliVTrack* vtrack) const
 fill qa histograms for pico tracks
void FillQAHistograms(AliVEvent* vevent)
 fill qa histograms for events
void FillWeightedTrackHistograms() const
 fill track histograms
void FillWeightedClusterHistograms() const
 fill cluster histograms
void FillWeightedEventPlaneHistograms(Double_t** vzero, Double_t* vzeroComb, Double_t* tpc) const
 fill event plane histograms, only called in qa mode
void FillWeightedRhoHistograms()
 fill rho histograms
void FillWeightedDeltaPtHistograms(Double_t psi2) const
 fill delta pt histograms
void FillWeightedJetHistograms(Double_t psi2)
 fill jet histograms
void FillWeightedQAHistograms(AliVTrack* vtrack) const
 fill qa histograms for pico tracks
void FillWeightedQAHistograms(AliVEvent* vevent)
 fill qa histograms for events
void FillWeightedTriggerQA(Double_t dPhi, Double_t pt, UInt_t trigger)
 fill the trigger efficiency histograms
void FillAnalysisSummaryHistogram() const
 fill the analysis summary histrogram, saves all relevant analysis settigns
void Terminate(Option_t* option)
 terminate
void SetModulationFit(TF1* fit)
 set modulation fit
void SetUseControlFit(Bool_t c)
 set control fit
TH1F* GetResolutionFromOuptutFile(AliAnalysisTaskJetV2::detectorType detector, Int_t h = 2, TArrayD* c = 0x0)
 INTERFACE METHOD FOR OUTPUTFILE
 get the detector resolution, user has ownership of the returned histogram
TH1F* CorrectForResolutionDiff(TH1F* v, AliAnalysisTaskJetV2::detectorType detector, TArrayD* cen, Int_t c, Int_t h = 2)
 INTERFACE METHOD FOR OUTPUT FILE
 correct the supplied differential vn histogram v for detector resolution
TH1F* CorrectForResolutionInt(TH1F* v, AliAnalysisTaskJetV2::detectorType detector, TArrayD* cen, Int_t h = 2)
 INTERFACE METHOD FOR OUTPUT FILE
 correct the supplied intetrated vn histogram v for detector resolution
 integrated vn must have the same centrality binning as the resolotion correction
TH1F* GetDifferentialQC(TProfile* refCumulants, TProfile* diffCumlants, TArrayD* ptBins, Int_t h)
 get differential QC
void ReadVZEROCalibration2010h()
 necessary for calibration of 10h vzero event plane. code copied from flow package
 (duplicate, but i didn't want to introduce an ulgy dependency )
 this function is only called when the runnumber changes
Int_t GetVZEROCentralityBin() const
 return cache index number corresponding to the event centrality
AliEmcalJet* GetLeadingJet(AliLocalRhoParameter* localRho = 0x0)
 return pointer to the highest pt jet (before background subtraction) within acceptance
 only rudimentary cuts are applied on this level, hence the implementation outside of
 the framework
TH1F* GetEventPlaneWeights(TH1F* hist)
 get event weights distribution from event plane distribution
void PrintTriggerSummary(UInt_t trigger)
 test function to print binary representation of given trigger mask
 trigger mask is represented by 32 bits (hardcoded as it is an UInt_t )
AliAnalysisTaskJetV2()
 constructors, destructor
return histo. KolmogorovTest((&test))
void SetRunToyMC(Bool_t t)
 setters - analysis setup
{fRunToyMC = t; }
void SetAttachToEvent(Bool_t b)
void SetFillHistograms(Bool_t b)
void SetFillQAHistograms(Bool_t qa)
void SetReduceBinsXYByFactor(Float_t x, Float_t y)
void SetNoEventWeightsForQC(Bool_t e)
void SetCentralityClasses(TArrayD* c)
void SetExpectedRuns(TArrayI* r)
void SetExpectedSemiGoodRuns(TArrayI* r)
void SetIntegratedFlow(TH1F* i, TH1F* j)
void SetOnTheFlyResCorrection(TH1F* r2, TH1F* r3)
void SetEventPlaneWeights(TH1F* ep)
void SetAcceptanceWeights(Bool_t w)
void SetNameRhoSmall(TString name)
{fNameSmallRho = name; }
void SetRandomSeed(TRandom3* r)
{if (fRandom) delete fRandom; fRandom = r; }
void SetModulationFitMinMaxP(Float_t m, Float_t n)
{fMinPvalue = m; fMaxPvalue = n; }
void SetModulationFitType(AliAnalysisTaskJetV2::fitModulationType type)
void SetGoodnessTest(AliAnalysisTaskJetV2::fitGoodnessTest test)
{fFitGoodnessTest = test; }
void SetQCnRecoveryType(AliAnalysisTaskJetV2::qcRecovery type)
{fQCRecovery = type; }
void SetModulationFitOptions(TString opt)
void SetReferenceDetector(AliAnalysisTaskJetV2::detectorType type)
{fDetectorType = type; }
void SetAnalysisType(AliAnalysisTaskJetV2::analysisType type)
{fAnalysisType = type; }
void SetCollisionType(AliAnalysisTaskJetV2::collisionType type)
{fCollisionType = type; }
void SetUsePtWeight(Bool_t w)
void SetUsePtWeightErrorPropagation(Bool_t w)
void SetRunModeType(AliAnalysisTaskJetV2::runModeType type)
{fRunModeType = type; }
void SetAbsVertexZ(Float_t v)
{fAbsVertexZ = v; }
void SetMinDistanceRctoLJ(Float_t m)
void SetMaxNoRandomCones(Int_t m)
{fMaxCones = m; }
void SetExcludeLeadingJetsFromFit(Float_t n)
void SetRebinSwapHistoOnTheFly(Bool_t r)
void SetSaveThisPercentageOfFits(Float_t p)
 setters specific to the vzero calibration for 10h data
void SetVZEROApol(Int_t ring, Float_t f)
{fVZEROApol[ring]=f;}
void SetVZEROCpol(Int_t ring, Float_t f)
{fVZEROCpol[ring]=f;}
void SetVZEROgainEqualizationPerRing(Bool_t s)
void SetUseVZERORing(Int_t i, Bool_t u)
 exclude vzero rings: 0 through 7 can be excluded by calling this setter multiple times
 0 corresponds to segment ID 0 through 7, etc
void SetChi2VZEROA(TArrayD* a)
{ fChi2A = a;}
void SetChi2VZEROC(TArrayD* a)
{ fChi2C = a;}
void SetChi3VZEROA(TArrayD* a)
{ fChi3A = a;}
void SetChi3VZEROC(TArrayD* a)
{ fChi3C = a;}
TString GetJetsName() const
 getters
TString GetTracksName() const
TString GetLocalRhoName() const
{return fLocalRhoName; }
TArrayD* GetCentralityClasses() const
TProfile* GetResolutionParameters(Int_t h, Int_t c) const
{return (h==2) ? fProfV2Resolution[c] : fProfV3Resolution[c];}
TList* GetOutputList() const
{return fOutputList;}
AliLocalRhoParameter* GetLocalRhoParameter() const
{return fLocalRho;}
Double_t GetJetRadius() const
void ExecMe()
AliAnalysisTaskJetV2* ReturnMe()
 local cuts
{return this;}
void SetSoftTrackMinMaxPt(Float_t min, Float_t max)
void SetSemiGoodJetMinMaxPhi(Double_t a, Double_t b)
void SetSemiGoodTrackMinMaxPhi(Double_t a, Double_t b)
 numerical evaluations
Bool_t PassesCuts(AliVEvent* event)
Bool_t PassesCuts(const AliVCluster* track) const
 filling histograms
void SetOutputList(TList* l)
 interface methods for the output file
AliAnalysisTaskJetV2& operator=(const AliAnalysisTaskJetV2& )