From 9dc4f67156363014c7922fb09d235a5e850aba9e Mon Sep 17 00:00:00 2001 From: lmilano Date: Fri, 26 Sep 2014 15:28:31 +0200 Subject: [PATCH] JCORRAN code update from DongJo --- PWGCF/Correlations/JCORRAN/AliJBaseCard.cxx | 279 ++++ PWGCF/Correlations/JCORRAN/AliJBaseCard.h | 102 ++ .../JCORRAN/AliJBaseEventHeader.cxx | 56 +- .../JCORRAN/AliJBaseEventHeader.h | 17 + PWGCF/Correlations/JCORRAN/AliJBaseTrack.cxx | 74 +- PWGCF/Correlations/JCORRAN/AliJBaseTrack.h | 125 +- PWGCF/Correlations/JCORRAN/AliJCORRAN.cxx | 793 ++++++++++++ PWGCF/Correlations/JCORRAN/AliJCORRAN.h | 163 +++ PWGCF/Correlations/JCORRAN/AliJCORRANTask.cxx | 982 ++------------ PWGCF/Correlations/JCORRAN/AliJCORRANTask.h | 94 +- PWGCF/Correlations/JCORRAN/AliJCard.cxx | 349 +++++ PWGCF/Correlations/JCORRAN/AliJCard.h | 201 +++ PWGCF/Correlations/JCORRAN/AliJConst.h | 71 +- .../Correlations/JCORRAN/AliJCorrelations.cxx | 721 +++++++++++ PWGCF/Correlations/JCORRAN/AliJCorrelations.h | 135 ++ .../Correlations/JCORRAN/AliJDataManager.cxx | 431 +++++++ PWGCF/Correlations/JCORRAN/AliJDataManager.h | 155 +++ .../JCORRAN/AliJDiHadronCorrTask.cxx | 177 +++ .../JCORRAN/AliJDiHadronCorrTask.h | 54 + PWGCF/Correlations/JCORRAN/AliJEfficiency.cxx | 209 +++ PWGCF/Correlations/JCORRAN/AliJEfficiency.h | 65 + .../JCORRAN/AliJEfficiencyScanner.cxx | 560 ++++++++ .../JCORRAN/AliJEfficiencyScanner.h | 143 +++ .../JCORRAN/AliJEfficiencyTask.cxx | 160 +++ .../Correlations/JCORRAN/AliJEfficiencyTask.h | 53 + .../Correlations/JCORRAN/AliJEventHeader.cxx | 51 +- PWGCF/Correlations/JCORRAN/AliJEventHeader.h | 48 +- PWGCF/Correlations/JCORRAN/AliJEventPool.cxx | 227 ++++ PWGCF/Correlations/JCORRAN/AliJEventPool.h | 99 ++ PWGCF/Correlations/JCORRAN/AliJFilter.cxx | 1143 +++++++++++++++++ PWGCF/Correlations/JCORRAN/AliJFilter.h | 222 ++++ .../Correlations/JCORRAN/AliJHistManager.cxx | 879 +++++++++++++ PWGCF/Correlations/JCORRAN/AliJHistManager.h | 423 ++++++ PWGCF/Correlations/JCORRAN/AliJHistos.cxx | 1082 ++++++++++++++++ PWGCF/Correlations/JCORRAN/AliJHistos.h | 334 +++++ PWGCF/Correlations/JCORRAN/AliJJet.cxx | 56 + PWGCF/Correlations/JCORRAN/AliJJet.h | 56 + PWGCF/Correlations/JCORRAN/AliJMCTrack.cxx | 14 +- PWGCF/Correlations/JCORRAN/AliJMCTrack.h | 15 +- PWGCF/Correlations/JCORRAN/AliJPhoton.cxx | 174 ++- PWGCF/Correlations/JCORRAN/AliJPhoton.h | 158 ++- PWGCF/Correlations/JCORRAN/AliJPiZero.cxx | 185 +++ PWGCF/Correlations/JCORRAN/AliJPiZero.h | 85 ++ PWGCF/Correlations/JCORRAN/AliJRunHeader.cxx | 157 +-- PWGCF/Correlations/JCORRAN/AliJRunHeader.h | 187 ++- PWGCF/Correlations/JCORRAN/AliJRunTable.cxx | 208 +++ PWGCF/Correlations/JCORRAN/AliJRunTable.h | 68 + PWGCF/Correlations/JCORRAN/AliJTrack.cxx | 44 +- PWGCF/Correlations/JCORRAN/AliJTrack.h | 74 +- .../Correlations/JCORRAN/AliJTrackCounter.cxx | 88 ++ PWGCF/Correlations/JCORRAN/AliJTrackCounter.h | 93 ++ PWGCF/Correlations/JCORRAN/AliJTrackCut.cxx | 130 ++ PWGCF/Correlations/JCORRAN/AliJTrackCut.h | 26 + .../macros/jcorran/AddTaskJCORRANFilter.C | 84 ++ .../macros/jcorran/AddTaskJDiHadronCorr.C | 42 + .../macros/jcorran/cardAlice_pp.input | 72 ++ 56 files changed, 11312 insertions(+), 1381 deletions(-) create mode 100644 PWGCF/Correlations/JCORRAN/AliJBaseCard.cxx create mode 100644 PWGCF/Correlations/JCORRAN/AliJBaseCard.h mode change 100755 => 100644 PWGCF/Correlations/JCORRAN/AliJBaseEventHeader.cxx mode change 100755 => 100644 PWGCF/Correlations/JCORRAN/AliJBaseEventHeader.h mode change 100755 => 100644 PWGCF/Correlations/JCORRAN/AliJBaseTrack.cxx mode change 100755 => 100644 PWGCF/Correlations/JCORRAN/AliJBaseTrack.h create mode 100644 PWGCF/Correlations/JCORRAN/AliJCORRAN.cxx create mode 100644 PWGCF/Correlations/JCORRAN/AliJCORRAN.h mode change 100755 => 100644 PWGCF/Correlations/JCORRAN/AliJCORRANTask.cxx mode change 100755 => 100644 PWGCF/Correlations/JCORRAN/AliJCORRANTask.h create mode 100644 PWGCF/Correlations/JCORRAN/AliJCard.cxx create mode 100644 PWGCF/Correlations/JCORRAN/AliJCard.h mode change 100755 => 100644 PWGCF/Correlations/JCORRAN/AliJConst.h create mode 100644 PWGCF/Correlations/JCORRAN/AliJCorrelations.cxx create mode 100644 PWGCF/Correlations/JCORRAN/AliJCorrelations.h create mode 100644 PWGCF/Correlations/JCORRAN/AliJDataManager.cxx create mode 100644 PWGCF/Correlations/JCORRAN/AliJDataManager.h create mode 100644 PWGCF/Correlations/JCORRAN/AliJDiHadronCorrTask.cxx create mode 100644 PWGCF/Correlations/JCORRAN/AliJDiHadronCorrTask.h create mode 100644 PWGCF/Correlations/JCORRAN/AliJEfficiency.cxx create mode 100644 PWGCF/Correlations/JCORRAN/AliJEfficiency.h create mode 100644 PWGCF/Correlations/JCORRAN/AliJEfficiencyScanner.cxx create mode 100644 PWGCF/Correlations/JCORRAN/AliJEfficiencyScanner.h create mode 100644 PWGCF/Correlations/JCORRAN/AliJEfficiencyTask.cxx create mode 100644 PWGCF/Correlations/JCORRAN/AliJEfficiencyTask.h mode change 100755 => 100644 PWGCF/Correlations/JCORRAN/AliJEventHeader.cxx mode change 100755 => 100644 PWGCF/Correlations/JCORRAN/AliJEventHeader.h create mode 100644 PWGCF/Correlations/JCORRAN/AliJEventPool.cxx create mode 100644 PWGCF/Correlations/JCORRAN/AliJEventPool.h create mode 100644 PWGCF/Correlations/JCORRAN/AliJFilter.cxx create mode 100644 PWGCF/Correlations/JCORRAN/AliJFilter.h create mode 100644 PWGCF/Correlations/JCORRAN/AliJHistManager.cxx create mode 100644 PWGCF/Correlations/JCORRAN/AliJHistManager.h create mode 100644 PWGCF/Correlations/JCORRAN/AliJHistos.cxx create mode 100644 PWGCF/Correlations/JCORRAN/AliJHistos.h create mode 100644 PWGCF/Correlations/JCORRAN/AliJJet.cxx create mode 100644 PWGCF/Correlations/JCORRAN/AliJJet.h mode change 100755 => 100644 PWGCF/Correlations/JCORRAN/AliJMCTrack.cxx mode change 100755 => 100644 PWGCF/Correlations/JCORRAN/AliJMCTrack.h create mode 100644 PWGCF/Correlations/JCORRAN/AliJPiZero.cxx create mode 100644 PWGCF/Correlations/JCORRAN/AliJPiZero.h mode change 100755 => 100644 PWGCF/Correlations/JCORRAN/AliJRunHeader.cxx mode change 100755 => 100644 PWGCF/Correlations/JCORRAN/AliJRunHeader.h create mode 100644 PWGCF/Correlations/JCORRAN/AliJRunTable.cxx create mode 100644 PWGCF/Correlations/JCORRAN/AliJRunTable.h mode change 100755 => 100644 PWGCF/Correlations/JCORRAN/AliJTrack.cxx mode change 100755 => 100644 PWGCF/Correlations/JCORRAN/AliJTrack.h create mode 100644 PWGCF/Correlations/JCORRAN/AliJTrackCounter.cxx create mode 100644 PWGCF/Correlations/JCORRAN/AliJTrackCounter.h create mode 100644 PWGCF/Correlations/JCORRAN/AliJTrackCut.cxx create mode 100644 PWGCF/Correlations/JCORRAN/AliJTrackCut.h create mode 100755 PWGCF/Correlations/macros/jcorran/AddTaskJCORRANFilter.C create mode 100755 PWGCF/Correlations/macros/jcorran/AddTaskJDiHadronCorr.C create mode 100644 PWGCF/Correlations/macros/jcorran/cardAlice_pp.input diff --git a/PWGCF/Correlations/JCORRAN/AliJBaseCard.cxx b/PWGCF/Correlations/JCORRAN/AliJBaseCard.cxx new file mode 100644 index 00000000000..5297ae7c87a --- /dev/null +++ b/PWGCF/Correlations/JCORRAN/AliJBaseCard.cxx @@ -0,0 +1,279 @@ +//==================================== +//last modified FK 6.NOV 2009 +//==================================== +//blah +// blah + +#include "AliJConst.h" +#include "AliJBaseCard.h" + +//ClassImp(AliJBaseCard); + +AliJBaseCard::AliJBaseCard() : + fnentry(0), + fKeyWordVector(0), + fValuesVector(0), + fValueString(0), + fKeyTable(0) +{ + //constructor +} + +AliJBaseCard::AliJBaseCard(const char *filename) : + fnentry(0), + fKeyWordVector(0), + fValuesVector(0), + fValueString(0), + fKeyTable(0) +{ + //constructor + + strcpy(fcardname, filename); //needed in PrintOut() + + if( strlen( filename ) > 0 ){ + + //---- r e a d t h e c a r d ---- + ReadInputCard();//read config file fill Tvectors + } +} + + +AliJBaseCard& AliJBaseCard::operator=(const AliJBaseCard& obj){ + // equal operator + JUNUSED(obj); + return *this; +} + +AliJBaseCard::~AliJBaseCard(){ + // destructor +} + + +unsigned int AliJBaseCard::GetTVectorIndex(TString keyword, int tol){ + + // //returns findex of a TVector according to its position in std::hash_map + // std::hash_map< TString, unsigned int >::iterator iter = MapKeyWordToTVector.begin(); + // iter = MapKeyWordToTVector.find(keyword); + // if(iter != MapKeyWordToTVector.end()){ + // return (unsigned int) iter->second; + // }else{ + // cout << "ERROR: \""<GetUniqueID(); + if( ind == -1 ){ + for( UInt_t ii=0;ii not found!"< 1000){//is the file reasonably long? + cout<<"Maximum number of 1000 lines reached in AliJBaseCard.C"<0){ + tstr.Remove(startOFcomment,tstr.Length() - startOFcomment); + } + + //remove white spaces from the begining + if(tstr.BeginsWith(" ")){ + Ssiz_t startOFkeyword = 0; + while(1){ + TString s = tstr[startOFkeyword]; + if(s.CompareTo(" ")) break; + startOFkeyword++; + } + tstr.Replace(0,startOFkeyword,"",0); + } + + //separate inputs + TObjArray *lineContents = tstr.Tokenize(" "); + + if(lineContents->GetEntriesFast() < 1) return;//skipp empty lines + + //----- Read a keyword ----- + TString entryname = ((TObjString*)(lineContents->At(0)))->String(); //read a key word + + if(lineContents->GetEntriesFast() == 1){ + cout<<"WARNING: single keyword "< items;//auxiliary vector + + for(int i=1; iGetEntriesFast(); i++){ //loop over the numbers + TString token = ((TObjString*)(lineContents->At(i)))->String();//read a string + + if(token.IsFloat()){ + items.push_back(token.Atof());//if string is float number store it to vector + }else{ + items.push_back(0); + // cout<<"ERROR: char "<At(1)))->String() ); + + // MapKeyWordToTVector.insert(pair(entryname.Data(),fKeyWordVector.size()-1)); + AddToKeyTable( entryname, fValuesVector.size()-1 ); + + + }//else + + lineContents->~TObjArray();//remove array from heap +} + +void AliJBaseCard::PrintOut(){ + // echo + cout<GetDirectory("JCard")) { + file->mkdir("JCard");//directory to store input parameters + } + file->cd("JCard"); + for(unsigned int i=0;i + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace std; +#ifndef AliJMaxDimBuffer +#define AliJMaxDimBuffer +const int kMaxDimBuffer = 300;//max length of a line read to a buffe +#endif + +class AliJBaseCard { + + //==== M e m b e r F u n c t i o n s ======== + +public: + + AliJBaseCard(); // constructor + AliJBaseCard(const char *filename); // constructor + AliJBaseCard& operator=(const AliJBaseCard& obj); + + virtual ~AliJBaseCard(); + + void AddToKeyTable( TString key, int index ){ + TNamed * ko = new TNamed(key.Data(),""); + ko->SetUniqueID(index); + fKeyTable.Add(ko);// TODO check duplicate + } + + float Get(TString keyword, int VectorComponent=0); //get TVector component + TString GetStr(TString keyword ); //get TVector component + TVector* GetVector( TString keyword ); + int GetN(TString keyword); //get TVector dimension + void PrintOut(); + void WriteCard(TDirectory *file); + + virtual void InitCard(); + void FinishCard(); + void ReadInputLine( const char* buffer ); + +protected: + void ReadInputCard(); + + int GetNwithIndex(int i){ return fValuesVector[i].GetNrows(); } + + unsigned int GetTVectorIndex(TString keyword, int tol=0); + + //==== D a t a M e m b e r s ======== + + char fcardname[255]; // file name + int fnentry; //Number of lines in cfg file + std::vector< TString > fKeyWordVector; //array of key words + std::vector< TVector > fValuesVector; //array of float number confg parameter vectors + std::vector< TString > fValueString; // Storage of raw inut string for each item + //std::map< TString, unsigned int > MapKeyWordToTVector;//mapping keywords to TVector + THashList fKeyTable; // key map with hash algorithm + + //ClassDef(AliJBaseCard, 1); // EMCAL for jcorran +}; + +#endif + + + + + + + + + + + + + + + + + + + + + + diff --git a/PWGCF/Correlations/JCORRAN/AliJBaseEventHeader.cxx b/PWGCF/Correlations/JCORRAN/AliJBaseEventHeader.cxx old mode 100755 new mode 100644 index fb1f7753ca7..39ccff63862 --- a/PWGCF/Correlations/JCORRAN/AliJBaseEventHeader.cxx +++ b/PWGCF/Correlations/JCORRAN/AliJBaseEventHeader.cxx @@ -1,27 +1,29 @@ /************************************************************************** -* Copyright(c) 1998-1999, 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 notifce * -* 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. * -**************************************************************************/ + * Copyright(c) 1998-2014, 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. * + **************************************************************************/ + +// Comment describing what this class does needed! // $Id: AliJBaseEventHeader.cxx,v 1.4 2008/05/08 13:44:45 djkim Exp $ //////////////////////////////////////////////////// // -// \file AliJBaseEventHeader.cc -// \brief -// \author J. Rak, D.J.Kim, R.Diaz, M.Bondila, Chang Yeong (University of Jyvaskyla) email: djkim@cc.jyu.fi -// \version $Revision: 1.4 $ -// \date $Date: 2008/05/08 13:44:45 $ +// \file AliJBaseEventHeader.cc +// \brief +// \author J. Rak, D.J.Kim, R.Diaz, M.Bondila, Chang Yeong (University of Jyvaskyla) email: djkim@cc.jyu.fi +// \version $Revision: 1.4 $ +// \date $Date: 2008/05/08 13:44:45 $ // // Base class for event headers //////////////////////////////////////////////////// @@ -39,7 +41,10 @@ AliJBaseEventHeader::AliJBaseEventHeader(): fVtxX(-999), fVtxY(-999), fVtxZ(-999), - fVtxZErr(-999) + fVtxZErr(-999), + fVtxMCX(9999), + fVtxMCY(9999), + fVtxMCZ(9999) { // default constructor } @@ -52,7 +57,10 @@ AliJBaseEventHeader::AliJBaseEventHeader(int eventid, float cent, float vtxz): fVtxX(-999), fVtxY(-999), fVtxZ(vtxz), - fVtxZErr(-999) + fVtxZErr(-999), + fVtxMCX(9999), + fVtxMCY(9999), + fVtxMCZ(9999) { //constructor } @@ -64,7 +72,10 @@ AliJBaseEventHeader::AliJBaseEventHeader(const AliJBaseEventHeader& a): fVtxX(a.fVtxX), fVtxY(a.fVtxY), fVtxZ(a.fVtxZ), - fVtxZErr(a.fVtxZErr) + fVtxZErr(a.fVtxZErr), + fVtxMCX(a.fVtxMCX), + fVtxMCY(a.fVtxMCY), + fVtxMCZ(a.fVtxMCZ) { //copy constructor } @@ -80,6 +91,9 @@ AliJBaseEventHeader& AliJBaseEventHeader::operator=(const AliJBaseEventHeader& fVtxY = header.fVtxY; fVtxZ = header.fVtxZ; fVtxZErr = header.fVtxZErr; + fVtxMCX = header.fVtxMCX; + fVtxMCY = header.fVtxMCY; + fVtxMCZ = header.fVtxMCZ; } return *this; diff --git a/PWGCF/Correlations/JCORRAN/AliJBaseEventHeader.h b/PWGCF/Correlations/JCORRAN/AliJBaseEventHeader.h old mode 100755 new mode 100644 index 578ccd80c93..768ea46d11b --- a/PWGCF/Correlations/JCORRAN/AliJBaseEventHeader.h +++ b/PWGCF/Correlations/JCORRAN/AliJBaseEventHeader.h @@ -1,3 +1,8 @@ +/* Copyright(c) 1998-2014, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +// Short comment describing what this class does needed! + // $Id: AliJBaseEventHeader.h,v 1.5 2008/05/08 13:44:45 djkim Exp $ //////////////////////////////////////////////////// @@ -35,6 +40,10 @@ class AliJBaseEventHeader : public TNamed { float GetZVertex() const {return fVtxZ;} float GetZVertexErr() const {return fVtxZErr;} + float GetXVertexMC() const {return fVtxMCX;} + float GetYVertexMC() const {return fVtxMCY;} + float GetZVertexMC() const {return fVtxMCZ;} + //setter void SetEventID(int evid) {fEventID=evid;} void SetCentrality(float cent) {fCentrality=cent;} @@ -44,6 +53,10 @@ class AliJBaseEventHeader : public TNamed { void SetZVertexErr(float vt) {fVtxZErr=vt;} void SetVertex(float x, float y, float z, float err){ fVtxX=x;fVtxY=y;fVtxZ=z;fVtxZErr=err; } + void SetXVertexMC(float vt) {fVtxMCX=vt;} + void SetYVertexMC(float vt) {fVtxMCY=vt;} + void SetZVertexMC(float vt) {fVtxMCZ=vt;} + AliJBaseEventHeader& operator=(const AliJBaseEventHeader& header); private: @@ -55,6 +68,10 @@ class AliJBaseEventHeader : public TNamed { Double32_t fVtxZ; //vertex Z Double32_t fVtxZErr; //vertex error + Double32_t fVtxMCX; //vertex X MC + Double32_t fVtxMCY; //vertex Y MC + Double32_t fVtxMCZ; //vertex Z MC + ClassDef(AliJBaseEventHeader,1) }; diff --git a/PWGCF/Correlations/JCORRAN/AliJBaseTrack.cxx b/PWGCF/Correlations/JCORRAN/AliJBaseTrack.cxx old mode 100755 new mode 100644 index dd764652a24..e5473b0d0a9 --- a/PWGCF/Correlations/JCORRAN/AliJBaseTrack.cxx +++ b/PWGCF/Correlations/JCORRAN/AliJBaseTrack.cxx @@ -1,3 +1,20 @@ +/************************************************************************** + * Copyright(c) 1998-2014, 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. * + **************************************************************************/ + +// Comment describing what this class does needed! + // $Id: AliJBaseTrack.cxx,v 1.5 2008/05/08 15:19:52 djkim Exp $ //////////////////////////////////////////////////// /*! @@ -10,18 +27,21 @@ */ //////////////////////////////////////////////////// -#include -#include #include "AliJBaseTrack.h" //______________________________________________________________________________ AliJBaseTrack::AliJBaseTrack(): fID(-1), - fLabel(-1), + fLabel(-9999), fParticleType(-1), fCharge(0), fStatus(0), - fFlags(0) + fFlags(0), + fTriggID(-1), + fAssocID(-1), + fTracEff(-1), + fMCIndex(-9999), + fWeight(1.0) { // constructor } @@ -30,11 +50,16 @@ AliJBaseTrack::AliJBaseTrack(): AliJBaseTrack::AliJBaseTrack(float px,float py, float pz, float e, Int_t id, Short_t ptype, Char_t charge): TLorentzVector( px, py, pz, e ), fID(id), - fLabel(-1), + fLabel(-9999), fParticleType(ptype), fCharge(charge), fStatus(0), - fFlags(0) + fFlags(0), + fTriggID(-1), + fAssocID(-1), + fTracEff(-1), + fMCIndex(-9999), + fWeight(1.0) { // constructor } @@ -43,11 +68,16 @@ AliJBaseTrack::AliJBaseTrack(float px,float py, float pz, float e, Int_t id, Sho AliJBaseTrack::AliJBaseTrack(const AliJBaseTrack& a): TLorentzVector (a), fID (a.fID), - fLabel (a.fLabel), + fLabel (a.fLabel), fParticleType ( a.fParticleType ), fCharge ( a.fCharge ), fStatus ( a.fStatus ), - fFlags ( a.fFlags ) + fFlags ( a.fFlags ), + fTriggID( a.fTriggID ), + fAssocID( a.fAssocID ), + fTracEff( a.fTracEff ), + fMCIndex( a.fMCIndex ), + fWeight ( a.fWeight ) { //copy constructor } @@ -56,11 +86,16 @@ AliJBaseTrack::AliJBaseTrack(const AliJBaseTrack& a): AliJBaseTrack::AliJBaseTrack(const TLorentzVector& a): TLorentzVector (a), fID ( -1 ), - fLabel ( -1 ), + fLabel ( -9999 ), fParticleType ( -1 ), fCharge ( 0 ), fStatus ( 0 ), - fFlags ( 0 ) + fFlags ( 0 ), + fTriggID(-1), + fAssocID(-1), + fTracEff(-1), + fMCIndex(-9999), + fWeight(1.0) { //copy constructor } @@ -75,16 +110,31 @@ AliJBaseTrack& AliJBaseTrack::operator=(const AliJBaseTrack& trk){ fCharge = trk.fCharge; fStatus = trk.fStatus; fFlags = trk.fFlags; + fTriggID = trk.fTriggID; + fAssocID = trk.fAssocID; + fTracEff = trk.fTracEff; + fMCIndex = trk.fMCIndex; + fWeight = trk.fWeight; } return *this; } //_____________________________________________________________ -void AliJBaseTrack::Print(Option_t* option = "" ) const{ +void AliJBaseTrack::Print(Option_t *option) const{ //object print out + JUNUSED(option); std::cout<-AliJConst::kJPi/3 ? Phi() : AliJConst::kJTwoPi+Phi();} - TLorentzVector GetLorentzVector(){ return TLorentzVector( *this);} - - Int_t GetID() const { return fID;} - Int_t GetLabel() const { return fLabel; } - Short_t GetParticleType() const { return fParticleType;} - ULong_t GetStatus() const { return fStatus; } - Short_t GetCharge() const { return fCharge; } - UInt_t GetFlags() const { return fFlags; } - Bool_t GetIsIsolated() const { return IsTrue(kIsIsolated);} - - - void SetID (const int id){fID=id;} - void SetLabel (const Int_t label ){ fLabel=label; } - void SetParticleType(const Short_t ptype){ fParticleType=ptype; } - void SetStatus (const ULong_t status){ fStatus=status; } - void SetCharge (const Char_t charge){ fCharge=charge; } - void SetFlags (const UInt_t bits ){ fFlags=bits; } - void SetIsIsolated(Bool_t tf){ SetFlag( kIsIsolated, tf); } - - void Print(Option_t* option) const; - - // Handel BitsData - Bool_t IsTrue(int i ) const { return TESTBIT(fFlags, i); } - void SetFlag(int i, Bool_t t){ if(t){SETBIT(fFlags,i);}else{CLRBIT(fFlags, i);}} - - // Operators - AliJBaseTrack& operator=(const AliJBaseTrack& trk); - - protected: - Int_t fID; // Unique track ID - Int_t fLabel; // Unique track label for MC-Data relation - Short_t fParticleType; // ParticleType - Char_t fCharge; // track charge for real data - ULong_t fStatus; // reconstruction status flags or MC status - UInt_t fFlags; // store series of any boolen value. - - ClassDef(AliJBaseTrack,1) + public: + enum { kIsIsolated, kNFlag }; + AliJBaseTrack(); + AliJBaseTrack(float px,float py, float pz, float e, Int_t id, Short_t ptype, Char_t charge); // constructor + AliJBaseTrack(const AliJBaseTrack& a); + AliJBaseTrack(const TLorentzVector & a); + virtual ~AliJBaseTrack(){;} //destructor + + double EtaAbs(){ return TMath::Abs(Eta()); } + float GetTwoPiPhi() const {return Phi()>-kJPi/3 ? Phi() : kJTwoPi+Phi();} + TLorentzVector GetLorentzVector(){ return TLorentzVector(Px(), Py(), Pz(), E());} + + Int_t GetID() const { return fID;} + Int_t GetLabel() const { return fLabel; } + Short_t GetParticleType() const { return fParticleType;} + ULong_t GetStatus() const { return fStatus; } + Short_t GetCharge() const { return fCharge; } + UInt_t GetFlags() const { return fFlags; } + Bool_t GetIsIsolated() const { return IsTrue(kIsIsolated);} + + Int_t GetTriggBin() const { return fTriggID; } + Int_t GetAssocBin() const { return fAssocID; } + Double32_t GetTrackEff() const { + if(fTracEff==-1) { cout<<"AliJBaseTrack: Uninitilized track eff " <=0; } + Bool_t IsInAssocBin() const { return fAssocID>=0; } + Double_t GetWeight() const { return fWeight;} + Int_t GetMCIndex() const { return fMCIndex;} + + void SetID (const int id){fID=id;} + void SetLabel (const Int_t label ){ fLabel=label; } + void SetParticleType(const Short_t ptype){ fParticleType=ptype; } + void SetStatus (const ULong_t status){ fStatus=status; } + void SetCharge (const Char_t charge){ fCharge=charge; } + void SetFlags (const UInt_t bits ){ fFlags=bits; } //MC, is primary flag + void SetIsIsolated(Bool_t tf){ SetFlag( kIsIsolated, tf); } + + void SetTriggBin(const int id){fTriggID = id;} + void SetAssocBin(const int id){fAssocID = id;} + void SetTrackEff(const Double32_t inEff){fTracEff = inEff;} + + void SetWeight(Double_t weight) { fWeight = weight;} + void SetMCIndex(Int_t idx) { fMCIndex = idx;} + + virtual void Print(Option_t *option="") const; + + // Handel BitsData + Bool_t IsTrue(int i ) const { return TESTBIT(fFlags, i); } + void SetFlag(int i, Bool_t t){ if(t){SETBIT(fFlags,i);}else{CLRBIT(fFlags, i);}} + + // Operators + AliJBaseTrack& operator=(const AliJBaseTrack& trk); + + protected: + Int_t fID; // Unique track ID + Int_t fLabel; // Unique track label for MC-Data relation + Short_t fParticleType; // ParticleType + Char_t fCharge; // track charge for real data + ULong_t fStatus; // reconstruction status flags or MC status + UInt_t fFlags; // store series of any boolen value. + + Int_t fTriggID, fAssocID; //! //id of trigger and assoc particle + Double32_t fTracEff; //! //track efficiency + Int_t fMCIndex; //! //index of corresp. MC track + Double_t fWeight; //! //particle weight + + ClassDef(AliJBaseTrack,1) }; #endif diff --git a/PWGCF/Correlations/JCORRAN/AliJCORRAN.cxx b/PWGCF/Correlations/JCORRAN/AliJCORRAN.cxx new file mode 100644 index 00000000000..d0bafd23184 --- /dev/null +++ b/PWGCF/Correlations/JCORRAN/AliJCORRAN.cxx @@ -0,0 +1,793 @@ +/************************************************************************** + * Copyright(c) 1998-2014, 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. * + **************************************************************************/ + +// Comment describing what this class does needed! + +// jcorran main class +// used in local and grid execution +// blah +// blah +// blah + +#include +#include "AliJCORRAN.h" + +#include "AliJTrackCounter.h" +#include + +#include "AliJCard.h" +#include "AliJHistos.h" +#include "AliJCorrelations.h" +#include "AliJEventPool.h" +#include "AliJDataManager.h" + +#include "AliJEventHeader.h" +#include "AliJRunHeader.h" +#include "AliJTrack.h" +#include "AliJPhoton.h" +#include "AliJMCTrack.h" +#include "AliJConst.h" + + + + +#include "AliJEfficiency.h" +#include + +ClassImp(AliJCORRAN) + + AliJCORRAN::AliJCORRAN() : + TObject(), + fExecLocal(kTRUE), + fFirstEvent(kTRUE), + fjtrigg((particleType)-100), + fjassoc((particleType)-100), + fcard(0), + finputFile(0), + fInclusiveFile(""), + fevt(0), + fhistos(0), + fcorrelations(0), + fphotonPool(0), + fassocPool(0), + fphotonList(0), + fchargedHadronList(0), + fpizeroList(0), + ftriggList(0), + fassocList(0), + fpairList(0), + fpairCounterList(0), + finputList(0), + fdmg(0), + feventHeader(0), + frunHeader(0), + fnumberEvents(0), + fieout(0), + fEventCounter(0), + fcent(0), + fncBin(0), + fnPttBin(0), + fbTriggCorrel(0), + fbLPCorrel(0), + fbLPpairCorrel(0), + fTrackEtaRange(0), + flowerPtAssocBoarder(0), + fCentMultLow(0), + fCentMultHigh(0), + fEventBC(0), + fSQRTS(0), + fEfficiency(0), + fRunTable(0), + fIsolationR(0), + fHadronSelectionCut(0) +{ + // constructor +} + +AliJCORRAN::AliJCORRAN(Bool_t execLocal) : + TObject(), + fExecLocal(execLocal), + fFirstEvent(kTRUE), + fjtrigg((particleType)-100), + fjassoc((particleType)-100), + fcard(0), + finputFile(0), + fInclusiveFile(""), + fevt(0), + fhistos(0), + fcorrelations(0), + fphotonPool(0), + fassocPool(0), + fphotonList(0), + fchargedHadronList(0), + fpizeroList(0), + ftriggList(0), + fassocList(0), + fpairList(0), + fpairCounterList(0), + finputList(0), + fdmg(0), + feventHeader(0), + frunHeader(0), + fnumberEvents(0), + fieout(0), + fEventCounter(0), + fcent(0), + fncBin(0), + fnPttBin(0), + fbTriggCorrel(0), + fbLPCorrel(0), + fbLPpairCorrel(0), + fTrackEtaRange(0), + flowerPtAssocBoarder(0), + fCentMultLow(0), + fCentMultHigh(0), + fEventBC(0), + fSQRTS(0), + fEfficiency(0), + fRunTable(0), + fIsolationR(0), + fHadronSelectionCut(0) +{ + // constructor +} + +AliJCORRAN::~AliJCORRAN(){ + // destructor +} + +AliJCORRAN::AliJCORRAN(const AliJCORRAN& obj) : + TObject(), + fExecLocal(obj.fExecLocal), + fFirstEvent(obj.fFirstEvent), + fjtrigg(obj.fjtrigg), + fjassoc(obj.fjassoc), + fcard(obj.fcard), + finputFile(obj.finputFile), + fInclusiveFile(obj.fInclusiveFile), + fevt(obj.fevt), + fhistos(obj.fhistos), + fcorrelations(obj.fcorrelations), + fphotonPool(obj.fphotonPool), + fassocPool(obj.fassocPool), + fphotonList(obj.fphotonList), + fchargedHadronList(obj.fchargedHadronList), + fpizeroList(obj.fpizeroList), + ftriggList(obj.ftriggList), + fassocList(obj.fassocList), + fpairList(obj.fpairList), + fpairCounterList(obj.fpairCounterList), + finputList(obj.finputList), + fdmg(obj.fdmg), + feventHeader(obj.feventHeader), + frunHeader(obj.frunHeader), + fnumberEvents(obj.fnumberEvents), + fieout(obj.fieout), + fEventCounter(obj.fEventCounter), + fcent(obj.fcent), + fncBin(obj.fncBin), + fnPttBin(obj.fnPttBin), + fbTriggCorrel(obj.fbTriggCorrel), + fbLPCorrel(obj.fbLPCorrel), + fbLPpairCorrel(obj.fbLPpairCorrel), + fTrackEtaRange(obj.fTrackEtaRange), + flowerPtAssocBoarder(obj.flowerPtAssocBoarder), + fCentMultLow(obj.fCentMultLow), + fCentMultHigh(obj.fCentMultHigh), + fEventBC(obj.fEventBC), + fSQRTS(obj.fSQRTS), + fEfficiency(obj.fEfficiency), + fRunTable(obj.fRunTable), + fIsolationR(obj.fIsolationR), + fHadronSelectionCut(obj.fHadronSelectionCut) +{ + // copy constructor + JUNUSED(obj); +} + +AliJCORRAN& AliJCORRAN::operator=(const AliJCORRAN& obj){ + // copy constructor + JUNUSED(obj); + return *this; +} + + +void AliJCORRAN::Initialize() const{ + // init + +} + +void AliJCORRAN::UserCreateOutputObjects(){ + // local init + + + cout << "jcorran user create output objects ----------------" << endl; + + fHadronSelectionCut =int ( fcard->Get("HadronSelectionCut")); + fIsolationR = fcard->Get("IsolationR"); + + fhistos = new AliJHistos( fcard ); + fhistos->CreateEventTrackHistos(); + fhistos->CreateAzimuthCorrHistos(); + fhistos->CreateIAAMoons(); + fhistos->CreateXEHistos(); + fhistos->CreateXtHistos(); + fhistos->CreatePairPtCosThetaStar(); + + fhistos->fHMG->Print(); + + fEventBC = (Int_t)(fcard->Get( "eventBC" )); + fSQRTS = 0.; + + + //TODO: inclusive fhistos shipping along + + fcorrelations = new AliJCorrelations( fcard, fhistos); + cout<ReadInclusiveHistos(fInclusiveFile); + fcorrelations->SetSampligInclusive(); //kperp background and triangle. Default is flat + cout<<"Sampling kperp and triangle from " << fInclusiveFile <SetExecLocal( fExecLocal ); + + //==== Read the Data files ===== + if( fExecLocal ){ + fdmg->ChainInputStream(finputFile); + // TODO: run header is not supposed to be here + // doesn't work fSQRTS = 2.*frunHeader->GetBeamEnergy(); + + // for grid running, numberEvents is filled by the encapsulating + // grid task, which has access to the input handlers and can + // extract event numbers out of it + fnumberEvents = fdmg->GetNEvents(); + fieout = fnumberEvents/20; + frunHeader = fdmg->GetRunHeader(); + cout<<"RunID = "<GetRunNumber()<< " Looping over "<SetRunHeader( frunHeader ); + frunHeader = fdmg->GetRunHeader(); + } + + //==== Efficiency ==== + fEfficiency = new AliJEfficiency; + fEfficiency->SetMode( fcard->Get("EfficiencyMode") ); // 0:NoEff, 1:Period 2:RunNum 3:Auto + + //------------------------------------------------------------------- + fEventCounter=0; + + fcent = -1; + fncBin = fcard->GetNoOfBins( kCentrType ); + fnPttBin = fcard->GetNoOfBins( kTriggType ); + + fbTriggCorrel = fcard->Get("CorrelationType")==0; + fbLPCorrel = fcard->Get("CorrelationType")==1; + fbLPpairCorrel = fcard->Get("CorrelationType")==2; + fTrackEtaRange = fcard->Get("EtaRange"); + flowerPtAssocBoarder = fcard->GetBinBorder(kAssocType, 0); + + //==== Limit the no of track for each fcentrality ====== + fCentMultLow = new TF1("fCentMultLow","[0]*sqrt([1]-x)+[2]", 0, 75); + fCentMultHigh = new TF1("fCentMultHigh","[0]*sqrt([1]-x)+[2]", 0, 90); + + // fast parameter load + + + fhistos->fHMG->WriteConfig(); + fFirstEvent = kTRUE; + fevt = -1; + + cout << "end of jcorran user create output objects ----------------" << endl; + +} + +void AliJCORRAN::UserExec(){ + // event loop + fevt++; + + // TODO Add train mode if( !fExecLocal && fFirstEvent ){ + if( 0 && !fExecLocal && fFirstEvent ){ + fdmg->ChainInputStream(""); + fieout = fnumberEvents/20; + if (fieout<1) fieout=1; + cout<<"RunID = "<GetRunNumber()<< " Looping over "<fhEventPerRun->Fill(fnumberEvents>0?log(fnumberEvents):1); + fFirstEvent = kFALSE; + } + + // TODO + if( fExecLocal ) { + if(fevt % fieout == 0) cout << fevt << "\t" << int(float(fevt)/fnumberEvents*100) << "%" << endl ; + } + + if( fFirstEvent ) { + //==== RunTable + fRunTable = & AliJRunTable::GetSpecialInstance(); + fRunTable->SetRunNumber( frunHeader->GetRunNumber() ); + fSQRTS = fRunTable->GetBeamEnergy(fRunTable->GetPeriod()); + cout << "sqrts = "<< fSQRTS << ",runnumber = "<< frunHeader->GetRunNumber() << endl; + fEfficiency->SetRunNumber( frunHeader->GetRunNumber() ); + TString effTag = fcard->GetStr("EfficiencyTag"); + + if( effTag.Length() > 0 ){ + fEfficiency->SetTag( effTag ); + } + fEfficiency->Load(); + fFirstEvent = kFALSE; + } + + if(fRunTable->IsHeavyIon()){ + fCentMultLow->SetParameters( fcard->Get("CentMultCutLow",0), fcard->Get("CentMultCutLow",1), fcard->Get("CentMultCutLow",2) ); + fCentMultHigh->SetParameters(fcard->Get("CentMultCutHigh",0), fcard->Get("CentMultCutHigh",1), fcard->Get("CentMultCutHigh",2) ); + //fCentMultLow->Print(); + //fCentMultHigh->Print(); + } + + fdmg->LoadEvent(fevt); // to be here to load EventHeader + fhistos->fhEvents->Fill( 0 ); + + if(!fdmg->IsGoodEvent()) return; // Vertex cut applied in IsGoodEvent and histo saved there too + + feventHeader = fdmg->GetEventHeader(); + double zVert = feventHeader->GetZVertex(); + //---------------------------------------------------------- + + UInt_t triggermaskJCorran = feventHeader->GetTriggerMaskJCorran(); + //cout << fevt <<"\t"<< zVert << "\t"<< triggermaskJCorran << endl; + + if( fdmg->IsSelectedTrigger((int) triggermaskJCorran)) + fhistos->fhEvents->Fill( 5 ); + + // select only some BC%4 + if( feventHeader->GetBunchCrossNumber() % 4 != fEventBC && + fEventBC > -1 ) + return; + + if( fdmg->IsSelectedTrigger((int) triggermaskJCorran)) + fhistos->fhEvents->Fill( 6 ); + + if(fRunTable->IsHeavyIon() || fRunTable->IsPA()){ + fcent = feventHeader->GetCentrality(); + }else { + fcent = 1; //ntracks; + } + + //cout<<"evt="<Pt() <<" "<< fabs(ftk1->Eta() - ftk2->Eta()) <<" "<< 2*fdphi <<" "<< 3*fdphi <0 ? vdelta[0]/vdeltaNorm : 0; + vdelta[1] = vdeltaNorm>0 ? vdelta[1]/vdeltaNorm : 0; + fhistos->fhVdelta2[cBin]->Fill(vdelta[0]*100); + fhistos->fhVdelta3[cBin]->Fill(vdelta[1]*100); + if(vdelta[0]>0) fhistos->fpV2->Fill( fcent, sqrt(vdelta[0])*100 ); + if(vdelta[1]>0) { + fhistos->fpV3->Fill( fcent, sqrt(vdelta[1])*100 ); + fcard->SetEventV3kv(vdelta[1]); + } + fhistos->fpVdeltaNorm->Fill( fcent, vdeltaNorm ); + } + + //---------------------------------------------------- + //----- Generate trigg list and find LP -- + //----- Fiducial cut should be used in AliJCorrelations-- + //---------------------------------------------------- + AliJTrackCounter *lpTrackCounter = new AliJTrackCounter(), *lpPairCounter = new AliJTrackCounter(); + AliJBaseTrack *lPTr = NULL; + int noTriggs=0; + ftriggList->Clear(); + for(int itrack=0; itrackAt(itrack); + triggTr->SetTriggBin( fcard->GetBin(kTriggType, triggTr->Pt()) ); + + double ptt = triggTr->Pt(); + double etat = triggTr->Eta(); + //TODO iCut == 0; + + double effCorr = 1.0/triggTr->GetTrackEff(); + + if( ptt>flowerPtAssocBoarder ){ + //FK//double effCorr = 1./fcard->TrackEfficiency(ptt, fcent); // here you generate warning if ptt>30 + //double effCorr = 1./fcard->TrackEfficiency(ptt, etat, cBin); // here you generate warning if ptt>30 + fhistos->fhChargedPt[cBin]->Fill(ptt, effCorr ); + fhistos->fhChargedPtNoCorr[cBin]->Fill( ptt ); + fhistos->fhChargedEta->Fill(triggTr->Eta(), effCorr); + //fhistos->fhChargedPtJacek[cBin]->Fill(ptt, effCorr ); + fhistos->fhChargedPtJacek[cBin]->Fill(ptt, ptt>0 ? 1./ptt*effCorr : 0); //One CANNOT do 1/ptt here!! First unfold. + if( -0.8fhChargedPtJacekEta[cBin][0]->Fill(ptt, ptt>0 ? 1./ptt*effCorr : 0); + if( -0.2fhChargedPtJacekEta[cBin][1]->Fill(ptt, ptt>0 ? 1./ptt*effCorr : 0); + if( 0.3fhChargedPtJacekEta[cBin][2]->Fill(ptt, ptt>0 ? 1./ptt*effCorr : 0); + fhistos->fhChargedPtFiete->Fill(ptt, effCorr ); + } + + if( !triggTr->IsInTriggerBin() ) continue; + //FK//triggTr->SetTrackEff( fcard->TrackEfficiency(triggTr->Pt(), fcent) ); + int iptt = triggTr->GetTriggBin(); + fhistos->fhIphiTrigg[cBin][iptt]->Fill( triggTr->Phi(), effCorr); + fhistos->fhIetaTrigg[cBin][iptt]->Fill( triggTr->Eta(), effCorr); + + if( ptt > lpTrackCounter->Pt() ) { + lpTrackCounter->Store(noTriggs, ptt, iptt); + lPTr = triggTr; + } + //cout <<"1 ptt="<< triggTr->Pt() <<" bin="<< triggTr->GetTriggBin() << " st=" << triggTr->GetStatus() << " trigg eff=" << triggTr->GetTrackEff() << endl; + new ((*ftriggList)[noTriggs++]) AliJBaseTrack(*triggTr); + fhistos->fhTriggMult[cBin][iptt]->Fill(noAllTriggTracks); + } + + //---------------------------------------------------- + //----- Find sum of two leading particles ------------ + //---------------------------------------------------- + if(fbLPpairCorrel){ + int noPairs=0; + fpairList->Clear(); + fpairCounterList->Clear(); + for(int ii=0;iiAt(ii); + for(int jj=ii+1;jjAt(jj); + TLorentzVector lVPair = triggTr1->GetLorentzVector()+triggTr2->GetLorentzVector(); + double fdphi = DeltaPhi(triggTr1->Phi(), triggTr2->Phi()); + new ((*fpairList)[noPairs]) AliJBaseTrack(lVPair); + new ((*fpairCounterList)[noPairs++]) + AliJTrackCounter( triggTr1->GetID(), triggTr2->GetID(), ii, jj, fdphi ); + } + } + + // ----- Find the Leading Pair -------------------------- + AliJBaseTrack *pairTr = NULL; + for(int ii=0;iiAt(ii); + AliJTrackCounter *pairCounter = (AliJTrackCounter*)fpairCounterList->At(ii); + //cout<Pt()<Print(); + if(pairTr->Pt() > lpPairCounter->Pt() && fabs(pairCounter->GetPairDPhi())<1.0) { + int iptt = fcard->GetBin(kTriggType, pairTr->Pt()); + lpPairCounter = pairCounter; + lpPairCounter->Store(ii, pairTr->Pt(), iptt); + } + } + if(lpPairCounter->Exists()){ + pairTr->SetParticleType(kHadron); + //double effCorr = 1./fcard->TrackEfficiency(lpTrackCounter->GetLPpt()); + fhistos->fhLPpairPt->Fill(pairTr->Pt()); + } + } + + //-------------------------------------------------- + //--- Generate assoc list and pool --- + //-------------------------------------------------- + fassocList->Clear(); + int noAssocs=0; + double sumPtAroundLP = 0; + if(fjassoc==kPizero) finputList = fpizeroList; + else if(fjassoc==kHadron) finputList = fchargedHadronList; + else if(fjassoc==kPhoton) finputList = fphotonList; + + int noAllAssocTracks = finputList->GetEntries(); + + + for(int itrack=0;itrackAt(itrack); + assocTr->SetAssocBin( fcard->GetBin(kAssocType, assocTr->Pt()) ); + + if(assocTr->IsInAssocBin()){ + + int ipta = assocTr->GetAssocBin(); + double effCorr = 1.0/assocTr->GetTrackEff(); + fhistos->fhIphiAssoc[cBin][ipta]->Fill( assocTr->Phi(), effCorr); + fhistos->fhIetaAssoc[cBin][ipta]->Fill( assocTr->Eta(), effCorr); + new ((*fassocList)[noAssocs++]) AliJBaseTrack(*assocTr); + } + // determine an activity in the cone around trigger + if(lpTrackCounter->Exists() && (lPTr->GetID()!=assocTr->GetID()) && (0.5 < assocTr->Pt())){ + double dPhi = DeltaPhi( assocTr->Phi(), lPTr->Phi() ); + double dEta = assocTr->Eta() - lPTr->Eta(); + if(fIsolationR > sqrt(dPhi*dPhi+dEta*dEta)) sumPtAroundLP += assocTr->Pt();//FK// + } + } + + FillXtHistos(finputList, lpTrackCounter); + + //----------------------------------------------- + // Set the isolation flag + //----------------------------------------------- + if( lpTrackCounter->Exists() ){ + //double effCorr = 1./fcard->TrackEfficiency(lpTrackCounter->Pt(), fcent); + //TODO ??? AGAIN AGAIN??? + double effCorr = 1./fEfficiency->GetCorrection(lpTrackCounter->Pt(), fHadronSelectionCut, fcent ); + fhistos->fhLPpt->Fill(lpTrackCounter->Pt(), effCorr); + fhistos->fhLPeta->Fill(lPTr->Eta(), effCorr); + fhistos->fhBkgActivity[lpTrackCounter->GetPtBin()]->Fill(sumPtAroundLP/lpTrackCounter->Pt()); + + if( sumPtAroundLP/lpTrackCounter->Pt()< fcard->GetCutOnBkgActivity() && ///relative activity + ( fabs(lPTr->Eta()) < (fTrackEtaRange - fIsolationR) ) ){ //fiducial cut + + fhistos->fhIsolatedLPpt->Fill(lpTrackCounter->Pt(), effCorr ); + + AliJBaseTrack* lpTrigger = (AliJBaseTrack*) ftriggList->At(lpTrackCounter->GetIndex()); + lpTrigger->SetIsIsolated(1); + } + } + + fhistos->fhAssocMult->Fill(noAssocs); + //cout<"Triggs = "<<0 ){} + if(noAssocs>0 ) fassocPool->AcceptList(fassocList, fcent, zVert, noAllChargedTracks, fevt); + + //------------------------------------------------------------------ + // Do the Correlation + //----------------------ooooo--------------------------------------- + int noTriggTracs=-1; + noTriggTracs = fbTriggCorrel ? noTriggs : 1; + if(fbLPCorrel && !lpTrackCounter->Exists()) return; + if(fbLPpairCorrel && !lpPairCounter->Exists()) return; + AliJBaseTrack *triggTr = NULL; + + for(int ii=0;iiAt(ii); + if (fbLPCorrel) triggTr = (AliJBaseTrack*)ftriggList->At(lpTrackCounter->GetIndex()); + if (fbLPpairCorrel) triggTr = (AliJBaseTrack*)fpairList->At(lpPairCounter->GetIndex()); + //for(int ii=0;iiAt(ii); + double ptt = triggTr->Pt(); + int iptt = triggTr->GetTriggBin(); + if(iptt<0) { + cout<<"Not registered trigger ! I better stop here." <GetTrackEff(); + fhistos->fhTriggPtBin[cBin][zBin][iptt]->Fill(ptt, effCorr);//inclusive + + if(triggTr->GetIsIsolated()>0) fhistos->fhTriggPtBinIsolTrigg[kReal][cBin][iptt]->Fill(ptt, effCorr); + + for(int jj=0;jjAt(jj); + //assocTr->PrintOut("assoc track"); + if(fbLPpairCorrel && + (assocTr->GetID()==lpPairCounter->GetPairTrackID(0) || + assocTr->GetID()==lpPairCounter->GetPairTrackID(1)) ) continue; + //------------------------------------------------------------- + fcorrelations->FillAzimuthHistos(kReal, cBin, zBin, triggTr, assocTr); + //------------------------------------------------------------- + } // end assoc loop + } // end trigg loop + // == mix trigg with assoc + if (fbLPpairCorrel) + fassocPool->Mix(fpairList, kAzimuthFill, fcent, zVert, noAllChargedTracks, fevt); + else + fassocPool->Mix(ftriggList, kAzimuthFill, fcent, zVert, noAllChargedTracks, fevt); + + //-------------------------------------------------------------- + // End of the Correlation + //-------------------------------------------------------------- + + + +} + +void AliJCORRAN::Terminate() { + // termination + + /* TODO + for (int hic = 0;hic < fcard->GetNoOfBins(kCentrType);hic++){ + ScaleNotEquidistantHisto( fhistos->fhChargedPt[hic], 1); + ScaleNotEquidistantHisto( fhistos->fhChargedPtNoCorr[hic], 1); + ScaleNotEquidistantHisto( fhistos->fhChargedPtJacek[hic], 1); + } + ScaleNotEquidistantHisto( fhistos->fhLPpt, 1); + ScaleNotEquidistantHisto( fhistos->fhLPpairPt, 1); + ScaleNotEquidistantHisto( fhistos->fhIsolatedLPpt, 1); + ScaleNotEquidistantHisto( fhistos->fhChargedPtFiete, 1); + */ + + // cout<<"MB's="< <"< "< not recognized"<-kJPi/3.0 ? res : kJTwoPi+res ; + return res>-kJPi*9./20. ? res : kJTwoPi+res ; +} + +void AliJCORRAN::ScaleNotEquidistantHisto(TH1D *hid, const double sc=1){ + // histo scaler + for(int i=1;i<= hid->GetNbinsX();i++){ + hid->SetBinContent(i,hid->GetBinContent(i)*sc/hid->GetBinWidth(i)); + hid->SetBinError(i,hid->GetBinError(i)*sc/hid->GetBinWidth(i)); + } +} + +// Fill xT histograms (Esko) +void AliJCORRAN::FillXtHistos(TClonesArray *inputList, AliJTrackCounter *lpTrackCounter){ + // Here should be a comment describing this method + JUNUSED(lpTrackCounter); + + enum xTtype { kInclusive=0, kIsolated=1, kIsolatedLP=2} ; + double lowerPtCut = 0.2; + double isolationR = 0.4; + double fCutOnBkgActivity = 0.10; + int cBin = fcard->GetBin(kCentrType, fcent); + double sqrts = fSQRTS; + int noAllTriggTracks = inputList->GetEntries(); + //cout << "Entering Esko's analysis loop" << endl; + //cout << "Sqrts = " << sqrts << " pT = " << ptt << " xT = " << xtt << endl; + for(int itrack=0; itrackAt(itrack); + double sumPtAroundTrigger = 0; + double ptt = triggTr->Pt(); + double xtt = 2.0 * ptt / (1.0 * sqrts); + double effCorr = 1.0/triggTr->GetTrackEff(); + fhistos->fhPtForXt[kInclusive][cBin]->Fill(ptt, ptt>0 ? 1./ptt*effCorr : 0); + fhistos->fhXt[kInclusive][cBin]->Fill(xtt, effCorr ); + fhistos->fhXtWeighted[kInclusive][cBin]->Fill(xtt, effCorr*1.0/xtt ); + + for(int jj=0;jjGetEntriesFast();jj++){ // assoc loop + AliJBaseTrack *assocTr = (AliJBaseTrack*)inputList->At(jj); + if(triggTr->GetID()==assocTr->GetID()) continue; + double pta = assocTr->Pt(); + // determine the activity in the cone around trigger (Esko) + if( lowerPtCut < pta ){ + double dPhi = DeltaPhi( assocTr->Phi(), triggTr->Phi() ); + double dEta = assocTr->Eta() - triggTr->Eta(); + if(isolationR > sqrt(dPhi*dPhi+dEta*dEta)) sumPtAroundTrigger += assocTr->Pt();//FK// + } + //cout << " Assoc number " << assocCounter++ << endl; + } + // If pT sum is below the limit, fill to the isolated histos + if( sumPtAroundTrigger/ptt < fCutOnBkgActivity && ///relative activity + ( fabs(triggTr->Eta()) < (fTrackEtaRange - isolationR) ) ){ //fiducial cut + // pT and xT + // kInclusive kIsolated, kLPIsolated + fhistos->fhPtForXt[kIsolated][cBin]->Fill(ptt,effCorr*1.0/ptt); + fhistos->fhXt[kIsolated][cBin]->Fill(xtt, effCorr ); + fhistos->fhXtWeighted[kIsolated][cBin]->Fill(xtt,effCorr*1.0/xtt); + } + //cout<<"pT sum around trigger = " << sumPtAroundTrigger << endl; + } + +} // end FillXtHistos diff --git a/PWGCF/Correlations/JCORRAN/AliJCORRAN.h b/PWGCF/Correlations/JCORRAN/AliJCORRAN.h new file mode 100644 index 00000000000..7b62b19a30e --- /dev/null +++ b/PWGCF/Correlations/JCORRAN/AliJCORRAN.h @@ -0,0 +1,163 @@ +/* Copyright(c) 1998-2014, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +// Short comment describing what this class does needed! + +#ifndef ALIJCORRAN_H +#define ALIJCORRAN_H + +#include +#include +#include + +// jcorran main class +// used in local and grid execution +// blah + +class AliJCard; +class AliJHistos; +class AliJCorrelations; +class AliJEventHeader; +class AliJEventPool; +class AliJHistos; +class AliJRunHeader; +class AliJEfficiency; +class AliJTrackCounter; + +class TClonesArray; +class TF1; +class AliJRunTable; +class TRandom3; + +class AliJCORRAN : public TObject +{ + public: + AliJCORRAN(); + AliJCORRAN(Bool_t execLocal); + virtual ~AliJCORRAN(); + AliJCORRAN(const AliJCORRAN& obj); + AliJCORRAN& operator=(const AliJCORRAN& obj); + + void Initialize() const; + void Init(){ Initialize(); } + void UserCreateOutputObjects(); + void UserExec(); + void Terminate(); + + Int_t GetNumberEvents() const { return fnumberEvents; } + AliJHistos *GetHistos() { return fhistos; } + AliJCorrelations *GetCorrelations() { return fcorrelations; } + AliJEventPool *GetAssocPool() { return fassocPool; } + Int_t GetEventCounter() const { return fEventCounter; } + AliJCard *GetCard() { return fcard; } + + void FillXtHistos(TClonesArray *inputList, AliJTrackCounter *lpTrackCounter); // Esko + + void SetCard( AliJCard *c ) { fcard = c; } + void SetTrigger( char* p ) { fjtrigg = GetParticleType(p); } + void SetAssoc( char* p ) { fjassoc = GetParticleType(p); } + void SetInclusiveFile( const char *f ){ fInclusiveFile = f; } + void SetInputFile( char *f ) { finputFile = f; } + void SetNumberEvents( Int_t n ) { fnumberEvents = n; } + + void SetTrackList( TClonesArray *a ) { fdmg->SetTrackList( a ); } + void SetPhotonList( TClonesArray *a ) { fdmg->SetPhotonList( a ); } + void SetCaloCellList( TClonesArray *a ) { fdmg->SetCaloCellList( a ); } + void SetMCTrackList( TClonesArray *a ) { fdmg->SetMCTrackList( a ); } + void SetHeaderList( TClonesArray *a ) { fdmg->SetHeaderList( a ); } + void SetRunHeader( AliJRunHeader *a ) { frunHeader = a; } + void SetRunInfoList( TList *a ) { fdmg->SetRunInfoList( a ); } + void SetESDVZERO( TObject *a ) { fdmg->SetESDVZERO( a ); } + + // void SetESDTZERO( AliESDTZERO *a ) { fdmg->SetESDTZERO( a ); } + // void SetESDZDC( AliESDZDC *a ) { fdmg->SetESDZDC( a ); } + + + double DeltaPhi(double phi1, double phi2); + particleType GetParticleType(char *inchar); + void ScaleNotEquidistantHisto(TH1D *hid, const double sc); + + private: + + Bool_t fExecLocal; // exec mode + Bool_t fFirstEvent; //! + + particleType fjtrigg; // assoc + particleType fjassoc; // trigger + + AliJCard *fcard; // card + char * finputFile; //! + TString fInclusiveFile; // File for inclusive distributions + + Int_t fevt; // event number + AliJHistos *fhistos; //! + AliJCorrelations *fcorrelations; //! + AliJEventPool *fphotonPool; //! + AliJEventPool *fassocPool; //! + TClonesArray *fphotonList; //! + TClonesArray *fchargedHadronList; //! + TClonesArray *fpizeroList; //! + TClonesArray *ftriggList; //! + TClonesArray *fassocList; //! + TClonesArray *fpairList; //! + TClonesArray *fpairCounterList; //! + TClonesArray *finputList; //! + + AliJDataManager* fdmg; //! + AliJEventHeader *feventHeader; //! + AliJRunHeader* frunHeader; //! + + int fnumberEvents; //! + int fieout; //! + int fEventCounter; //! + double fcent; //! + Int_t fncBin; //! + Int_t fnPttBin; //! + bool fbTriggCorrel; //! + bool fbLPCorrel; //! + bool fbLPpairCorrel; //! + double fTrackEtaRange; //! + double flowerPtAssocBoarder; //! + + TF1 *fCentMultLow; //! + TF1 *fCentMultHigh; //! + + + + Int_t fEventBC; //! + Float_t fSQRTS; // todo + + AliJEfficiency *fEfficiency; // comment me + AliJRunTable *fRunTable; // comment needed + float fIsolationR; // comment1 + int fHadronSelectionCut; /// comment2 + + ClassDef(AliJCORRAN, 1); // EMCAL for jcorran + +}; + +#endif + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/PWGCF/Correlations/JCORRAN/AliJCORRANTask.cxx b/PWGCF/Correlations/JCORRAN/AliJCORRANTask.cxx old mode 100755 new mode 100644 index 3a55a6903f1..4f7e844c0d3 --- a/PWGCF/Correlations/JCORRAN/AliJCORRANTask.cxx +++ b/PWGCF/Correlations/JCORRAN/AliJCORRANTask.cxx @@ -22,191 +22,75 @@ // Adapted for AliAnalysisTaskSE and AOD objects ////////////////////////////////////////////////////////////////////////////// +#include "TChain.h" +#include "TList.h" +#include "TTree.h" +#include "TFile.h" -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include #include "AliAnalysisTaskSE.h" #include "AliAODHandler.h" #include "AliJCORRANTask.h" #include "AliAnalysisManager.h" -#include "AliESDEvent.h" -#include "AliMCEvent.h" -#include "AliStack.h" -#include "AliGenEventHeader.h" -#include "AliGenCocktailEventHeader.h" -#include "AliGenPythiaEventHeader.h" -#include "AliInputEventHandler.h" -#include "AliESDCaloCluster.h" -#include "AliAODEvent.h" -#include "AliAODHeader.h" -#include "AliLog.h" -#include "AliESDVertex.h" -#include "AliESDtrack.h" -#include "AliAODTrack.h" -#include "AliAnalysisFilter.h" -#include "AliESDtrackCuts.h" -#include "AliAODVertex.h" -#include "AliAODTracklets.h" -#include "AliAODPid.h" -#include "AliESDUtils.h" -//#include "AliESDVZERO.h" -#include "AliCentrality.h" -#include "AliAODTracklets.h" -#include "AliMultiplicity.h" -#include "AliJConst.h" -#include "AliESDRun.h" -#include "AliESDVZERO.h" -#include "AliExternalTrackParam.h" -//== EMCAL -#include "AliESDCaloCluster.h" -#include "AliEMCALGeometry.h" -#include "AliVCluster.h" -#include "AliVCaloCells.h" -#include "AliEMCALRecoUtils.h" -#include "AliEMCALPIDUtils.h" #include "AliJTrack.h" #include "AliJMCTrack.h" #include "AliJPhoton.h" +//#include "AliJCaloCell.h" #include "AliJEventHeader.h" #include "AliJRunHeader.h" //______________________________________________________________________________ AliJCORRANTask::AliJCORRANTask() : AliAnalysisTaskSE("PWG4JCORRAN"), - fRunType("LHC10h"), // enable filling EP info - fInputFormat("ESD"), - fEsdTrackCuts(0x0), - fESDFilter(0x0), - fIsRealOrMC(), + fFilter(0x0), fAODName("jcorran.root"), - fStoreEventPlaneSource(false), - fStoreTPCTrack(false), - fOADBPath(), - fTrackList(0), - fMCTrackList(0x0), - fPhotonList(0x0), - fHeaderList(0x0), - fRunInfoList(0x0), - fPIDesd(0x0), - fPIDResponse(0x0), - fPIDCombined(0x0), - fVZEROData(0x0), - fTZEROData(0x0), - //fFMDData(0x0), - fZDCData(0x0), - fAliRunHeader(0x0), - fEMCALGeoUtils(0x0), - fPHOSGeom(0x0) -{ - //Default constructor - for(Int_t i=0;i 5) cout << "---- AliJCORRANTask Constructor ----"<~AliJCORRANTask(); new(this) AliJCORRANTask(ap); return *this; @@ -224,23 +109,10 @@ AliJCORRANTask& AliJCORRANTask::operator = (const AliJCORRANTask& ap) AliJCORRANTask::~AliJCORRANTask() { // destructor - delete fTrackList; - delete fMCTrackList; - delete fPhotonList; - delete fHeaderList; - delete fAliRunHeader; - delete fRunInfoList; - delete fPIDesd; - delete fOADBPath; - delete fPIDResponse; - delete fPIDCombined; - delete fEMCALGeoUtils; - delete fPHOSGeom; - delete fVZEROData; - delete fTZEROData; - delete fZDCData; - // delete fFMDData; + delete fFilter; + delete fJODTree; + delete fAliJRunHeader; } @@ -250,758 +122,104 @@ void AliJCORRANTask::UserCreateOutputObjects() { //=== create the jcorran outputs objects if(fDebug > 1) printf("AliJCORRANTask::UserCreateOutPutData() \n"); - + //=== Get AnalysisManager AliAnalysisManager *man = AliAnalysisManager::GetAnalysisManager(); if(!man->GetOutputEventHandler()) { Fatal("UserCreateOutputObjects", "This task needs an AOD handler"); return; } - man->RegisterExtraFile(fAODName.Data()); - - //=== Other Objects - fEMCALGeoUtils = AliEMCALGeometry::GetInstance("EMCAL_COMPLETE"); - fPHOSGeom = new AliPHOSGeoUtils(); - - //=== Set Tree and TClonesArray - //== TRACKS - AddListAODBranch("AliJTrackList", "AliJTrack", &fTrackList, 1000); - AddListAODBranch("AliJPhotonList", "AliJPhoton", &fPhotonList, 1000); - if((bool)fIsRealOrMC[0]) - AddListAODBranch("AliJTMCrackList", "AliJMCTrack", &fMCTrackList, 1000); - //== Event Header - AddListAODBranch("AliJEventHeaderList", "AliJEventHeader", &fHeaderList, 1000); - //== RUN HEADER - fAliRunHeader = new AliJRunHeader(); - fRunInfoList = new TList(); - fRunInfoList->SetName("RunInfoList"); - fRunInfoList->SetOwner(); - fRunInfoList->Clear(); - fRunInfoList->Add(fAliRunHeader); - //== EventPlane SRC - if( fStoreEventPlaneSource ){ - fVZEROData = new AliESDVZERO; - fTZEROData = new AliESDTZERO; - fZDCData = new AliESDZDC; - AddAODBranch("AliESDVZERO", &fVZEROData, fAODName.Data()); - AddAODBranch("AliESDTZERO", &fTZEROData, fAODName.Data()); - AddAODBranch("AliESDZDC", &fZDCData, fAODName.Data()); - } - //== PID - fPIDesd = new AliESDpid; - fPIDCombined = new AliPIDCombined; - fPIDCombined->SetDefaultTPCPriors(); - fPIDCombined->SetDetectorMask(AliPIDResponse::kDetTPC+AliPIDResponse::kDetTOF); - fPIDResponse = ((AliInputEventHandler*) (man->GetInputEventHandler()))->GetPIDResponse(); - fPIDResponse->SetOADBPath(AliAnalysisManager::GetOADBPath()); - if (!fOADBPath.IsNull()) fPIDResponse->SetOADBPath(fOADBPath.Data()); - - cout << "Add(fAliRunHeader) in UserCreateObject() ======= " << endl; - PostData(1,fRunInfoList); - -} -//______________________________________________________________________________ -void AliJCORRANTask::UserExec(Option_t* /*option*/) -{ + // run the filter class + fFilter->SetMyTask( this ); + fFilter->SetAliJRunHeader( fAliJRunHeader ); + fFilter->UserCreateOutputObjects(); - // Processing of one event - if(fDebug > 5) cout << "------- AliJCORRANTask Exec-------"<Clear(); - if((bool)fIsRealOrMC[0]) fMCTrackList->Clear(); - fPhotonList->Clear(); - fHeaderList->Clear(); - - //=== COMMON for ESD and AOD - static int runId=-1; - AliVEvent *event = InputEvent(); - if(!event) return; - AliMCEvent* mcEvent = NULL; - if((bool)fIsRealOrMC[0]) mcEvent = MCEvent(); - // RUN Header - if(event->GetRunNumber() != runId){ //new run has started - runId = event->GetRunNumber(); - //Polarity of magnetic field in L3 solenoid - Short_t l3MgFieldPolarity=0; // (LHC convention: +current -> +Bz) - //Create internal JCorran trigger mask. Mapping between trigger and trigger bit - fTriggerTableJCorran[AliJConst::kMinBiasTriggerBitJCorran]="Minimum Bias";//minimum bias occupies first trigger bit - fTriggerTableJCorran[AliJConst::kHighMultTriggerBitJCorran]="High Multiplicity";//high multiplicity trigger => second trigger bit - //=========== Fill Run header object =============== - fAliRunHeader->SetRunNumber(runId); - fAliRunHeader->SetActiveTriggersJCorran(fTriggerTableJCorran,AliJConst::kRangeTriggerTableJCorran); - SetAliceTriggerDef(fAliRunHeader);//TODO for AOD - SetAliceFilterMapDef(fAliRunHeader);// TODO for AOD - //FOR ESD - if(fInputFormat=="ESD"){ - AliESDEvent* esd = dynamic_cast(event); - if(!esd) return; - if(esd->GetCurrentL3() >0) l3MgFieldPolarity = 1; - if(esd->GetCurrentL3() <0) l3MgFieldPolarity = -1; - fAliRunHeader->SetL3Field(l3MgFieldPolarity, esd->GetMagneticField()); - const AliESDRun* esdRun = esd->GetESDRun(); - for(Int_t triggerBit=0; triggerBitGetTriggerClass(triggerBit); - } - fAliRunHeader->SetActiveTriggersAlice(fActiveTriggers); - } - fRunInfoList->Add(fAliRunHeader); - cout << "Add(fAliRunHeader) is done =============" << endl; - } + // register ouput branches - //=== If ESD or AOD - if(fInputFormat=="ESD"){ //Reading ESD - if(fDebug > 5) cout << "\t------- Start ESD "<(event); - if(!esd) return; - ReadESDHeader(esd); - ReadESDTracks(esd); - //ReadESDCaloClusters(esd); - if((bool)fIsRealOrMC[0]) ReadMCTracks(mcEvent); - }else if( fInputFormat == "AOD") { - if(fDebug > 5) cout << "\t------- Start AOD "<(event); - if(!aod) return; - ReadAODHeader(aod); - ReadAODTracks(aod); - //ReadAODCaloClusters(aod); - }else{ - cout << "Error: Not correct InputDataFormat especified " << endl; - return; + if(fDoStoreJOD){ + TFile * file1 = OpenFile(1); + file1-> SetCompressionLevel(9); + TTree * tree = new TTree("JODTree","JYFL Object Data"); + int split = 2; + int basketsize = 32000; + tree->Branch("TrackList", fFilter->GetTrackList(),basketsize, split); + if( fFilter->IsMC() ) + tree->Branch("MCTrackList", fFilter->GetMCTrackList(),basketsize, split ); + //== Event Header + tree->Branch("HeaderList", fFilter->GetHeaderList(),basketsize, split ); + //== EventPlane SRC + if( fFilter->GetStoreEventPlaneSource() ){ + tree->Branch("AliESDVZERO", fFilter->GetESDVZERO()); + tree->Branch("AliESDTZERO", fFilter->GetESDTZERO()); + tree->Branch("AliESDZDC", fFilter->GetESDZDC()); + } + fJODTree = tree; } - //=== TODO : need this? - AliAODHandler* outputHandler = - (AliAODHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler()); - outputHandler->SetFillAOD(kTRUE); - outputHandler->SetFillExtension(kTRUE); - PostData(1,fRunInfoList); - - if(fDebug > 5) cout << "\t------- End UserExec "<GetRunInfoList()); -//______________________________________________________________________________ -void AliJCORRANTask::Init() -{ - // Intialisation of parameters - AliInfo("Doing initialization") ; - - TString formula(fEsdTrackCuts->GetMaxDCAToVertexXYPtDep()); - if(formula.Length()>0){ // momentum dep DCA cut for AOD - formula.ReplaceAll("pt","x"); - } -} -//______________________________________________________________________________ -void AliJCORRANTask::Terminate(Option_t *) -{ - // Processing when the event loop is ended - cout<<"PWG4JCORRAN Analysis DONE !!"< (GetOutputData(1)); - if(fRunInfoList) - { - fAliRunHeader = dynamic_cast (fRunInfoList->FindObject("AliJRunHeader")); - if(fAliRunHeader) {fAliRunHeader->Print();} - } - else - { - cout << "WARNING : Run Information List is empty" << endl; - } + cout << "Add(fAliRunHeader) in UserCreateObject() ======= " << endl; } //______________________________________________________________________________ -void AliJCORRANTask::ReadESDTracks(AliESDEvent * esd) - //void AliJCORRANTask::ReadESDTracks(const AliESDEvent * esd) +void AliJCORRANTask::UserExec(Option_t* /*option*/) { - // Read the AliESDtrack and fill the list of AliJTrack containers - Int_t nt = esd->GetNumberOfTracks(); - if(fDebug > 5) cout << "ESD::NumberOfTracks = " << nt << endl; - Short_t ntrk = 0; - - //loop over tracks - for(Int_t it = 0; it < nt; it++) { - - AliESDtrack *track = esd->GetTrack(it); - if( !track ) continue; - if(! fEsdTrackCuts->IsSelected(track)) continue; // apply track selection criteria - UInt_t filterMap = fESDFilter->IsSelected( track ); - //------------ T P C ------------ - Float_t tpcDca[2], tpcCov[3]; // dca_xy, dca_z, sigma_xy, sigma_xy_z, sigma_z - track->GetImpactParametersTPC(tpcDca,tpcCov); - - Int_t nClust = track->GetTPCclusters(0); - Int_t nFindableClust = track->GetTPCNclsF(); - Float_t tpcChi2PerCluster = 0.; - if(nClust>0.) tpcChi2PerCluster = track->GetTPCchi2()/Float_t(nClust); - - Float_t tpcClustPerFindClust = 0.; - if(nFindableClust>0.) tpcClustPerFindClust = Float_t(nClust)/nFindableClust; - //-------------------------------- - - //create a new AliJTrack and fill the track info - AliJTrack * ctrack = new( (*fTrackList)[fTrackList->GetEntriesFast()] ) AliJTrack; - ctrack->SetPxPyPzE(track->Px(), track->Py(), track->Pz(), 0 ); - ctrack->SetTPCdEdx( track->GetTPCsignal() ); - if( fStoreTPCTrack ){ - AliESDtrack *tpcTrack = AliESDtrackCuts::GetTPCOnlyTrack( esd, it ); - if( !tpcTrack ) continue; - ctrack->SetTPCTrack( tpcTrack->Px(), tpcTrack->Py(), tpcTrack->Pz()); - } - ReadESDPID( track, ctrack ); - ctrack->SetParticleType(AliJConst::kNone); - ctrack->SetCharge(track->Charge()); - ctrack->SetFilterMap( filterMap ); - - if(fDebug > 5 && track->P()>1 ) cout << "P = " << track->P() << endl; - - ++ntrk; - } // end tracks loop -} -//_________________________________________________________________________________- -void AliJCORRANTask::ReadESDPID(AliESDtrack *track, AliJTrack *ctrack) -{ - // Probability calculation for PID - Double_t probTPC[AliPID::kSPECIES]={0.}; - Double_t probTOF[AliPID::kSPECIES]={0.}; - Double_t probTPCTOF[AliPID::kSPECIES]={0.}; - // - fPIDCombined->SetDetectorMask(AliPIDResponse::kDetTPC); - UInt_t detUsed = fPIDCombined->ComputeProbabilities(track, fPIDResponse, probTPC); - if (detUsed != 0) { // TPC is available - for (Int_t ispec=0; ispecNumberOfSigmasTPC(track,(AliPID::EParticleType)ispec); - ctrack->SetTPCsigma(AliJTrack::AliJTrkPID(ispec), nSigmaTPC); - } - - // compute priors for TPC+TOF, even if we ask just TOF for PID - fPIDCombined->SetDetectorMask(AliPIDResponse::kDetTOF); - detUsed = fPIDCombined->ComputeProbabilities(track, fPIDResponse, probTOF); - if (detUsed != 0) { // TOF is available - for (Int_t ispec=0; ispecNumberOfSigmasTOF(track,(AliPID::EParticleType)ispec); - ctrack->SetTOFsigma(AliJTrack::AliJTrkPID(ispec), nSigmaTOF); - } - } - - fPIDCombined->SetDetectorMask(AliPIDResponse::kDetTOF|AliPIDResponse::kDetTPC); - detUsed = fPIDCombined->ComputeProbabilities(track, fPIDResponse, probTPCTOF); - } + // Processing of one event + if(fDebug > 5) cout << "------- AliJCORRANTask Exec-------"<SetPID(AliJTrack::AliJTrkPID(ip), probTOF[ip], AliJTrack::kTOF); - ctrack->SetPID(AliJTrack::AliJTrkPID(ip), probTPC[ip], AliJTrack::kTPC); - ctrack->SetPID(AliJTrack::AliJTrkPID(ip), probTPCTOF[ip], AliJTrack::kTPCTOF); - } + fFilter->UserExec(""); - // TOF beta and expected beta - Float_t beta = -1; Float_t minP = 0.2; Float_t minTPCsignal = 40; Float_t minTOFLength = 365.; Float_t minTOFsignal = 12000; - Double_t inttimes[10]; Float_t betaTh[10]; Double_t dEdxTh[10]; - track->GetIntegratedTimes(inttimes); - for(int i=0;i<10;i++) { - betaTh[i] = -1.; // initialize expected beta = -1 - dEdxTh[i] = -1.; // initialize expected dEdx = -1 - } - if(track->P() > minP && track->GetTPCsignal() > minTPCsignal && (track->GetStatus() & AliESDtrack::kTOFout) - && (track->GetStatus() & AliESDtrack::kTIME) && (track->GetIntegratedLength() > minTOFLength)&& track->GetTOFsignal() > minTOFsignal) { - Double_t consCal = 33.3564095198152043; - beta = track->GetIntegratedLength() / (track->GetTOFsignal() - fPIDesd->GetTOFResponse().GetStartTime(track->P())) * consCal; - for(int i=0; i<10; i++) { - betaTh[i] = track->GetIntegratedLength() / ( inttimes[i] ) * consCal; - } - } - ctrack->SetTOFbeta(beta); - - Double_t ptpc[3]; - track->GetInnerPxPyPz(ptpc); - Float_t momtpc=TMath::Sqrt(ptpc[0]*ptpc[0] + ptpc[1]*ptpc[1] + ptpc[2]*ptpc[2]); - for(int ip=0; ip < (AliJTrack::kNAliJTrkPID); ip++) { - ctrack->SetExpectedTOFbeta(AliJTrack::AliJTrkPID(ip), betaTh[ip]); - // expected dEdx - dEdxTh[ip] = fPIDesd->GetTPCResponse().GetExpectedSignal(momtpc, AliPID::EParticleType(ip)); - ctrack->SetExpectedTPCdEdx(AliJTrack::AliJTrkPID(ip), dEdxTh[ip]); - } - - - -} - -//______________________________________________________________________________ -void AliJCORRANTask::ReadAODTracks(const AliAODEvent * aod) -{ - // Read the AliAODtrack and fill the list of AliJTrack containers - Int_t nt = aod->GetNumberOfTracks(); - if(fDebug > 5) cout << "AOD::NumberOfTracks = " << nt << endl; - cout << "AOD::NumberOfTracks = " << nt << endl; - //Short_t ntrk = 0; - //loop over tracks - for(Int_t it = 0; it < nt; it++) { - - AliAODTrack *track = aod->GetTrack(it); - //if(!AcceptAODTrack(track)) continue; - //if(! fEsdTrackCuts->IsSelected(track)) continue; //apply loose selection criteria - //FK//if(track->GetType() != AliAODTrack::kPrimary) continue; // only primaries - - AliJTrack * ctrack = new( (*fTrackList)[fTrackList->GetEntriesFast()] ) AliJTrack; - ctrack->SetPxPyPzE(track->Px(), track->Py(), track->Pz(), 0 ); - //TODO if( fStoreTPCTrack ) - ctrack->SetParticleType(AliJConst::kNone); - ctrack->SetCharge(track->Charge()); - ctrack->SetStatus(track->GetStatus());// - ctrack->SetFlags( track->GetFlags() ); - ctrack->SetLabel( track->GetLabel() ); - //FilterMap - UInt_t filterMap=0; - for( unsigned int i=0;iTestFilterBit( 1UL<SetFilterMap( filterMap ); - - //PID TODO - double const * pid = track->PID(); - ctrack->SetPID(AliJTrack::kElectronAliJ,pid[AliAODTrack::kElectron],AliJTrack::kTOF); - ctrack->SetPID(AliJTrack::kMuonAliJ, pid[AliAODTrack::kMuon], AliJTrack::kTOF); - ctrack->SetPID(AliJTrack::kPionAliJ, pid[AliAODTrack::kPion], AliJTrack::kTOF); - ctrack->SetPID(AliJTrack::kKaonAliJ, pid[AliAODTrack::kKaon], AliJTrack::kTOF); - ctrack->SetPID(AliJTrack::kProtonAliJ, pid[AliAODTrack::kProton], AliJTrack::kTOF); - //TPC - ctrack->SetTPCnClust(track->GetTPCNcls()); - ctrack->SetTPCdEdx( track->GetTPCsignal() ); - - if((bool) fIsRealOrMC[0]){ - //Int_t label = track->GetLabel(); - //ctrack->SetITSLabel(label); - //ctrack->SetTPCLabel(label); - } - - - if(fDebug > 5 && track->P()>1 ) cout << "P = " << track->P() << endl; - } // end tracks loop -} - -//______________________________________________________________________________ -void AliJCORRANTask::ReadESDCaloClusters(const AliESDEvent* esd) -{ - //AliVEvent * event = InputEvent(); - AliVEvent * event = (AliVEvent*)esd; - TRefArray *caloClustersArr=new TRefArray(); - event->GetEMCALClusters(caloClustersArr); - Double_t v[3]; - event->GetPrimaryVertex()->GetXYZ(v); - - AliEMCALRecoUtils * fRecoUtils = new AliEMCALRecoUtils; - - //const Int_t kNumberOfEMCALClusters =caloClustersArr->GetEntries(); - Int_t numberOfCaloClusters = caloClustersArr->GetEntries() ; - if(fDebug > 5) cout << "ESD::number of ESD caloclusters " << numberOfCaloClusters << endl; - - AliVCaloCells *emCells =event->GetEMCALCells(); - - int nPhotons = 0; - for(Int_t icluster=0; iclusterAt(icluster); - if( !c1 ) continue; - //== remove bad channels - if(fRecoUtils->ClusterContainsBadChannel(fEMCALGeoUtils, c1->GetCellsAbsId(), c1->GetNCells())) continue; - //== check energy and position - if(fRecoUtils->IsRecalibrationOn()){ - fRecoUtils->RecalibrateClusterEnergy(fEMCALGeoUtils, c1, emCells); - fRecoUtils->RecalculateClusterShowerShapeParameters(fEMCALGeoUtils, emCells, c1); - fRecoUtils->RecalculateClusterPID(c1); - } - //== correct non linearity - c1->SetE(fRecoUtils->CorrectClusterEnergyLinearity(c1)); - - //== corrected clusters - if(c1->E() < 0.8 || c1->E() > 30) continue; //TODO - //fRecoUtils->GetMaxEnergyCell(fEMCALGeo, emCells, c1, absID1, iSM, ieta1, iphi1, shared); - - AliJPhoton *pht = new( (*fPhotonList)[nPhotons++] ) AliJPhoton; - pht->SetParticleType(AliJConst::kNone);//kPhoton); - pht->SetChi2(c1->Chi2()); - pht->SetPID(c1->GetPID()); - Float_t pos[3]; - TLorentzVector p1; - c1->GetPosition(pos); - c1->GetMomentum(p1, v); - //TODO - pht->SetPositionX(pos[0]); - pht->SetPositionY(pos[1]); - pht->SetPositionZ(pos[2]); - pht->SetPxPyPzE( p1.Px(), p1.Py(), p1.Pz(), p1.E()); - pht->SetTrackDx( c1->GetTrackDx() ); - pht->SetTrackDz( c1->GetTrackDz() ); - pht->SetCharge(0); - if(c1->IsEMCAL()) pht->SetCaloType(AliJPhoton::kEMCALCalo); - if(c1->IsPHOS()) pht->SetCaloType(AliJPhoton::kPHOSCalo); - pht->SetDistToBadChannel(c1->GetDistanceToBadChannel()); - pht->SetDispersion(c1->GetDispersion()); - pht->SetM20(c1->GetM20()); - pht->SetM02(c1->GetM02()); - pht->SetEmcCpvDist(c1->GetEmcCpvDistance()); - pht->SetNCells(c1->GetNCells()); - pht->SetCellsAmplitudeFraction( c1->GetCellsAmplitudeFraction() ); - pht->SetCellsAbsId(c1->GetCellsAbsId()); - Int_t imoduleID = GetSuperModuleNumber(c1->IsEMCAL(), c1->GetCellAbsId(0)); - pht->SetSuperModuleID(imoduleID); - } - delete fRecoUtils; - delete caloClustersArr; + if( 1 || fFilter->GetEventSuccess() ){ // TODO + if( fDoStoreJOD ){ + fJODTree->Fill(); + } + } + PostData(1,fJODTree); + PostData(2,fFilter->GetRunInfoList()); -} -//______________________________________________________________________________ -void AliJCORRANTask::ReadAODCaloClusters(const AliAODEvent* aod) -{ - if( !aod ) aod=0; - // Read the AliAODCaloClusters and fill the list of AliJPhoton containers + if(fDebug > 5) cout << "\t------- End UserExec "<GetEntriesFast()] ) AliJEventHeader; - - AliVVZERO *v0 = event->GetVZEROData(); - if( v0 ) hdr->SetV0Mult(v0->GetMTotV0A() + v0->GetMTotV0C()); - // Get Centrality as a percent from 0% to 100% - AliCentrality *cent = event->GetCentrality(); - if( cent ){ - hdr->SetCentrality( cent->GetCentralityPercentile("V0M")); - hdr->SetCentralityArray(AliJEventHeader::kcV0M, cent->GetCentralityPercentile("V0M")); - hdr->SetCentralityArray(AliJEventHeader::kcFMD, cent->GetCentralityPercentile("FMD")); - hdr->SetCentralityArray(AliJEventHeader::kcTRK, cent->GetCentralityPercentile("TRK")); - hdr->SetCentralityArray(AliJEventHeader::kcTKL, cent->GetCentralityPercentile("TKL")); - hdr->SetCentralityArray(AliJEventHeader::kcCL0, cent->GetCentralityPercentile("CL0")); - hdr->SetCentralityArray(AliJEventHeader::kcCL1, cent->GetCentralityPercentile("CL1")); - hdr->SetCentralityArray(AliJEventHeader::kcV0MvsFMD, cent->GetCentralityPercentile("V0MvsFMD")); - hdr->SetCentralityArray(AliJEventHeader::kcTKLvsV0, cent->GetCentralityPercentile("TKLvsV0")); - hdr->SetCentralityArray(AliJEventHeader::kcZEMvsZDC, cent->GetCentralityPercentile("ZEMvsZDC")); - } - hdr->SetTriggerMaskAlice(event->GetTriggerMask()); //ULong64_t - hdr->SetTriggerMaskJCorran(ConvertTriggerMask()); //UInt_t - hdr->SetEventType(event->GetEventType()); - int ncontributors = 0; - const AliVVertex * vtxESD = event->GetPrimaryVertex(); - if(vtxESD){ - hdr->SetXVertex(vtxESD->GetX()); //FK// EFF - hdr->SetYVertex(vtxESD->GetY()); //FK// EFF - hdr->SetZVertex(vtxESD->GetZ()); - //hdr->SetZVertexErr(vtxESD->GetZRes()); - double covMat[6]; - vtxESD->GetCovarianceMatrix(covMat); - hdr->SetZVertexErr(TMath::Sqrt(covMat[5])); // GetZRes := TMath::Sqrt(fCovZZ) - ncontributors = vtxESD->GetNContributors(); // get number of contributors to vertex - hdr->SetVtxMult( vtxESD->GetNContributors() ); - }else{ - hdr->SetZVertex(9999); - hdr->SetZVertexErr(9999); - } - hdr->SetVtxMult(ncontributors); //FK// EFF contrib to vertex - return hdr; -} -//______________________________________________________________________________ -void AliJCORRANTask::ReadESDHeader(AliESDEvent *esd) +void AliJCORRANTask::Init() { - // Read the AliESDEvent and fill the list of AliJEventHeader containers - if(!esd) return; - AliESDUtils::RefitESDVertexTracks( esd ); // TODO only for LHC11a right? - AliJEventHeader *hdr = ReadCommonHeader( esd ); - //create a header and fill it - AliMultiplicity *fSPDMult =(AliMultiplicity *) esd->GetMultiplicity(); - if(fSPDMult) hdr->SetSPDTrackletMult(fSPDMult->GetNumberOfTracklets()); - - //TODO Store Detector data - if( fStoreEventPlaneSource ){ - *fVZEROData = *esd->GetVZEROData(); - *fTZEROData = AliESDTZERO(*esd->GetESDTZERO()); - *fZDCData = *esd->GetESDZDC(); - } - hdr->SetEventID( esd->GetEventNumberInFile()); - const AliESDVertex * vtxESD = esd->GetPrimaryVertex(); - if( vtxESD->GetStatus() == 0 ) hdr->SetVtxMult( 0 ); - // if fNcontributes > 0 then status is always true. do we need this? -} + // Intialisation of parameters + AliInfo("Doing initialization") ; -//______________________________________________________________________________ -void AliJCORRANTask::ReadAODHeader(AliAODEvent *aod) -{ - //Read the AliAODEvent and fill the list of AliJEventHeader containers - AliJEventHeader *hdr = ReadCommonHeader( aod ); + fFilter->Init(); - const AliAODTracklets *trackletsSPD = aod->GetTracklets(); - if(trackletsSPD){ - hdr->SetSPDTrackletMult(trackletsSPD->GetNumberOfTracklets()); - } - //TODO hdr->SetEventID( esd->GetEventNumberInFile()); + // TString formula(fEsdTrackCuts->GetMaxDCAToVertexXYPtDep()); + // if(formula.Length()>0){ // momentum dep DCA cut for AOD + // formula.ReplaceAll("pt","x"); + // } } //______________________________________________________________________________ -Int_t AliJCORRANTask::GetSuperModuleNumber(bool isemcal, Int_t absId) +void AliJCORRANTask::Terminate(Option_t * option) { - //get super module number - if(isemcal){ - // return GetEMCALGeoUtils()->GetSuperModuleNumber(absId) ; - return fEMCALGeoUtils->GetSuperModuleNumber(absId) ; - - } else { - Int_t relId[4]; - if ( absId >= 0) { - fPHOSGeom->AbsToRelNumbering(absId,relId); - fPHOSGeom->AbsToRelNumbering(absId,relId); - return relId[0]-1; - } else return -1; - }//PHOS - - return -1; -} - -//_____________________________________________________________________________ - -UInt_t AliJCORRANTask::ConvertTriggerMask(){ - - //convert alice trigger mask to jcorran trigger mask - UInt_t triggerMaskJC=0; - if(((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler())) - ->IsEventSelected() & AliVEvent::kMB){ - // minimum bias TBit 0 - triggerMaskJC += (1<GetInputEventHandler())) - ->IsEventSelected() & AliVEvent::kHighMult){ - //high multiplicity trigger TBit 1 - triggerMaskJC += (1<Stack(); - Int_t np = fMC->GetNumberOfTracks(); - - // AliGenEventHeader* genHeader = fMC->GenEventHeader(); - // AliGenPythiaEventHeader* pythiaGenHeader = dynamic_cast(genHeader); - // Double_t ptHard = 0; - // Double_t nTrials = 1; // Trials for MC trigger weigth for real data - // nTrials = pythiaGenHeader->Trials(); - // ptHard = pythiaGenHeader->GetPtHard(); - // Int_t nprim = stack->GetNtrack(); - - Short_t ntrack = 0; - - for(Int_t iTrack = 0; iTrack < np; iTrack++){ - AliMCParticle *track = (AliMCParticle*) fMC->GetTrack(iTrack); - if(!track){ - Printf("ERROR: Could not receive track %d", iTrack); - continue; - } - Bool_t isPrimary = fMC->Stack()->IsPhysicalPrimary(iTrack); - if(isPrimary){ - //create a new JMCTrack and fill the track info - AliJMCTrack *ctrack = new( (*fMCTrackList)[ntrack++] ) AliJMCTrack;; - - TParticle *partStack = stack->Particle(iTrack); - Int_t pdg = partStack->GetPdgCode(); - // BS unused : Float_t engy = partStack->Energy(); - // BS unused : Float_t pt = partStack->Pt(); - // BS unused : Float_t ptot = partStack->P(); - // BS unused : Float_t eta = partStack->Eta(); - // BS unused : Float_t theta = partStack->Theta(); - // BS unused : Float_t phi = atan2(sin( partStack->Phi()), cos(partStack->Phi())); - // BS unused : Short_t ch = (Short_t) partStack->GetPDG()->Charge(); - Int_t label = track->GetLabel(); - - ctrack->SetLabel(label); - ctrack->SetPdgCode(pdg); - ctrack->SetPxPyPzE( partStack->Px(), partStack->Py(), partStack->Pz(), partStack->Energy()); - //ctrack->SetCharge(ch); - ctrack->SetFlag(AliJMCTrack::kPrimary, isPrimary); - - ctrack->SetProductionVertex(partStack->Vx(),partStack->Vy(),partStack->Vz()); - /* - Int_t status = partStack->GetStatusCode(); - ctrack->SetStatusCode(status); - - //ctrack->SetPtHard(ptHard); - - //bool isInc = (status == 1 && icode == 22); //Inclusive - bool ispi0 = (status == 11 && pdg == 111); //kPizero - bool isDgamma = (status == 6 || status == 7) && pdg == 22; // Direct photon - bool inPHOS = (ispi0||isDgamma)&&fabs(eta)<0.12; - bool inEMCAL = (ispi0||isDgamma)&&fabs(eta)<0.7; - bool inTPC = fabs(eta)<0.9; - ctrack->SetMother(0,partStack->GetFirstMother()); - ctrack->SetMother(1,partStack->GetSecondMother()); - ctrack->SetDaughter(0,partStack->GetFirstDaughter()); - ctrack->SetDaughter(1,partStack->GetLastDaughter()); - ctrack->SetIsInPHOS(inPHOS); - ctrack->SetIsInEMCAL(inEMCAL); - ctrack->SetIsInTPC(inTPC); - */ - }// loop for al primary tracks - } -} - -//-------------------------------------------------------------------- -bool AliJCORRANTask::AcceptAODTrack(AliAODTrack* aodTrack){ - //This function mimics for the AliAODTracks object the AliESDtrackCut function IsSelected - //Cuts are taken from fEsdTrackCuts object - if(fEsdTrackCuts->GetMinNClusterTPC() > aodTrack->GetTPCNcls()) return kFALSE; - - //if(fEsdTrackCuts->GetMaxChi2PerClusterTPC() < );//<-------- how to check? - // ctrack->SetChi2perNDF(track->Chi2perNDF()); - - // C h e c k r e f i t - - /* - if(fEsdTrackCuts->GetRequireTPCRefit() && - ((aodTrack->GetStatus() & AliJTrack::kTPCrefit) == 0)) return kFALSE; - if(fEsdTrackCuts->GetRequireITSRefit() && - ((aodTrack->GetStatus() & AliJTrack::kITSrefit) == 0)) return kFALSE; - */ - - // C u t s o n D C A - Float_t impactDCA[3]; - if( aodTrack->GetPosition(impactDCA)){ - if((fEsdTrackCuts->GetMaxDCAToVertexXY()>0) && - (fEsdTrackCuts->GetMaxDCAToVertexXY() < sqrt(impactDCA[0]*impactDCA[0] + impactDCA[1]*impactDCA[1]))) return kFALSE; - if((fEsdTrackCuts->GetMaxDCAToVertexZ()>0) && - (fEsdTrackCuts->GetMaxDCAToVertexZ() < TMath::Abs(impactDCA[2]))) return kFALSE; - } else return kFALSE; - - - - // if(fEsdTrackCuts->GetAcceptKinkDaughters()) //<--------how to check ? - // esdTrackCuts->SetAcceptKinkDaughters(kFALSE); - - - return kTRUE; -} - -bool AliJCORRANTask::SetAliceTriggerDef(AliJRunHeader *RunInfo){ - RunInfo->AddAliceTriggerDef( "kMB", AliVEvent::kMB ); - if( fRunType == "LHC10h" ) - { - RunInfo->AddAliceTriggerDef( "kINT7", AliVEvent::kINT7 ); - RunInfo->AddAliceTriggerDef( "kMUON", AliVEvent::kMUON ); - RunInfo->AddAliceTriggerDef( "kHighMult", AliVEvent::kHighMult ); - RunInfo->AddAliceTriggerDef( "kEMC1", AliVEvent::kEMC1 ); - RunInfo->AddAliceTriggerDef( "kCINT5", AliVEvent::kCINT5 ); - RunInfo->AddAliceTriggerDef( "kCMUS5", AliVEvent::kCMUS5 ); - RunInfo->AddAliceTriggerDef( "kMUSH7", AliVEvent::kMUSH7 ); - RunInfo->AddAliceTriggerDef( "kMUL7", AliVEvent::kMUL7 ); - RunInfo->AddAliceTriggerDef( "kMUU7", AliVEvent::kMUU7 ); - RunInfo->AddAliceTriggerDef( "kEMC7", AliVEvent::kEMC7 ); - RunInfo->AddAliceTriggerDef( "kMUS7", AliVEvent::kMUS7 ); - RunInfo->AddAliceTriggerDef( "kPHI1", AliVEvent::kPHI1 ); - RunInfo->AddAliceTriggerDef( "kPHI7", AliVEvent::kPHI7 ); - RunInfo->AddAliceTriggerDef( "kUserDefined", AliVEvent::kUserDefined ); - RunInfo->AddAliceTriggerDef( "kFastOnly", AliVEvent::kFastOnly ); - RunInfo->AddAliceTriggerDef( "kAny", AliVEvent::kAny ); - RunInfo->AddAliceTriggerDef( "kAnyINT", AliVEvent::kAnyINT ); - } - else{ - // Default - RunInfo->AddAliceTriggerDef( "kINT7", AliVEvent::kINT7 ); - RunInfo->AddAliceTriggerDef( "kMUON", AliVEvent::kMUON ); - RunInfo->AddAliceTriggerDef( "kHighMult", AliVEvent::kHighMult ); - RunInfo->AddAliceTriggerDef( "kEMC1", AliVEvent::kEMC1 ); - RunInfo->AddAliceTriggerDef( "kCINT5", AliVEvent::kCINT5 ); - RunInfo->AddAliceTriggerDef( "kCMUS5", AliVEvent::kCMUS5 ); - RunInfo->AddAliceTriggerDef( "kMUSH7", AliVEvent::kMUSH7 ); - RunInfo->AddAliceTriggerDef( "kMUL7", AliVEvent::kMUL7 ); - RunInfo->AddAliceTriggerDef( "kMUU7", AliVEvent::kMUU7 ); - RunInfo->AddAliceTriggerDef( "kEMC7", AliVEvent::kEMC7 ); - RunInfo->AddAliceTriggerDef( "kMUS7", AliVEvent::kMUS7 ); - RunInfo->AddAliceTriggerDef( "kPHI1", AliVEvent::kPHI1 ); - RunInfo->AddAliceTriggerDef( "kPHI7", AliVEvent::kPHI7 ); - RunInfo->AddAliceTriggerDef( "kUserDefined", AliVEvent::kUserDefined ); - RunInfo->AddAliceTriggerDef( "kFastOnly", AliVEvent::kFastOnly ); - RunInfo->AddAliceTriggerDef( "kAny", AliVEvent::kAny ); - RunInfo->AddAliceTriggerDef( "kAnyINT", AliVEvent::kAnyINT ); - } - return true; -} - -bool AliJCORRANTask::SetAliceFilterMapDef(AliJRunHeader *RunInfo) { - if( fRunType == "LHC10h" ) - { - RunInfo->AddAliceFilterMapDef("EsdTrackCutsL",BIT(0)); - RunInfo->AddAliceFilterMapDef("EsdTrackCutsITsa",BIT(1)); - RunInfo->AddAliceFilterMapDef("ItsStrong",BIT(2)); - RunInfo->AddAliceFilterMapDef("ElectronID",BIT(3)); - RunInfo->AddAliceFilterMapDef("EsdTrackCutsH",BIT(4)); - RunInfo->AddAliceFilterMapDef("EsdTrackCutsH2",BIT(5)); - RunInfo->AddAliceFilterMapDef("EsdTrackCutsH3",BIT(6)); - RunInfo->AddAliceFilterMapDef("EsdTrackCutsTPCOnly",BIT(7)); - RunInfo->AddAliceFilterMapDef("EsdTrackCutsRaa",BIT(8)); - } - else - { - // Default - RunInfo->AddAliceFilterMapDef("EsdTrackCutsL",BIT(0)); - RunInfo->AddAliceFilterMapDef("EsdTrackCutsITsa",BIT(1)); - RunInfo->AddAliceFilterMapDef("ItsStrong",BIT(2)); - RunInfo->AddAliceFilterMapDef("ElectronID",BIT(3)); - RunInfo->AddAliceFilterMapDef("EsdTrackCutsH",BIT(4)); - RunInfo->AddAliceFilterMapDef("EsdTrackCutsH2",BIT(5)); - RunInfo->AddAliceFilterMapDef("EsdTrackCutsH3",BIT(6)); - RunInfo->AddAliceFilterMapDef("EsdTrackCutsTPCOnly",BIT(7)); - RunInfo->AddAliceFilterMapDef("EsdTrackCutsRaa",BIT(8)); - } - return true; -} - -void AliJCORRANTask::PrintOut() { - AliJRunHeader * RunInfo = fAliRunHeader; - cout << "===== TriggerDef =====" << endl; - cout << RunInfo->GetAliceTriggerDef("kMB") << endl; - cout << RunInfo->GetAliceTriggerDef("kINT7") << endl; - cout << RunInfo->GetAliceTriggerDef("kMUON") << endl; - cout << RunInfo->GetAliceTriggerDef("kHighMult") << endl; - cout << RunInfo->GetAliceTriggerDef("kEMC1") << endl; - cout << RunInfo->GetAliceTriggerDef("kCINT5") << endl; - cout << RunInfo->GetAliceTriggerDef("kCMUS5") << endl; - cout << RunInfo->GetAliceTriggerDef("kMUSH7") << endl; - cout << RunInfo->GetAliceTriggerDef("kMUL7") << endl; - cout << RunInfo->GetAliceTriggerDef("kMUU7") << endl; - cout << RunInfo->GetAliceTriggerDef("kEMC7") << endl; - cout << RunInfo->GetAliceTriggerDef("kMUS7") << endl; - cout << RunInfo->GetAliceTriggerDef("kPHI1") << endl; - cout << RunInfo->GetAliceTriggerDef("kPHI7") << endl; - cout << RunInfo->GetAliceTriggerDef("kUserDefined") << endl; - cout << RunInfo->GetAliceTriggerDef("kFastOnly") << endl; - cout << RunInfo->GetAliceTriggerDef("kAny") << endl; - cout << RunInfo->GetAliceTriggerDef("kAnyINT") << endl; - cout << "===== FilterMapDef =====" << endl; - cout << RunInfo->GetAliceFilterMapDef("EsdTrackCutsL") << endl; - cout << RunInfo->GetAliceFilterMapDef("EsdTrackCutsITsa") << endl; - cout << RunInfo->GetAliceFilterMapDef("ItsStrong") << endl; - cout << RunInfo->GetAliceFilterMapDef("ElectronID") << endl; - cout << RunInfo->GetAliceFilterMapDef("EsdTrackCutsH") << endl; - cout << RunInfo->GetAliceFilterMapDef("EsdTrackCutsH2") << endl; - cout << RunInfo->GetAliceFilterMapDef("EsdTrackCutsH3") << endl; - cout << RunInfo->GetAliceFilterMapDef("EsdTrackCutsTPCOnly") << endl; - cout << RunInfo->GetAliceFilterMapDef("EsdTrackCutsRaa") << endl; -} - + fFilter->Terminate(); + + // Processing when the event loop is ended + fAliJRunHeader->PrintOut(); + cout<<"AliJCORRANTask Analysis DONE !!"< (GetOutputData(1)); + if(fRunInfoList) + { + AliJRunHeader *fAliRunHeader = dynamic_cast (fRunInfoList->FindObject("AliJRunHeader")); + if(fAliRunHeader) {fAliRunHeader->Print();} + } + else + { + cout << "WARNING : Run Information List is empty" << endl; + } -//******************************************** -// UTILS -//******************************************** -void AliJCORRANTask::AddListAODBranch(const char* aname, const char* cname, TClonesArray **obj, int nlist){ - *obj = new TClonesArray(cname, nlist); - (*obj)->SetName(aname); - AddAODBranch("TClonesArray", obj, fAODName.Data() ); } diff --git a/PWGCF/Correlations/JCORRAN/AliJCORRANTask.h b/PWGCF/Correlations/JCORRAN/AliJCORRANTask.h old mode 100755 new mode 100644 index 0ae9997f355..abea78ad855 --- a/PWGCF/Correlations/JCORRAN/AliJCORRANTask.h +++ b/PWGCF/Correlations/JCORRAN/AliJCORRANTask.h @@ -32,17 +32,16 @@ #include "AliESDZDC.h" #include "AliJConst.h" #include "AliESDpid.h" -#include "AliEMCALGeometry.h" #include "AliPHOSGeoUtils.h" #include "AliPIDResponse.h" #include "AliPIDCombined.h" +#include "AliJFilter.h" +#include "AliJEfficiencyScanner.h" //============================================================== using namespace std; -const int kMaxDimBuffer = 300;//max length of a line read to a buffe - class TH1D; class TH2D; class TNtuple; @@ -77,88 +76,31 @@ class AliJCORRANTask : public AliAnalysisTaskSE { // methods to fill from AliAnalysisTaskSE virtual void UserCreateOutputObjects(); - virtual void Init(); + virtual void Init(); virtual void LocalInit() { Init(); } virtual void UserExec(Option_t *option); - virtual void Terminate(Option_t * opt = ""); - - TString GetRunType() const { return fRunType;} - void SetRunType( const TString type ){ fRunType = type; } - void SetESDtrackCuts(AliESDtrackCuts* esdTrackCuts){ fEsdTrackCuts = esdTrackCuts;} - void SetESDFilter( AliAnalysisFilter * filter ){ fESDFilter = filter; } - void SetRealOrMC(Bool_t realormc){fIsRealOrMC[0]=realormc;} //flags whether the input - void SetStoreEventPlaneSource(bool dostore ){ fStoreEventPlaneSource = dostore; } - bool GetStoreEventPlaneSource(){ return fStoreEventPlaneSource; }; - void SetStoreTPCTrack(bool dostore ){ fStoreTPCTrack = dostore; } - bool GetStoreTPCTrack(){ return fStoreTPCTrack; }; - //are ESDs from real exp or MonteCarlo + virtual void Terminate(Option_t* option=""); + + AliJFilter *GetFilter() { return fFilter; } + + AliJRunHeader * GetJRunHeader(){ return fAliJRunHeader; } + void SetJRunHeader( AliJRunHeader * hdr ){ fAliJRunHeader = hdr ; } void SetOutputAODName(const char* aodname){ fAODName=aodname;} - // AliEMCALGeoUtils* GetEMCALGeoUtils (bool doDelete=kFALSE); + TString *GetOutputAODName() {return &fAODName;} + + void SetDoStoreJOD(Bool_t doeff){ fDoStoreJOD=doeff; } + Bool_t GetDoStoreJOD(){ return fDoStoreJOD; } private: - AliJEventHeader* ReadCommonHeader(AliVEvent *event); - // methods to read data from ESD - void ReadESDTracks(AliESDEvent* esd); - void ReadESDCaloClusters(const AliESDEvent* esd); - void ReadESDHeader(AliESDEvent* esd); - void ReadESDPID(AliESDtrack* track, AliJTrack* ctrack); - // methods to read data from AOD - void ReadAODTracks(const AliAODEvent* aod); - void ReadAODCaloClusters(const AliAODEvent* aod); - void ReadAODHeader(AliAODEvent* aod); - void ReadFilter(); - void ReadMCTracks(AliMCEvent* fMC); - Int_t GetSuperModuleNumber(bool isemcal, Int_t absId); - - UInt_t ConvertTriggerMask();//Converts alice trigger mask to JCorran trigger mask - //functions used for event selction: - bool AcceptAODTrack(AliAODTrack* aodTrack); - void SetOADBPath(const char* path) {fOADBPath=path;} - const char* GetOADBPath() const { return fOADBPath.Data(); } - - // method to fill jcorran - bool SetAliceTriggerDef(AliJRunHeader *runHeader); - bool SetAliceFilterMapDef(AliJRunHeader *runHeader); //TODO Check - void PrintOut(); - // UTILS - void AddListAODBranch(const char* aname, const char* cname, TClonesArray **obj, int nlist); - - // d a t a m e m b e r s - TString fRunType; // ex) LHC10h - TString fInputFormat; // specify the input data format (ESD or AOD) - AliESDtrackCuts* fEsdTrackCuts; //track selection cuts - AliAnalysisFilter * fESDFilter; //filter set of track selection BS - TVectorT fIsRealOrMC; //flags if the input are real (0) ESDs or MonteCarlo ESDs (1) + AliJFilter *fFilter; // filter object TString fAODName; //output delta AOD name - TString fActiveTriggers[AliJConst::kRangeTriggerTableAlice];//alice table mapping trigger bit to trigger name - TString fTriggerTableJCorran[AliJConst::kRangeTriggerTableJCorran];//JCorran trigger table TBit 0 =MinBias - bool fStoreEventPlaneSource; - bool fStoreTPCTrack; - TString fOADBPath; - - // jcorran output objects - - TClonesArray * fTrackList; // list of charged track objects - TClonesArray * fMCTrackList; // list of charged track objects - TClonesArray * fPhotonList; // list of photons objects - TClonesArray * fHeaderList; // event details - TList * fRunInfoList; // run details - - AliESDpid *fPIDesd; - AliPIDResponse *fPIDResponse; // PID response object - AliPIDCombined *fPIDCombined; - - AliESDVZERO* fVZEROData; - AliESDTZERO* fTZEROData; - // AliESDFMD* fFMDData; - AliESDZDC* fZDCData; + TTree *fJODTree; + AliJRunHeader * fAliJRunHeader; - AliJRunHeader* fAliRunHeader;// run details (mg field, trigger mask,etc...) - AliEMCALGeometry * fEMCALGeoUtils; // no AliEMCALGeoUtils.h in trunk aliroot (111130) - AliPHOSGeoUtils * fPHOSGeom; //phos geometry matrix + Bool_t fDoStoreJOD; - ClassDef(AliJCORRANTask, 1); + ClassDef(AliJCORRANTask, 2); }; #endif // AliJCORRANTask_H diff --git a/PWGCF/Correlations/JCORRAN/AliJCard.cxx b/PWGCF/Correlations/JCORRAN/AliJCard.cxx new file mode 100644 index 00000000000..6a1a1313174 --- /dev/null +++ b/PWGCF/Correlations/JCORRAN/AliJCard.cxx @@ -0,0 +1,349 @@ +//==================================== +//last modified FK 6.NOV 2009 +//==================================== +//blah +// blah + +#include "AliJCard.h" + +//ClassImp(AliJCard); + +AliJCard::AliJCard(): + AliJBaseCard(), + fhCorr(0), + feventV3kv(0), + fIndexVector(0), + fpi0massbin(0) +{ + //constructor +} + +AliJCard::AliJCard(const char *filename): + AliJBaseCard(filename), + fhCorr(0), + feventV3kv(0), + fIndexVector(0), + fpi0massbin(0) +{ + //constructor + InitCard(); + MakeFastCorrTypeIndex(); +} + + + +AliJCard::AliJCard(const AliJCard& obj) : + AliJBaseCard(), + fhCorr(obj.fhCorr), + feventV3kv(obj.feventV3kv), + fIndexVector(obj.fIndexVector), + fpi0massbin(obj.fpi0massbin) +{ + // copy constructor + JUNUSED(obj); +} + + +AliJCard& AliJCard::operator=(const AliJCard& obj){ + // copy constructor + JUNUSED(obj); + return *this; +} + +AliJCard::~AliJCard(){ + // destructor + if( fpi0massbin ){ + for( int i = 0; i < GetNoOfBins( kCentrType ); i++ ){ + delete [] fpi0massbin[i]; + } // destructor + delete [] fpi0massbin; + } + if( fhCorr ){ + delete fhCorr; + } +} + +void AliJCard::MakeFastCorrTypeIndex(){ + // make fast findex array + for( unsigned int i=0;iGet("UpperPairPtCut",i)) i++; + if(i -1 ){ + return (int) fValuesVector[findex].GetNrows(); + }else{ + cout<<"ERROR: fValuesVector fast findex out of range "<< findex << " " << (GetKeyWord( ctype )).Data() << endl; + exit(1); + } +} + + +float AliJCard::Get(corrType ctype, int VectorComponent){ + //returns VectorComponent Component of fValuesVecto`uor TVector for given keyword + return Get(GetKeyWord(ctype), VectorComponent); +} + +float AliJCard::GetFast(corrType ctype, int VectorComponent){ + // fast get + + if(0<=VectorComponent && VectorComponent -1 ){ + return fValuesVector[fIndexVector[ctype]][VectorComponent+1]; + }else{ + cout<<"ERROR: fValuesVector fast findex out of range "<< (GetKeyWord(ctype)).Data()< -1 ){ + cout<<" (dim ="<GetNrows(), v->GetMatrixArray(), val ); + if( iBin2 >= v->GetNrows()-1 ) iBin2 = -1; + + return iBin2; +} + +int AliJCard::GetBinFast(corrType ctype, float val){ + // fast get bin + + if(ctype == kNoType) return 0; + + for(int i=0; i<(GetNFast(ctype)-1); i++) + if(GetFast(ctype,i)<=val && val 0; //masking on >0 masking off ==0 desired trigger +} + + +bool AliJCard::SimilarVertZ(float Z1, float Z2){ + // z vert + static double v = Get("maxMixDZ"); + if( v < 0 ) return 1; + return fabs(Z1-Z2) < v ; +} + +bool AliJCard::SimilarMultiplicity(float mult1, float mult2){ + // multi + static double v = Get("maxMixDMult"); + if( v <0) return 1; + return fabs(mult1-mult2) < v; +} + + +bool AliJCard::SimilarCentrality(float c1, float c2, int cbin){ + // centra + static TVector *v = GetVector("maxDCent"); + if(v==NULL) return 1; + return fabs(c1-c2) < (*v)[cbin+1]; // TODO +} + + +//--------- P H E N I X C G L -------------- + +bool AliJCard::InPhiRange(float Phi){ + // phi + bool isIn = false; + for(int i=1; i Get("MaxChi2PerClusterTPC")) isGoodTrack = false; + return isGoodTrack; +} + +bool AliJCard::CheckMinNumTPCClustPt(int NClustersTPC, float fpt){ + // tpc pars + float minNTPCCls = Get("ParMinNClustTPCPt",0)*log(Get("ParMinNClustTPCPt",1)*fpt + Get("ParMinNClustTPCPt",2)); + if(NClustersTPC > minNTPCCls) return true; //track had enough clusters + else return false; //track did not have sufficient number of clusters +} + + +bool AliJCard::CheckTrackImpact(float xyIm, float zIm, float fpt){ + // tpc pars + bool isGoodTrack = true; + if(TMath::Abs(xyIm) > Get("ParMaxDCAToVertexXYPtDep",0)+Get("ParMaxDCAToVertexXYPtDep",1)/pow(fpt,Get("ParMaxDCAToVertexXYPtDep",2))){ + isGoodTrack = false; + } + if(TMath::Abs(zIm) > Get("MaxDCAToVertexZ")) isGoodTrack = false; + + return isGoodTrack; +} + + + +bool AliJCard::DeltaEtaCheck(const AliJBaseTrack *ftk1, const AliJBaseTrack *ftk2) { + // deta + double delta = fabs( log(tan(ftk1->Theta()/2.0)) - log(tan(ftk2->Theta()/2.0)) ); + if(Get("etaCut")>0) return delta < Get("etaCut"); + if(Get("etaCut")<0) return delta > Get("etaCut"); + + return true; +} + + + + + + + + + + + + + + + + + + + + + diff --git a/PWGCF/Correlations/JCORRAN/AliJCard.h b/PWGCF/Correlations/JCORRAN/AliJCard.h new file mode 100644 index 00000000000..73d71c0c26e --- /dev/null +++ b/PWGCF/Correlations/JCORRAN/AliJCard.h @@ -0,0 +1,201 @@ +//================================================= +// AliJCard.h +// last modified FK 6.NOV 2009 +//================================================= + +#ifndef ALIJCARD_H +#define ALIJCARD_H + +#include + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "AliJConst.h" +#include "AliJBaseCard.h" + +class AliJBaseTrack; +#include "AliJPhoton.h" +class AliJTrack; + +using namespace std; + + +class AliJCard : public AliJBaseCard { + + public: + + AliJCard(); // constructor + AliJCard(const char *filename); // constructor + AliJCard(const AliJCard& obj); + AliJCard& operator=(const AliJCard& obj); + + virtual ~AliJCard(); + + void MakeFastCorrTypeIndex(); + + void PrintOut(); + + float Get(TString keyword, int VectorComponent=0){ return AliJBaseCard::Get(keyword, VectorComponent); } + float Get(corrType ctype, int VectorComponent =0); //get TVector component + float GetFast(corrType ctype, int VectorComponent=0); //get TVector component + int GetN(TString keyword){ return AliJBaseCard::GetN(keyword); } //get TVector dimension + int GetN(corrType ctype); //get TVector dimension + int GetNFast(corrType ctype); //get TVector dimension + + //---- Collision Species -- + float GetCollisionType() { return Get("CollisionType");} + + //------ v e r t e x ----- + + float VertInZRange(float Z) { + //cout<< "zv " << Z <<" "<< ( GetBinBorder(kZVertType,0) < Z && Z < GetBinBorder(kZVertType, GetNoOfBins(kZVertType)) ) < ZVertErr)) return true; + else return false; + } + + int IsLessThanUpperPairPtCut(double inPairPt); + + + //--- c o r r e l a t i o n bins & borders -- + int GetNoOfBins (corrType ctype){ return GetNFast(ctype)-1; } + float GetBinBorder(corrType ctype, int ii){ return GetFast(ctype,ii); } + int GetBin(corrType ctype, float val); + int GetBinFast(corrType ctype, float val); + double GetBinCenter(corrType ctype, int ii){ return (GetFast(ctype,ii)+GetFast(ctype,ii+1))/2.;} + + //----- m i x i n g ---- + int GetEventPoolDepth(int cBin){ return (int) Get("EventPoolDepth",cBin);} + bool SimilarVertZ(float Z1, float Z2); + bool SimilarMultiplicity(float mult1, float mult2); + bool SimilarCentrality(float c1, float c2, int cbin); + + //run characteristics + bool IsGoodRun(int runID); + + //trigger + bool MbTrigger(int triggin) const; + + //photon + bool IsPhoton(AliJPhoton *g){ return g->GetProbPhot() > Get("probPhot"); } + float GetPhotEnergyCut(){ return Get("minEnergy"); } + + bool InPhiRange(float Phi); + bool IsInZEDandThetaRange(float zedDC, float theta){ + return (fabs(zedDC) Get("deltaZEDPhiDC",0) && fabs(PhiDC) > Get("deltaZEDPhiDC",1)); + } + + /* bool CheckCovDiagonalElements(double *element){ + if(Get("MaxCovDiagonalElements",0)<0) return true; + bool isGoodTrack = true; + for(Int_t i=0;i<5;i++){ + if(Get("MaxCovDiagonalElements",i) < element[i]) isGoodTrack = false; + } + return isGoodTrack; + }*/ + + bool CheckTrackParamsInTPC(int NClustersTPC,float Chi2PerClusterTPC); + + bool CheckMinNumTPCClustPt(int NClustersTPC, float fpt); + + bool CheckTrackImpact(float xyIm, float zIm, float fpt); + + + bool AcceptKinkDaughters(int kinkIndex){ + if(( ! (bool) Get("AcceptKinkDaughters")) && kinkIndex > 0 ) return false;//we do not want kinks but kink findex>0 + else return true; + } + + + double GetCutOnBkgActivity(){ + return (double) Get("CutOnBkgActivity"); + } + + void SetEventV3kv(double inV3kv) {feventV3kv = inV3kv;} + double GetEventV3kv() const {return feventV3kv;} + + //Alice CALO + bool ReadEmcalSm(int sm){ return (bool) Get("EMCAL_SM",sm);} + bool ReadPhosSm(int sm){ return (bool) Get("PHOS_SM",sm);} + + bool MixPhotonForPi0Mass() {return ((int) Get("massMix")==1);}//FK// + bool MixMBForPi0Mass() {return ((int) Get("massMixMB")>0);} + bool MixMBMBForPi0Mass() {return ((int) Get("massMixMB")==2);} + + virtual void InitCard(); //TODO + void FinishCard(); // TODO + + + protected: + + + TString GetKeyWord(corrType ctype); + corrType GetCorrType( TString inStr ); + + //==== D a t a M e m b e r s ======== + + // double effPar[16]; + // double corrCent[10]; //FK// additional scaling factor to effPar to correct on hi fcentrality + TH2D *fhCorr; // comment me + + double feventV3kv; // comment me + + vector< int > fIndexVector; //array of float number confg parameter vectors + + Double_t **fpi0massbin; //! faster access to pi0 mass bins + + //ClassDef(AliJCard, 1); // EMCAL for jcorran +}; + +#endif + + + + + + + + + + + + + + + + + + + + + + diff --git a/PWGCF/Correlations/JCORRAN/AliJConst.h b/PWGCF/Correlations/JCORRAN/AliJConst.h old mode 100755 new mode 100644 index 167d46b9b85..93af311945e --- a/PWGCF/Correlations/JCORRAN/AliJConst.h +++ b/PWGCF/Correlations/JCORRAN/AliJConst.h @@ -1,3 +1,20 @@ +/************************************************************************** + * Copyright(c) 1998-2014, 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. * + **************************************************************************/ + +// Comment describing what this class does needed! + // $Id: JConst.h,v 1.5 2008/05/08 15:19:52 djkim Exp $ //////////////////////////////////////////////////// @@ -14,17 +31,19 @@ #ifndef JCONST_H #define JCONST_H +#define JUNUSED(expr) do { (void)(expr); } while (0) + // // Constants // // for JHisto and PhxJHisto #define kMaxNoCentrBin 10 // Maximum no of centrality bins defined in JCard.h #define kMaxTriggParticleType 35 // -#define kMaxJetType 32 // -#define kPtDim 20 // +#define kMaxJetType 32 // +#define kPtDim 15 // #define kMaxNoRuns 100 // Maximum no of runs in a nanoDST file +#define kMaxNoEPBin 24 -namespace AliJConst { const double kJPi = 3.14159265358979; //TMath::Pi(); const double kJTwoPi = 2*kJPi; const double kJToRadian = kJPi/180.; @@ -32,46 +51,46 @@ const double kJToDegree = 180./kJPi; const double kElectronMass = .51099906e-3; const double kPionMass = .1395675; -enum expName {kPHENIX, kALICE}; -const int kNumberOfExperiments = 2; //numberOfExperiments - -// Centrality -const int kNCentBin = 5; -const double kCentralityBins[kNCentBin+1] = { 0, 10, 20, 30, 40, 100 }; //====================== particle types ============================================ -const int kNumberOfParticleTypes = 9; -enum particleType {kHadron, kPion, kKaon, kProton, kPhoton, kDecayphoton, kPizero, kEta, kNone}; +const int kNumberOfParticleTypes = 10; +enum particleType {kHadron, kPion, kKaon, kProton, kPhoton, kDecayphoton, kPizero, kEta,kHadronMC, kJet, kJNone}; const char* const kParticleTypeStrName[kNumberOfParticleTypes] = - {"hadron", "pion", "kaon", "proton", "photon", "decayphoton", "pizero", "eta", "none"}; -const char* const kParticleProtoType[kNumberOfExperiments][kNumberOfParticleTypes] = - {{"PhJCgl", "PhJCgl", "PhJCgl", "PhJCgl", "PhJPhoton", "PhJPhoton", "AliPhJPiZero", "AliPhJPiZero", "None"}, - {"AliJTrack", "AliJTrack", "AliJTrack", "AliJTrack", "AliJPhoton", "AliJPhoton", "AliPhJPiZero", "AliPhJPiZero", "None"}}; - + {"hadron", "pion", "kaon", "proton", "photon", "decayphoton", "pizero", "eta", "hadronMC", "none"}; +const char* const kParticleProtoType[kNumberOfParticleTypes] = + {"AliJTrack", "AliJTrack", "AliJTrack", "AliJTrack", "AliJPhoton", "AliJPhoton", "AliJPiZero", "AliJPiZero", "None"}; //=======================JCorran trigger table definition=========================== //internal JCorran trigger mask TBit=0 is MinBias, TBit=1 HighMultiplicityTrigger -enum TriggerBitJCorran {kMinBiasTriggerBitJCorran, kHighMultTriggerBitJCorran}; +enum TriggerBitJCorran {kMinBiasTriggerBitJCorran, kHighMultTriggerBitJCorran, + kEmc0TriggerBitJCorran, + kEmc1GammaTriggerBitJCorran, kEmc1JetTriggerBitJCorran, + kCentralTriggerBitJCorran,kSemiCentralTriggerBitJCorran, + kFastOnlyBitJCorran, + kINT7TriggerBitJCorran, kJNTriggerBit + }; const int kRangeTriggerTableAlice = 50; const int kRangeTriggerTableJCorran = 16; //================================================================================== -enum fillType { kReal, kMixed, kRotated }; -enum corrType { kTriggType, kAssocType, kXeType, kCentrType, kMassType, kNoType }; - -enum TriggerParticleType { kTriggParticles, kLeadingParticle, kIsolatedParticle, kJets }; // kJets for additional jet trigger counting. +enum fillType { kReal, kMixed, kEtaGap }; +enum corrFillType {kAzimuthFill=0,kPionFill=1}; +enum corrType { kTriggType, kAssocType, kXeType, kLongType, kCentrType, kZVertType, kMassType, kEtaGapType, kDiJetType, kRGapType, kNoType, kNcorrType }; +enum TriggerParticleType { kTriggParticles, kLeadingParticle, kIsolatedParticle }; -const char* const TriggerParticleTypeName[] = - {"TriggParticles","LeadingParticle","IsolatedParticle"}; +const char* const kTriggerParticleTypeName[] = + {"TriggParticles","LeadingParticle","IsolatedParticle"}; // JETs ===== -const int NJetAlg = 10; +const int kNJetAlg = 10; enum JetAlg {kkt,kantikt,ksiscone,krecomE,krecomB,kcdfmidpoint,kjade,kd0run2cone,kGF,kSimpleCone}; -char const * const kJetAlgStrName[NJetAlg] = +const char* const kJetAlgStrName[kNJetAlg] = {"kt","antikt","siscone","recomE","recomB","cdfmidpoint","jade","d0run2cone","GF","SimpleCone"}; +enum EPType { kEPV0A, kEPV0C, kEPV0AC, kNEPType }; +const int kNHarmonics = 5; // PHENIX constants enum TEMC {kPbSc, kPbGl}; -} + #endif diff --git a/PWGCF/Correlations/JCORRAN/AliJCorrelations.cxx b/PWGCF/Correlations/JCORRAN/AliJCorrelations.cxx new file mode 100644 index 00000000000..333139b599c --- /dev/null +++ b/PWGCF/Correlations/JCORRAN/AliJCorrelations.cxx @@ -0,0 +1,721 @@ +/************************************************************************** + * Copyright(c) 1998-2014, 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. * + **************************************************************************/ + +// Comment describing what this class does needed! + +#include "AliJCorrelations.h" +#include "AliJDataManager.h" + +#include "AliJCorrelations.h" +#include "AliJHistos.h" +#include "AliJBaseTrack.h" +#include "AliJCard.h" +#include "AliJHistos.h" +#include "AliJRunTable.h" + + + +//========================================================================== +// don't count the trigger here ! You'll miss the not associated triggers +// but you will miss them in the main code too, unles you loop over those +// fevent with no cgl (set the masMix to 1) +//========================================================================== +// blah + +AliJCorrelations::AliJCorrelations( AliJCard *cardIn, AliJHistos *histosIn) : + fcard(cardIn), + fhistos(histosIn), + fnReal(0), + fnMix(0), + fsumTriggerAndAssoc(0), + fsamplingMethod(0), // flat by default + fIsHeavyIon(0), + fawayPhiGap(0), + fmaxEtaRange(0), + fRSignalBin(0), + frandom(0x0), + fptt(0), + fpta(0), + fTrackPairEfficiency(0), + fIsIsolatedTrigger(false), + fpttBin(0), + fptaBin(0), + fPhiTrigger(0), + fPhiAssoc(0), + fDeltaPhi(0), + fDeltaPhiPiPi(0), + fDeltaEta(0), + fXlong(0), + fNearSide(true), + fEtaGapBin(0), + fPhiGapBinNear(0), + fPhiGapBinAway(0), + fRGapBinNear(0), + fRGapBinAway(0), + fCentralityBin(0), + fXlongBin(0), + fGeometricAcceptanceCorrection(1) +{ + // constructor + + fsumTriggerAndAssoc = int( fcard->Get("sumTriggerAndAssoc") ); + fmaxEtaRange = fcard->Get("EtaRange"); + fRSignalBin = int(fcard->Get("EtaGapSignalBin")); + + fDPhiUERegion[0] = fcard->Get("DPhiUERegion",0); + fDPhiUERegion[1] = fcard->Get("DPhiUERegion",1); + cout << fmaxEtaRange <<" fDPhiUERegion[0]="<< fDPhiUERegion[0] <<" fDPhiUERegion[1]="<< fDPhiUERegion[1] <GetBinBorder(kEtaGapType, 2); + // ----------------------------------------------------------------------------------------------- + + for(int iRGap=0; iRGap < fcard->GetNoOfBins(kRGapType); iRGap++) + fRGap[iRGap] = fcard->GetBinBorder( kRGapType, iRGap); + + //dPhiRange = fhistos->GetDphiRange(); + frandom = new TRandom3(); //FK// frandom generator for jt flow UE + frandom->SetSeed(0); //FK// + +} + +AliJCorrelations::AliJCorrelations() : + fcard(0x0), + fhistos(0x0), + fnReal(0), + fnMix(0), + fsumTriggerAndAssoc(0), + fsamplingMethod(0), // flat by default + fIsHeavyIon(0), + fawayPhiGap(0), + fmaxEtaRange(0), + fRSignalBin(0), + frandom(0x0), + fptt(0), + fpta(0), + fTrackPairEfficiency(0), + fIsIsolatedTrigger(false), + fpttBin(0), + fptaBin(0), + fPhiTrigger(0), + fPhiAssoc(0), + fDeltaPhi(0), + fDeltaPhiPiPi(0), + fDeltaEta(0), + fXlong(0), + fNearSide(true), + fEtaGapBin(0), + fPhiGapBinNear(0), + fPhiGapBinAway(0), + fRGapBinNear(0), + fRGapBinAway(0), + fCentralityBin(0), + fXlongBin(0), + fGeometricAcceptanceCorrection(1) +{ + // default constructor +} + +AliJCorrelations::AliJCorrelations(const AliJCorrelations& in) : + fcard(in.fcard), + fhistos(in.fhistos), + fnReal(in.fnReal), + fnMix(in.fnMix), + fsumTriggerAndAssoc(in.fsumTriggerAndAssoc), + fsamplingMethod(in.fsamplingMethod), + fIsHeavyIon(in.fIsHeavyIon), + fawayPhiGap(in.fawayPhiGap), + fmaxEtaRange(in.fmaxEtaRange), + fRSignalBin(in.fRSignalBin), + frandom(in.frandom), + fptt(in.fptt), + fpta(in.fpta), + fTrackPairEfficiency(in.fTrackPairEfficiency), + fIsIsolatedTrigger(in.fIsIsolatedTrigger), + fpttBin(in.fpttBin), + fptaBin(in.fptaBin), + fPhiTrigger(in.fPhiTrigger), + fPhiAssoc(in.fPhiAssoc), + fDeltaPhi(in.fDeltaPhi), + fDeltaPhiPiPi(in.fDeltaPhiPiPi), + fDeltaEta(in.fDeltaEta), + fXlong(in.fXlong), + fNearSide(in.fNearSide), + fEtaGapBin(in.fEtaGapBin), + fPhiGapBinNear(in.fPhiGapBinNear), + fPhiGapBinAway(in.fPhiGapBinAway), + fRGapBinNear(in.fRGapBinNear), + fRGapBinAway(in.fRGapBinAway), + fCentralityBin(in.fCentralityBin), + fXlongBin(in.fXlongBin), + fGeometricAcceptanceCorrection(in.fGeometricAcceptanceCorrection) +{ + // The pointers to card and histos are just copied. I think this is safe, since they are not created by + // AliJCorrelations and thus should not disappear if the AliJCorrelation managing them is destroyed. + + fDPhiUERegion[0] = in.fDPhiUERegion[0]; + fDPhiUERegion[1] = in.fDPhiUERegion[1]; + + for(int iRGap=0; iRGap < fcard->GetNoOfBins(kRGapType); iRGap++){ + fRGap[iRGap] = in.fRGap[iRGap]; + } + + frandom = new TRandom3(); // frandom generator for jt flow UE + frandom->SetSeed(0); +} + +AliJCorrelations& AliJCorrelations::operator=(const AliJCorrelations& in){ + // Assingment operator + + if (&in==this) return *this; + + fptt = in.fptt; + fpta = in.fpta; + fTrackPairEfficiency = in.fTrackPairEfficiency; + fIsIsolatedTrigger = in.fIsIsolatedTrigger; + fpttBin = in.fpttBin; + fptaBin = in.fptaBin; + fPhiTrigger = in.fPhiTrigger; + fPhiAssoc = in.fPhiAssoc; + fDeltaPhi = in.fDeltaPhi; + fDeltaPhiPiPi = in.fDeltaPhiPiPi; + fDeltaEta = in.fDeltaEta; + fXlong = in.fXlong; + fNearSide = in.fNearSide; + fEtaGapBin = in.fEtaGapBin; + fPhiGapBinNear = in.fPhiGapBinNear; + fPhiGapBinAway = in.fPhiGapBinAway; + fRGapBinNear = in.fRGapBinNear; + fRGapBinAway = in.fRGapBinAway; + fCentralityBin = in.fCentralityBin; + fXlongBin = in.fXlongBin; + fGeometricAcceptanceCorrection = in.fGeometricAcceptanceCorrection; + fnReal = in.fnReal; + fnMix = in.fnMix; + fsumTriggerAndAssoc = in.fsumTriggerAndAssoc; + fsamplingMethod = in.fsamplingMethod; + fIsHeavyIon = in.fIsHeavyIon; + fawayPhiGap = in.fawayPhiGap; + fmaxEtaRange = in.fmaxEtaRange; + fRSignalBin = in.fRSignalBin; + + // The pointers to card and histos are just copied. I think this is safe, since they are not created by + // AliJCorrelations and thus should not disappear if the AliJCorrelation managing them is destroyed. + fcard = in.fcard; + fhistos = in.fhistos; + + fDPhiUERegion[0] = in.fDPhiUERegion[0]; + fDPhiUERegion[1] = in.fDPhiUERegion[1]; + + for(int iRGap=0; iRGap < fcard->GetNoOfBins(kRGapType); iRGap++){ + fRGap[iRGap] = in.fRGap[iRGap]; + } + + frandom = new TRandom3(); // frandom generator for jt flow UE + frandom->SetSeed(0); + + return *this; + // copy constructor +} + + +void AliJCorrelations::FillHisto(corrFillType cFTyp, fillType fTyp, int cBin, int zBin, AliJBaseTrack *ftk1, AliJBaseTrack *ftk2){ + // histo filler + if( cFTyp == kAzimuthFill ) + FillAzimuthHistos( fTyp, cBin, zBin, ftk1, ftk2); + +} + +//============================================================================================= +void AliJCorrelations::FillAzimuthHistos(fillType fTyp, int CentBin, int ZBin, AliJBaseTrack *ftk1, AliJBaseTrack *ftk2) +//============================================================================================= +{ + // histo filler + bool twoTracks = false; + if(ftk1->GetParticleType()==kHadron && ftk2->GetParticleType()==kHadron) twoTracks =true; + + //double-counting check + if(fTyp == kReal && twoTracks && ftk1->GetID()==ftk2->GetID()) return; + + // Accept only unlike sign pairs + //if(ftk1->GetCharge() > 0 && ftk2->GetCharge() > 0) return; + //if(ftk1->GetCharge() < 0 && ftk2->GetCharge() < 0) return; + + //---------------------------------------------------------------- + fptt = ftk1->Pt(); + fpta = ftk2->Pt(); + + fTrackPairEfficiency = 1./( ftk1->GetTrackEff() * ftk2->GetTrackEff() ); + + fIsIsolatedTrigger = ftk1->GetIsIsolated()>0 ? true : false; //FK// trigger particle is isolated hadron + + //phit= ftk1->Phi(); //for RP + fpttBin = ftk1->GetTriggBin(); + fptaBin = ftk2->GetAssocBin(); + fPhiTrigger = ftk1->Phi(); + fPhiAssoc = ftk2->Phi(); + fDeltaPhi = DeltaPhi(fPhiTrigger, fPhiAssoc); //radians + fDeltaPhiPiPi = atan2(sin(fPhiTrigger-fPhiAssoc), cos(fPhiTrigger-fPhiAssoc)); + fDeltaEta = ftk1->Eta() - ftk2->Eta(); + //double dEtaFar = ftk1->Eta() + ftk2->Eta(); + + fNearSide = cos(fPhiTrigger-fPhiAssoc) > 0 ? true : false; + + fEtaGapBin = fcard->GetBin( kEtaGapType, fabs(fDeltaEta)); + fPhiGapBinNear = fcard->GetBin( kEtaGapType, fabs(fDeltaPhiPiPi) ); + fPhiGapBinAway = fcard->GetBin( kEtaGapType, fabs(fDeltaPhi-kJPi) ); //here the angle must be 0-2pi and not (-pi,pi) + fRGapBinNear = fcard->GetBin( kRGapType, fabs(ftk1->DeltaR(*ftk2))); + fRGapBinAway = fcard->GetBin( kRGapType, sqrt(pow(fDeltaPhi-kJPi,2)+fDeltaEta*fDeltaEta) ); + fCentralityBin = CentBin; + + TLorentzVector vTrigger = ftk1->GetLorentzVector(), vAssoc = ftk2->GetLorentzVector(); // Lorentz vectors for trigger and associated particles + fXlong = vTrigger.Vect().Dot(vAssoc.Vect())/pow(vTrigger.P(),2); + fXlongBin = fcard->GetBin(kXeType, TMath::Abs(fXlong)); + + //if( rGapBin != fRGapBinNear ) cout<<"dR vs fRGapBinNear = "<fhxEPtBin[0][fpttBin][fptaBin]->Fill(fXlong, fGeometricAcceptanceCorrection * fTrackPairEfficiency); + if( fNearSide ) { + fhistos->fhxEPtBin[1][fpttBin][fptaBin]->Fill(fXlong, fGeometricAcceptanceCorrection * fTrackPairEfficiency); + } else { + fhistos->fhxEPtBin[2][fpttBin][fptaBin]->Fill(fXlong, fGeometricAcceptanceCorrection * fTrackPairEfficiency); + } + } + + if(fNearSide) { + fhistos->fhxEN [fTyp][fpttBin]->Fill(-xe, fGeometricAcceptanceCorrection * fTrackPairEfficiency); + } else { + fhistos->fhxEF [fTyp][fpttBin]->Fill(xe, fGeometricAcceptanceCorrection * fTrackPairEfficiency); + if(fIsIsolatedTrigger) fhistos->fhxEFIsolTrigg[fTyp][fpttBin]->Fill(xe, fGeometricAcceptanceCorrection * fTrackPairEfficiency); + } +} + +void AliJCorrelations::FillJtHistograms(fillType fTyp, AliJBaseTrack *ftk1, AliJBaseTrack *ftk2, bool fill2DBackground) +{ + // This method fills the jT and pout histograms + + double pout = fabs(fpta*sin(fPhiTrigger-fPhiAssoc)); + + if(fNearSide) { + + TLorentzVector vTrigger = ftk1->GetLorentzVector(), vAssoc = ftk2->GetLorentzVector(); // Lorentz vectors for tracks + + double jt = vAssoc.Perp(vTrigger.Vect()); + double weight = jt > 1e-3 ? fGeometricAcceptanceCorrection * fTrackPairEfficiency/jt : 0; + + int iKlongBin = fcard->GetBin(kLongType, vTrigger.Vect().Dot(vAssoc.Vect())/vTrigger.P()); + if(iKlongBin>=0){ + fhistos->fhJTKlong[fTyp][fCentralityBin][fpttBin][iKlongBin]->Fill(jt, weight); + //cout <<" jt="<< jt <<" geo="<< fGeometricAcceptanceCorrection <<" eff="<< fTrackPairEfficiency <<" w="<< fGeometricAcceptanceCorrection * fTrackPairEfficiency/jt <=0){ + fhistos->fhJT[fTyp][fCentralityBin][fpttBin][fXlongBin]->Fill(jt, weight); + //cout <<" jt="<< jt <<" geo="<< fGeometricAcceptanceCorrection <<" eff="<< fTrackPairEfficiency <<" w="<< fGeometricAcceptanceCorrection * fTrackPairEfficiency/jt <=0){ + fhistos->fhJTPta[fTyp][fCentralityBin][fpttBin][fptaBin]->Fill(jt, weight); + //cout <<" jt="<< jt <<" geo="<< fGeometricAcceptanceCorrection <<" eff="<< fTrackPairEfficiency <<" w="<< fGeometricAcceptanceCorrection * fTrackPairEfficiency/jt <=0 || fRGapBinNear >=0 ) ){ + for(int iEtaGap=0; iEtaGap<=fEtaGapBin; iEtaGap++) fhistos->fhPtaEtaGapN[fCentralityBin][iEtaGap][fpttBin]->Fill(fpta, fTrackPairEfficiency); + for(int iRGap=0; iRGap<=fRGapBinNear; iRGap++) fhistos->fhPtaRGapN[fCentralityBin][iRGap][fpttBin]->Fill(fpta, fTrackPairEfficiency); + for(int itrial=0; itrial<20; itrial++){ //For each high eta gap track generate ten others + + if(fsamplingMethod == 0){ + etaTriggRndm = frandom->Uniform(-fmaxEtaRange, fmaxEtaRange); + etaAssocRndm = frandom->Uniform(-fmaxEtaRange, fmaxEtaRange); + } else { + etaTriggRndm = fhistos->fhIetaTriggFromFile[fCentralityBin][fpttBin]->GetRandom(); + etaAssocRndm = fhistos->fhIetaAssocFromFile[fCentralityBin][fptaBin]->GetRandom(); + } + if( fEtaGapBin >=0 || fRGapBinNear >=0 ) { + if( fsamplingMethod == 0) { + dphiAssocRndm = kJPi * frandom->Uniform(-0.5, 0.5); + } else { + dphiAssocRndm = fhistos->fhIphiAssocFromFile[fCentralityBin][fptaBin]->GetRandom(); + } + vAssocRndm.SetPtEtaPhiM(fpta, etaAssocRndm, fPhiTrigger + dphiAssocRndm, 0); //set randomized assoc TLorentz vector + } else { + vAssocRndm.SetPtEtaPhiM(fpta, etaAssocRndm, fPhiAssoc, 0); //set randomized assoc TLorentz vector + } + + vThrustRndm.SetPtEtaPhiM(vTrigger.Pt(),etaTriggRndm, fPhiTrigger, 0); + + double dEtaRndm = etaTriggRndm - etaAssocRndm; + double geoAccCorrRndm = (fsamplingMethod == 0 || fPhiGapBinNear<0 ) ? GetGeoAccCorrFlat(dEtaRndm) : GetGeoAccCorrIncl(dEtaRndm); + + jt = vAssocRndm.Perp(vThrustRndm.Vect()); + + // TODO : shadowing of iKlongBin + int jKlongBin = fcard->GetBin(kLongType, vThrustRndm.Vect().Dot(vAssocRndm.Vect())/vThrustRndm.P()); + if(jKlongBin>=0){ // + if(jt>1e-3) { //here we used and BgFidCut + for(int iEtaGap=0; iEtaGap<=fEtaGapBin; iEtaGap++){ + fhistos->fhJTKlongBg[fCentralityBin][iEtaGap][fpttBin][jKlongBin]->Fill(jt, geoAccCorrRndm * fTrackPairEfficiency/jt); + if(fill2DBackground) fhistos->fhDphiDetaKlong[fCentralityBin][iEtaGap][fpttBin][jKlongBin]->Fill(dEtaRndm, dphiAssocRndm, geoAccCorrRndm * fTrackPairEfficiency); + fhistos->fhBgAssocKlong[fCentralityBin][iEtaGap][fpttBin][jKlongBin]->Fill(fpta, fTrackPairEfficiency); + } + for(int iRGap=0; iRGap<=fRGapBinNear; iRGap++){ + fhistos->fhJTKlongBgR[fCentralityBin][iRGap][fpttBin][jKlongBin]->Fill(jt, geoAccCorrRndm * fTrackPairEfficiency/jt); + if(fill2DBackground) fhistos->fhDphiDetaKlongR[fCentralityBin][iRGap][fpttBin][jKlongBin]->Fill(dEtaRndm, dphiAssocRndm, geoAccCorrRndm * fTrackPairEfficiency); + fhistos->fhBgAssocKlongR[fCentralityBin][iRGap][fpttBin][jKlongBin]->Fill(fpta, fTrackPairEfficiency); + } + } + } + int iXeBin = fcard->GetBin(kXeType, vThrustRndm.Vect().Dot(vAssocRndm.Vect())/pow(vThrustRndm.P(),2) ); + if(iXeBin>=0){ + if(jt>1e-3) { //here we used and BgFidCut + for(int iEtaGap=0; iEtaGap<=fEtaGapBin; iEtaGap++){ + fhistos->fhJTBg[fCentralityBin][iEtaGap][fpttBin][iXeBin]->Fill(jt, geoAccCorrRndm * fTrackPairEfficiency/jt); + if(fill2DBackground) fhistos->fhDphiDetaXe[fCentralityBin][iEtaGap][fpttBin][iXeBin]->Fill(dEtaRndm, dphiAssocRndm, geoAccCorrRndm * fTrackPairEfficiency); + fhistos->fhBgAssocXe[fCentralityBin][iEtaGap][fpttBin][iXeBin]->Fill(fpta, fTrackPairEfficiency); + } + for(int iRGap=0; iRGap<=fRGapBinNear; iRGap++){ + fhistos->fhJTBgR[fCentralityBin][iRGap][fpttBin][iXeBin]->Fill(jt, geoAccCorrRndm * fTrackPairEfficiency/jt); + if(fill2DBackground) fhistos->fhDphiDetaXeR[fCentralityBin][iRGap][fpttBin][iXeBin]->Fill(dEtaRndm, dphiAssocRndm, geoAccCorrRndm * fTrackPairEfficiency); + fhistos->fhBgAssocXeR[fCentralityBin][iRGap][fpttBin][iXeBin]->Fill(fpta, fTrackPairEfficiency); + } + } + } + if(fptaBin>=0){ + if(jt>1e-3) { //here we used and BgFidCut + for(int iEtaGap=0; iEtaGap<=fEtaGapBin; iEtaGap++){ + fhistos->fhJTPtaBg[fCentralityBin][iEtaGap][fpttBin][fptaBin]->Fill(jt, geoAccCorrRndm * fTrackPairEfficiency/jt); + if(fill2DBackground) fhistos->fhDphiDetaPta[fCentralityBin][iEtaGap][fpttBin][fptaBin]->Fill(dEtaRndm, dphiAssocRndm, geoAccCorrRndm * fTrackPairEfficiency); + fhistos->fhBgAssocPta[fCentralityBin][iEtaGap][fpttBin][fptaBin]->Fill(fpta, fTrackPairEfficiency); + } + for(int iRGap=0; iRGap<=fRGapBinNear; iRGap++){ + fhistos->fhJTPtaBgR[fCentralityBin][iRGap][fpttBin][fptaBin]->Fill(jt, geoAccCorrRndm * fTrackPairEfficiency/jt); + if(fill2DBackground) fhistos->fhDphiDetaPtaR[fCentralityBin][iRGap][fpttBin][fptaBin]->Fill(dEtaRndm, dphiAssocRndm, geoAccCorrRndm * fTrackPairEfficiency); + fhistos->fhBgAssocPtaR[fCentralityBin][iRGap][fpttBin][fptaBin]->Fill(fpta, fTrackPairEfficiency); + } + } + } + } //trials + }// Eta Gap Random + + + } else { + fhistos->fhPoutF[fTyp][fCentralityBin][fpttBin][fptaBin]->Fill(pout, fGeometricAcceptanceCorrection * fTrackPairEfficiency); + } +} + +void AliJCorrelations::FillDeltaEtaHistograms(fillType fTyp, int ZBin) +{ + // This method fills the DeltaEta histograms + + if( fNearSide ){ //one could check the phiGapBin, but in the pi/2 <1.6 and thus phiGap is always>-1 + if( fTyp == 0 ) { + fhistos->fhDEtaNear[fCentralityBin][ZBin][fPhiGapBinNear][fpttBin][fptaBin]->Fill( fDeltaEta , fGeometricAcceptanceCorrection * fTrackPairEfficiency ); + if(fXlongBin>=0) fhistos->fhDEtaNearXEbin[fCentralityBin][ZBin][fPhiGapBinNear][fpttBin][fXlongBin]->Fill( fDeltaEta , fGeometricAcceptanceCorrection * fTrackPairEfficiency ); + } else { + fhistos->fhDEtaNearM[fCentralityBin][ZBin][fPhiGapBinNear][fpttBin][fptaBin]->Fill( fDeltaEta , fGeometricAcceptanceCorrection * fTrackPairEfficiency ); + if(fXlongBin>=0) fhistos->fhDEtaNearMXEbin[fCentralityBin][ZBin][fPhiGapBinNear][fpttBin][fXlongBin]->Fill( fDeltaEta , fGeometricAcceptanceCorrection * fTrackPairEfficiency ); + } + } else { + if(fPhiGapBinAway<=3) fhistos->fhDEtaFar[fTyp][fCentralityBin][fpttBin]->Fill( fDeltaEta, fGeometricAcceptanceCorrection * fTrackPairEfficiency ); + } +} + +void AliJCorrelations::FillDeltaPhiHistograms(fillType fTyp) +{ + // This method fills the DeltaPhi histograms + + // When hists are filled for thresholds they are not properly normalized and need to be subtracted + // This induced improper errors - subtraction of not-independent entries + + fhistos->fhDphiAssoc[fTyp][fCentralityBin][fEtaGapBin][fpttBin][fptaBin]->Fill( fDeltaPhi/kJPi , fGeometricAcceptanceCorrection * fTrackPairEfficiency); + if(fXlongBin>=0) fhistos->fhDphiAssocXEbin[fTyp][fCentralityBin][fEtaGapBin][fpttBin][fXlongBin]->Fill( fDeltaPhi/kJPi , fGeometricAcceptanceCorrection * fTrackPairEfficiency); + + if(fIsIsolatedTrigger) fhistos->fhDphiAssocIsolTrigg[fTyp][fCentralityBin][fpttBin][fptaBin]->Fill( fDeltaPhi/kJPi , fGeometricAcceptanceCorrection * fTrackPairEfficiency); //FK// +} + +void AliJCorrelations::FillPtaHistograms(fillType fTyp) +{ + // This method fills various pta histograms + + if ( fTyp == kReal ) { + //must be here, not in main, to avoid counting triggers + fhistos->fhAssocPtBin[fCentralityBin][fpttBin][fptaBin]->Fill(fpta ); //I think It should not be weighted by Eff + + //++++++++++++++++++++++++++++++++++++++++++++++++++ + // in order to get mean pTa in the jet peak one has + // to fill fhMeanPtAssoc in |DeltaEta|<0.4 + // +++++++++++++++++++++++++++++++++++++++++++++++++ + if(fEtaGapBin>=0 && fEtaGapBin<2){ + fhistos->fhMeanPtAssoc[fCentralityBin][fpttBin][fptaBin]->Fill( fDeltaPhi/kJPi , fpta ); + fhistos->fhMeanZtAssoc[fCentralityBin][fpttBin][fptaBin]->Fill( fDeltaPhi/kJPi , fpta/fptt); + } + + //UE distribution + if(fabs(fDeltaPhiPiPi/kJPi)>fDPhiUERegion[0] && fabs(fDeltaPhiPiPi/kJPi)fhPtAssocUE[fCentralityBin][iEtaGap][fpttBin]->Fill(fpta, fTrackPairEfficiency); + if(fIsIsolatedTrigger){ //FK// trigger is isolated hadron + fhistos->fhPtAssocUEIsolTrigg[fpttBin]->Fill(fpta, fTrackPairEfficiency); //FK// + } + } + if(fabs(fDeltaPhi/kJPi)<0.15) fhistos->fhPtAssocN[fpttBin]->Fill(fpta, fTrackPairEfficiency); + if(fabs(fDeltaPhi/kJPi-1)<0.15) fhistos->fhPtAssocF[fpttBin]->Fill(fpta, fTrackPairEfficiency); + + fnReal++; + } else { // only mix + fnMix++; + } +} + +void AliJCorrelations::FillIAAAndMoonHistograms(fillType fTyp, int ZBin) +{ + // This method fills the I_AA and moon histograms + + fhistos->fhDphiAssoc2DIAA[fTyp][fCentralityBin][ZBin][fpttBin][fptaBin]->Fill( fDeltaEta, fDeltaPhi/kJPi, fTrackPairEfficiency); + + if(fRGapBinNear>=0){ + if(fRGapBinNear <= fRSignalBin) fhistos->fhDRNearPt[fTyp][fCentralityBin][ZBin][fRGapBinNear][fpttBin]->Fill( fpta, fGeometricAcceptanceCorrection * fTrackPairEfficiency ); + // - moon - + if(fRGapBinNear>0){ + for( int irs = 0; irs <= fRSignalBin;irs++ ){ + if( fRGapBinNear < irs ) continue; + if( fPhiGapBinNear > irs ) continue; + for ( int ir1=0;ir1<= fRGapBinNear;ir1++ ){ + if( irs > ir1 ) continue; + if( ir1 > fRGapBinNear ) continue; + double rGapS= fRGap[irs+1]; + double rGap1= fRGap[ir1+1]; + if( rGap1 < TMath::Abs(fDeltaPhiPiPi) ) continue; + if( rGapS < TMath::Abs(fDeltaPhiPiPi) ) continue; + double dEtaMin = sqrt(rGap1*rGap1-fDeltaPhiPiPi*fDeltaPhiPiPi); + double dEtaMax = dEtaMin + sqrt(rGapS*rGapS-fDeltaPhiPiPi*fDeltaPhiPiPi); + double eta = TMath::Abs( fDeltaEta ); + if( eta > dEtaMin && eta < dEtaMax ){ + //if( eta > dEtaMin && eta < dEtaMax && fDeltaEta <0 ){ + // xxx + // fhistos->hDRNearPtMoon[fTyp][fCentralityBin][ZBin][ir1][irs][fpttBin]->Fill( fpta, fGeometricAcceptanceCorrection * fTrackPairEfficiency ); + + if( fTyp == 0 ) + fhistos->fhDRNearPtMoon[fCentralityBin][ZBin][ir1][irs][fpttBin]->Fill( fpta, fGeometricAcceptanceCorrection * fTrackPairEfficiency ); + else + fhistos->fhDRNearPtMoonM[fCentralityBin][ZBin][ir1][irs][fpttBin]->Fill( fpta, fGeometricAcceptanceCorrection * fTrackPairEfficiency ); + if(fTyp == kReal) fhistos->fhDphiAssoc2D[ir1][irs]->Fill( fDeltaEta, fDeltaPhi/kJPi, fGeometricAcceptanceCorrection * fTrackPairEfficiency ); + } + } + } + } + } + + if(fRGapBinAway>=0){ + if(fRGapBinAway <= fRSignalBin) fhistos->fhDRFarPt[fTyp][fCentralityBin][ZBin][fRGapBinAway][fpttBin]->Fill( fpta, fGeometricAcceptanceCorrection * fTrackPairEfficiency ); + // - moon - + if(fRGapBinAway>0){ + for( int irs = 0; irs <= fRSignalBin;irs++ ){ + if( fRGapBinAway < irs ) continue; + if( fPhiGapBinAway > irs ) continue; + for ( int ir1=0;ir1<= fRGapBinAway;ir1++ ){ + if( irs > ir1 ) continue; + if( ir1 > fRGapBinAway ) continue; + double rGapS= fRGap[irs+1]; + double rGap1= fRGap[ir1+1]; + if( rGap1 < TMath::Abs(fDeltaPhi-kJPi) ) continue; + if( rGapS < TMath::Abs(fDeltaPhi-kJPi) ) continue; + double dEtaMin = sqrt(rGap1*rGap1- (fDeltaPhi-kJPi)*(fDeltaPhi-kJPi) ); + double dEtaMax = dEtaMin + sqrt(rGapS*rGapS-(fDeltaPhi-kJPi)*(fDeltaPhi-kJPi) ); + double eta = TMath::Abs( fDeltaEta ); + if( eta > dEtaMin && eta < dEtaMax ){ + //if( eta > dEtaMin && eta < dEtaMax && fDeltaEta <0 ){ + // xxx + // fhistos->hDRFarPtMoon[fTyp][fCentralityBin][ZBin][ir1][irs][fpttBin]->Fill( fpta, fGeometricAcceptanceCorrection * fTrackPairEfficiency ); + if( fTyp == 0 ) + fhistos->fhDRFarPtMoon[fCentralityBin][ZBin][ir1][irs][fpttBin]->Fill( fpta, fGeometricAcceptanceCorrection * fTrackPairEfficiency ); + else + fhistos->fhDRFarPtMoonM[fCentralityBin][ZBin][ir1][irs][fpttBin]->Fill( fpta, fGeometricAcceptanceCorrection * fTrackPairEfficiency ); + + if(fTyp == kReal) fhistos->fhDphiAssoc2D[ir1][irs]->Fill( fDeltaEta, fDeltaPhi/kJPi, fGeometricAcceptanceCorrection * fTrackPairEfficiency ); + } + } + } + } + } +} + + +double AliJCorrelations::GetGeoAccCorrFlat(double deltaEta){ + //FK// calculate acceptance correction on pseudorapidity triangle + double absDEta = fabs(deltaEta); + + double denominator = 1 - absDEta/(2*fmaxEtaRange); + //double denominator = 1 - (absDEta - ftriggFiducCut)/(2*fmaxEtaRange-2*ftriggFiducCut);//When Fid>0 max_Deta je mensi nez 2*EtaMax + //double denominator = 1 - (absDEta - ftriggFiducCut)/(2*fmaxEtaRange-ftriggFiducCut); + if(denominator > 1e-6) + return 1.0/denominator; + else + return 0; +} + +double AliJCorrelations::GetGeoAccCorrIncl(double deltaEta){ + // histo filler + + if(fhistos->fhDEtaNearMixFromFile[fCentralityBin][fpttBin][fptaBin]->GetEntries()<1000) return GetGeoAccCorrFlat(deltaEta); + + int bin = fhistos->fhDEtaNearMixFromFile[fCentralityBin][fpttBin][fptaBin]->FindBin(deltaEta); + double denominator = fhistos->fhDEtaNearMixFromFile[fCentralityBin][fpttBin][fptaBin]->GetBinContent(bin); + if(denominator > 1e-6) + return 1.0/denominator; + else + return 0; + +} + +double AliJCorrelations::DeltaPhi(double phi1, double phi2) { + // dphi + double res = atan2(sin(phi1-phi2), cos(phi1-phi2)); + //double res = phi1 - phi2; + //return res>-kJPi/3.0 ? res : kJTwoPi+res ; + return res>-kJPi*9./20. ? res : kJTwoPi+res ; +} + + + + + + + + + + + + + + + + + + + + + diff --git a/PWGCF/Correlations/JCORRAN/AliJCorrelations.h b/PWGCF/Correlations/JCORRAN/AliJCorrelations.h new file mode 100644 index 00000000000..9c89e0e735d --- /dev/null +++ b/PWGCF/Correlations/JCORRAN/AliJCorrelations.h @@ -0,0 +1,135 @@ +/* Copyright(c) 1998-2014, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +// Short comment describing what this class does needed! + +//=========================================================== +// AliJCorrelations.h +// Created Thu Apr 17 12:40:29 EEST 2008 by classmaker +// Jan Rak +//=========================================================== + +#ifndef ALIJCORRELATIONS_H +#define ALIJCORRELATIONS_H + +#include +#include +#include +#include +#include //FK// + +#include + +using namespace std; + +class AliJCorrelations; +class AliJHistos; +class AliJBaseTrack; +class AliJCard; + +class AliJCorrelations { + +public: + + AliJCorrelations( AliJCard *cardIn, AliJHistos *histosIn); + + virtual ~AliJCorrelations(){;} //destructor + AliJCorrelations(); + AliJCorrelations(const AliJCorrelations& in); + AliJCorrelations& operator=(const AliJCorrelations& obj); + + void PrintOut(){cout<<"Real correl = "< +#include +#include +#include +#include +#include +#include + +#include "AliJConst.h" +#include "AliJBaseTrack.h" +#include "AliJTrack.h" +#include "AliJMCTrack.h" +#include "AliJPhoton.h" +#include "AliJEventHeader.h" +// TODO #include "AliESDVZERO.h" +#include "AliJHistos.h" + +#include "AliJCard.h" +#include "AliJEventPool.h" + +#include "AliJRunHeader.h" +#include "AliJCorrelations.h" +#include "AliJTrackCut.h" +#include + +//______________________________________________________________________________ +AliJDataManager::AliJDataManager(AliJCard *inCard, AliJHistos *histin, AliJCorrelations *corrin, Bool_t execLocal ): + fChain(NULL), + fCard(inCard), + fhistos(histin), + fcorrelations(corrin), + fRunHeader(NULL), + fEventHeader(NULL), + fEventHeaderList(NULL), + fTrackList(NULL), + fPhotonList(NULL), + fCellList(NULL), + fPhotonListRecalib(NULL), + fCellListRecalib(NULL), + fMCTrackList(NULL), + fVZEROData(NULL), + fRunInfoList(NULL), + fhadronSelectionCut(0), + fFilterMap(0), + fFName(), + fExecLocal(execLocal), + fTriggerMask(0), + fTrackCut(NULL) +{ + // constructor + fChain = new TChain("JODTree"); + fhadronSelectionCut = int(fCard->Get("HadronSelectionCut")); + + + fTriggerMask = fCard->Get("TriggerMask"); + + fTrackCut = new AliJTrackCut; +} + +//______________________________________________________________________________ +AliJDataManager::~AliJDataManager(){ + // destructor + if( fChain ) delete fChain; + if( fTrackCut) delete fTrackCut; +} + +//______________________________________________________________________________ +AliJDataManager::AliJDataManager() : + fChain(NULL), + fCard(NULL), + fhistos(NULL), + fcorrelations(NULL), + fRunHeader(NULL), + fEventHeader(NULL), + fEventHeaderList(NULL), + fTrackList(NULL), + fPhotonList(NULL), + fCellList(NULL), + fPhotonListRecalib(NULL), + fCellListRecalib(NULL), + fMCTrackList(NULL), + fVZEROData(NULL), + fRunInfoList(NULL), + fhadronSelectionCut(0), + fFilterMap(0), + fFName(), + fExecLocal(true), + fTriggerMask(0), + fTrackCut(NULL) +{ + // default constructor +} + +//______________________________________________________________________________ +AliJDataManager::AliJDataManager(const AliJDataManager& obj) : + fChain(obj.fChain), + fCard(obj.fCard), + fhistos(obj.fhistos), + fcorrelations(obj.fcorrelations), + fRunHeader(obj.fRunHeader), + fEventHeader(obj.fEventHeader), + fEventHeaderList(obj.fEventHeaderList), + fTrackList(obj.fTrackList), + fPhotonList(obj.fPhotonList), + fCellList(obj.fCellList), + fPhotonListRecalib(obj.fPhotonListRecalib), + fCellListRecalib(obj.fCellListRecalib), + fMCTrackList(obj.fMCTrackList), + fVZEROData(obj.fVZEROData), + fRunInfoList(obj.fRunInfoList), + fhadronSelectionCut(obj.fhadronSelectionCut), + fFilterMap(obj.fFilterMap), + fFName(obj.fFName), + fExecLocal(obj.fExecLocal), + fTriggerMask(obj.fTriggerMask), + fTrackCut(obj.fTrackCut) +{ + // copy constructor TODO: proper handling of pointer data members + JUNUSED(obj); +} + +//______________________________________________________________________________ +AliJDataManager& AliJDataManager::operator=(const AliJDataManager& obj){ + // equal sign TODO: contents + JUNUSED(obj); + return *this; +} + + +//______________________________________________________________________________ + +bool AliJDataManager::IsGoodEvent(){ + // event checker + if(fEventHeader==NULL) return false; + int nContributorVtx = fEventHeader->GetVtxMult(); + double zVert = fEventHeader->GetZVertex(); + UInt_t triggermaskJCorran = fEventHeader->GetTriggerMaskJCorran(); + //double ZVertErr = fEventHeader->GetZVertexErr(); + bool goodVertex = kFALSE; + bool triggerred = (IsSelectedTrigger((int) triggermaskJCorran)); // CUT1 + + bool aMB = triggermaskJCorran & ( 1<< kMinBiasTriggerBitJCorran ); + bool aCentral = triggermaskJCorran & ( 1<fhEvents->Fill( 10 ); + if( aCentral ) fhistos->fhEvents->Fill( 11 ); + if( aSemiCentral ) fhistos->fhEvents->Fill( 12 ); + if( aMB || aCentral ) fhistos->fhEvents->Fill( 13 ); + if( aMB || aCentral || aSemiCentral ) fhistos->fhEvents->Fill( 14 ); + + for( int i=0;i < 31 ;i++ ){ + if( fEventHeader->GetTriggerMaskAlice() & BIT(i) ) + fhistos->fhEventTrigger->Fill(i); + } + fhistos->fhEventTrigger->Fill(41); + + /* + if(!AliJRunTable::GetInstance().IsHeavyIon()){ //pp data + if(fRunHeader->GetRunNumber() >= 146686 && fRunHeader->GetRunNumber() <= 146860){ //p+p 2.76 + if(!(fEventHeader->GetTriggerMaskAlice() & (1<<13))) triggerred= kFALSE; //noSDD CINT1-B-NOPF-FASTNOTRD + // Check with BS again about woSDD + } + } + */ + // pPb run + /* + if(AliJRunTable::GetInstance().IsPA()){ //p+Pb + if( + //(fEventHeader->GetTriggerMaskAlice() & (1<<20)) ) // kINT7 MB + ////(fEventHeader->GetTriggerMaskJCorran() & (1<<3)) ) // Emc1Gamma + (fEventHeader->GetTriggerMaskJCorran() & (1<<4)) ) // kEMCEJE + triggerred= kTRUE; // + // Check with BS again about woSDD + } + */ + //6 CINT7-B-NOPF-ALLNOTRD + //7 CINT7-ACE-NOPF-ALLNOTRD + //8 CINT7-A-NOPF-ALLNOTRD + //9 CINT7-C-NOPF-ALLNOTRD + //17 CEMC7EG1-B-NOPF-ALLNOTRD + //18 CEMC7EG2-B-NOPF-ALLNOTRD + //19 CEMC7EJ1-B-NOPF-ALLNOTRD + //20 CEMC7EJ2-B-NOPF-ALLNOTRD + + //Emc1GammaTriggerBitJCorran + + if(triggerred){ + fhistos->fhEvents->Fill( 1 ); + if(nContributorVtx==0){ + fhistos->fhVertexZTriggVtx->Fill(nContributorVtx,0.); + }else{ + fhistos->fhEvents->Fill( 2 ); + //cout<fhZVertRaw->Fill(zVert); + //fhistos->fhZVertRawErr->Fill(ZVertErr); + fhistos->fhVertexZTriggVtx->Fill(nContributorVtx,zVert); + goodVertex = (bool) fCard->VertInZRange(zVert); + + if( goodVertex ) + fhistos->fhEvents->Fill( 3 ); + } + } + //Trigger to be selected from the JCorran trigger mask is specified in the fCard + //if(( IsSelectedTrigger((int) triggermaskJCorran ) + // || ( fCard->MbTrigger((int) triggermaskJCorran ) && fCard->MixMBForPi0Mass() )) + if( + triggerred + && goodVertex ){ //Cut2 + + fhistos->fhEvents->Fill( 4 ); + return true; + }else{ + return false; + } +} + +//______________________________________________________________________________ +void AliJDataManager::RegisterList(TClonesArray* listToFill, TClonesArray* listFromToFill, + int cBin, int zBin, particleType whatToFill){ + // corrType whatCorrType){ + + // this is here just to silence the bloody rule checker + JUNUSED( cBin ); + JUNUSED( zBin ); + JUNUSED(listFromToFill); + JUNUSED( listToFill ); + + int noIn=0, counter=0; + // Double_t pid[10]={0}; + // bool isAliPion = 0; + // bool isAliKaon = 0; + // bool isAliProton = 0; + + switch (whatToFill) { + + case kPhoton: + break; + case kPizero: + break; + case kHadron: + noIn = fTrackList->GetEntriesFast(); + counter = 0; + { + for(int ii=0;iiAt(ii); + //if(fhadronSelectionCut == kTrackCutJFG || fhadronSelectionCut == kTrackCutHBT) cgl->SetUseTPCTrack(); + + // checking bit convention + for(int iTrackSelection=0; iTrackSelection<32; iTrackSelection++) { + if( cgl->IsFiltered(iTrackSelection) ) fhistos->fhTrackSelection->Fill( iTrackSelection ); + } + for(int iTrackSelection=0; iTrackSelection<32; iTrackSelection++) { + if( cgl->TestBit(BIT(iTrackSelection)) ) fhistos->fhTrackSelection->Fill( iTrackSelection+50 ); + } + + if( 1 + //&& ( cgl->GetFilterMap() & GetFilterMap() ) + && fTrackCut->IsSelected( cgl, fhadronSelectionCut ) + && fTrackCut->SetMomentum( cgl, fhadronSelectionCut ) + && fCard->IsInEtaRange(cgl->Eta()) + ){ // + cgl->SetID(ii); + cgl->SetParticleType(kHadron); + new ((*listToFill)[counter++]) AliJTrack(*cgl); + } + } + } + break; + + case kProton: + noIn = fTrackList->GetEntriesFast(); + counter = 0; + for(int ii=0;iiAt(ii); + Double32_t prob = 0.9;//cgl->GetPID(AliJTrack::kProtonAliJ, AliJTrack::kTPCTOF); + //cout << AliJTrack::kProtonAli <<"\t"<< AliJTrack::kTPCTOF <<"\t"<< prob<< endl; + //Double32_t prob = cgl->GetPID(AliJTrack::AliJTrkPID(4), AliJTrack::AliJTrkPIDmethod(2)); + if( 1 + && fCard->IsInEtaRange(cgl->Eta()) + && ( cgl->GetFilterMap() & GetFilterMap() ) + && prob > 0.9 + ){ // All cuts applied in the Train production stage + cgl->SetID(ii); + cgl->SetParticleType(kHadron); + new ((*listToFill)[counter++]) AliJTrack(*cgl); + } + } + break; + + default : + cout<<"Unknown particle type in JDatamenager.cxx/fillList()"<Compress(); +} + + +//______________________________________________________________________________ +void AliJDataManager::ChainInputStream(const char* infileList){ + // chainer + + if( fExecLocal ){ + + // read root nano data files in a list + char inFile[200]; + ifstream infiles(infileList); + while ( infiles >> inFile){ + fChain->Add(inFile); + } + //fChain->Print(); + + if(fChain->GetEntriesFast()<=0){ + cout<<"Empty chain from "<GetEntries())<FindBranch("HeaderList") ) + fChain->SetBranchAddress("HeaderList", &fEventHeaderList); + if( fChain->FindBranch("TrackList") ) + fChain->SetBranchAddress("TrackList", &fTrackList); + if( fChain->FindBranch("PhotonList") ) + fChain->SetBranchAddress("PhotonList", &fPhotonList); + if( fChain->FindBranch("CaloCellList") ) + fChain->SetBranchAddress("CaloCellList", &fCellList); + if( fChain->FindBranch("MCTrackList") ) + fChain->SetBranchAddress("MCTrackList", &fMCTrackList); + + if( AliJRunTable::GetInstance().IsHeavyIon() && fChain->FindBranch("AliESDVZERO")) { // if fevent-plane sources were stored + fChain->SetBranchAddress("AliESDVZERO", &fVZEROData); + // TODO for FMD, TZERO + } + + // fChain->SetBranchAddress("AliJMCTrackList", &fMCTrackList); + // Event Header + //Read Run Header + TFile* firstfile = fChain->GetFile(); + cout<<"============================================DEBUG 10 "<Get("RunInfo"); + fUserInfo->Print(); + fRunHeader=(AliJRunHeader*) fUserInfo->First(); + } + else{ + fRunHeader=(AliJRunHeader*) fRunInfoList->First(); + } + + if(fRunHeader){ + fRunHeader->PrintOut(); + } + +} + + +//______________________________________________________________________________ +Double_t AliJDataManager::LoadEvent(int ievt){ + //clear clones array and counters + //load the new fevent + + int v; + + v = 0; + + if( fExecLocal ){ + //fChain->GetEntry(ievt); + TString fp; + + //if( fExperiment == kMC ){ + // return fMCJDmg->GenerateEvent(); + //} else { + v = ((TTree*)fChain)->GetEntry(ievt); + + fp = fChain->GetCurrentFile()->GetPath(); + if( fp != fFName ){ + cout << fp.Data() << endl; + fFName = fp; + } + + } + + fEventHeader = dynamic_cast(fEventHeaderList->At(0)); + + return v; + //} +} + + + + + + + + + + + + + + + + + + + + + diff --git a/PWGCF/Correlations/JCORRAN/AliJDataManager.h b/PWGCF/Correlations/JCORRAN/AliJDataManager.h new file mode 100644 index 00000000000..92ced9aa242 --- /dev/null +++ b/PWGCF/Correlations/JCORRAN/AliJDataManager.h @@ -0,0 +1,155 @@ +// $Id: AliJDataManager.h,v 1.8 2008/02/12 15:51:27 djkim Exp $ +//////////////////////////////////////////////////// +/*! + \file AliJDataManager.h + \brief + \author J. Rak, D.J.Kim, B.S Chang (University of Jyvaskyla) + \email: djkim@cc.jyu.fi + \version $Revision: 1.8 $ + \date $Date: 2008/02/12 15:51:27 $ + */ +//////////////////////////////////////////////////// + +#ifndef ALIJDATAMANAGER_H +#define ALIJDATAMANAGER_H + +#include +#include +#include +#include + +#include + +#include "AliJConst.h" +#include "AliJEventHeader.h" +#include "AliJRunHeader.h" + +class TClonesArray; +class TList; +class AliJHistos; +class AliJCard; +class AliJCorrelations; +class AliJDataManager; +class AliJRunHeader; +class AliJTrackCut; +//class AliESDVZERO;TODO + + + +class AliJDataManager { + +public: + enum { kTrackCutDefault=0, kTrackCutJFG=1, kTrackCutHBT=2, kTrackCutRaa=3, kTrackCutHybrid=4, kTrackCutpp=5 }; + AliJDataManager(AliJCard *inCard, AliJHistos *fhistos, AliJCorrelations *corrin, Bool_t execLocal); + + virtual ~AliJDataManager(); //destructor + AliJDataManager(); + AliJDataManager(const AliJDataManager& obj); + AliJDataManager& operator=(const AliJDataManager& obj); + + void ChainInputStream(const char* infileList); + Double_t LoadEvent( int ievt ); + virtual void RegisterList(TClonesArray* listToFill, TClonesArray* listFromToFill, int cBin, int zBin, + particleType whatToFill); + // corrType whatCorrType); + + virtual bool IsGoodEvent(); + void SetRunHeader(AliJRunHeader *runHeader){ + std::cout<<"DEBUG ########### "<GetRunNumber()<GetEntries(); } + AliJRunHeader *GetRunHeader(){ return fRunHeader; }; + AliJEventHeader * GetEventHeader(){ return fEventHeader; }; + TClonesArray *GetEventHeaderList(){ return fEventHeaderList; }; + TClonesArray *GetTrackList(){ return fTrackList; }; + TClonesArray *GetPhotonList(){ return fPhotonList; }; + TClonesArray *GetCellList(){ return fCellList; }; + TClonesArray *GetPhotonListRecalib(){ return fPhotonListRecalib; }; + TClonesArray *GetCellListRecalib(){ return fCellListRecalib; }; + TClonesArray *GetMCTrackList(){ return fMCTrackList; }; + //AliESDVZERO *GetVZERO(){ return fVZEROData; } + TObject *GetVZERO(){ return fVZEROData; } + + void SetExecLocal( const Bool_t b ) { fExecLocal = b; } + + void SetTrackList( TClonesArray *a ) { fTrackList = a; } + void SetPhotonList( TClonesArray *a ) { fPhotonList = a; } + void SetCaloCellList( TClonesArray *a ) { fCellList = a; } + void SetMCTrackList( TClonesArray *a ) { fMCTrackList = a; } + void SetHeaderList( TClonesArray *a ) { fEventHeaderList = a; } + void SetRunInfoList( TList *a ) { fRunInfoList = a; } + void SetESDVZERO( TObject *a ) { fVZEROData = a; } + // void SetESDTZERO( AliESDTZERO *a ) { AliESDTZERO = a; } + // void SetESDZDC( AliESDZDC *a ) { AliESDZDC = a; } + + UInt_t GetFilterMap() const { return fFilterMap; } + void SetFilterMap( UInt_t fm ){ fFilterMap = fm; } + void AcceptTrackBit( UInt_t bit ){ SETBIT(fFilterMap, bit); } + Bool_t TestTrackBit( int i ){ return TESTBIT( GetFilterMap(), i );} + + Bool_t IsSelectedTrigger(unsigned int triggin ) const { return (triggin & fTriggerMask) >0;} + + protected: + TChain * fChain; // comment me + AliJCard * fCard; // comment me + AliJHistos *fhistos; // comment me + AliJCorrelations* fcorrelations; // comment me + + // Alice specific + AliJRunHeader *fRunHeader; // comment me + AliJEventHeader * fEventHeader; // comment me + TClonesArray *fEventHeaderList; // comment me + TClonesArray *fTrackList; // comment me + TClonesArray *fPhotonList; // comment me + TClonesArray *fCellList; // comment me + TClonesArray *fPhotonListRecalib; // comment me + TClonesArray *fCellListRecalib; // comment me + TClonesArray *fMCTrackList; // comment me + TObject *fVZEROData; // comment me + TList *fRunInfoList; // comment me + + int fhadronSelectionCut; // comment me + + UInt_t fFilterMap; // comment me + + TString fFName; // comment me + Bool_t fExecLocal; // comment me + + int fTriggerMask; // Trigger mask; + + + AliJTrackCut * fTrackCut; // Trigg selection class + + + +}; + +#endif + + + + + + + + + + + + + + + + + + + + + + diff --git a/PWGCF/Correlations/JCORRAN/AliJDiHadronCorrTask.cxx b/PWGCF/Correlations/JCORRAN/AliJDiHadronCorrTask.cxx new file mode 100644 index 00000000000..ef031fde90f --- /dev/null +++ b/PWGCF/Correlations/JCORRAN/AliJDiHadronCorrTask.cxx @@ -0,0 +1,177 @@ +/************************************************************************** + * Copyright(c) 1998-1999, 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. * + **************************************************************************/ + +//______________________________________________________________________________ +// Analysis task for high pt particle correlations +// author: R.Diaz, J. Rak, D.J. Kim +// ALICE Group University of Jyvaskyla +// Finland +// Fill the analysis containers for ESD or AOD +// Adapted for AliAnalysisTaskSE and AOD objects +////////////////////////////////////////////////////////////////////////////// + +#include "AliAnalysisTaskSE.h" +#include "AliAODHandler.h" +#include "AliAnalysisManager.h" +#include "AliLog.h" + +#include "AliJDiHadronCorrTask.h" +#include "AliJEventHeader.h" +#include "AliJRunHeader.h" +#include "AliJCORRANTask.h" +#include "AliJCard.h" + +//______________________________________________________________________________ +AliJDiHadronCorrTask::AliJDiHadronCorrTask() : + AliAnalysisTaskSE("AliJDiHadronCorrTaskTask"), + fFilterTask(NULL), + fFilterTaskName(""), + fJCORRAN(0x0), + fOutput(NULL) +{ + DefineOutput (1, TDirectory::Class()); +} + +//______________________________________________________________________________ +AliJDiHadronCorrTask::AliJDiHadronCorrTask(const char *name, TString inputformat): + AliAnalysisTaskSE(name), + fFilterTask(NULL), + fFilterTaskName(""), + fJCORRAN(0x0), + fOutput(NULL) +{ + // Constructor + AliInfo("---- AliJDiHadronCorrTask Constructor ----"); + + JUNUSED(inputformat); + DefineOutput (1, TDirectory::Class()); +} + +//____________________________________________________________________________ +AliJDiHadronCorrTask::AliJDiHadronCorrTask(const AliJDiHadronCorrTask& ap) : + AliAnalysisTaskSE(ap.GetName()), + fFilterTask(ap.fFilterTask), + fFilterTaskName(ap.fFilterTaskName), + fJCORRAN( ap.fJCORRAN ), + fOutput( ap.fOutput ) +{ + + AliInfo("----DEBUG AliJDiHadronCorrTask COPY ----"); + +} + +//_____________________________________________________________________________ +AliJDiHadronCorrTask& AliJDiHadronCorrTask::operator = (const AliJDiHadronCorrTask& ap) +{ + // assignment operator + + AliInfo("----DEBUG AliJDiHadronCorrTask operator= ----"); + this->~AliJDiHadronCorrTask(); + new(this) AliJDiHadronCorrTask(ap); + return *this; +} + +//______________________________________________________________________________ +AliJDiHadronCorrTask::~AliJDiHadronCorrTask() +{ + // destructor + + delete fJCORRAN; + +} + +//________________________________________________________________________ + +void AliJDiHadronCorrTask::UserCreateOutputObjects() +{ + //=== create the jcorran outputs objects + if(fDebug > 1) printf("AliJDiHadronCorrTask::UserCreateOutPutData() \n"); + + //=== Get AnalysisManager + AliAnalysisManager *man = AliAnalysisManager::GetAnalysisManager(); + if(!man->GetOutputEventHandler()) { + Fatal("UserCreateOutputObjects", "This task needs an AOD handler"); + return; + } + + fFilterTask = (AliJCORRANTask*)(man->GetTask( fFilterTaskName )); + + OpenFile(1); + fOutput = gDirectory;//->mkdir("JDiHadronCorr"); + fOutput->cd(); + + // Order should be kept + // TODO : better implementation + //bool orignalTH1AdddirectoryStatus=TH1::AddDirectoryStatus(); + // TODO Why? + //TH1::AddDirectory(kTRUE); + //if( !orignalTH1AdddirectoryStatus ) cout<<"DEBUG :: TH1::AddDirectory is turned on"<SetRunHeader( fFilterTask->GetJRunHeader() );//TODO + fJCORRAN->UserCreateOutputObjects(); + fJCORRAN->SetHeaderList(fFilterTask->GetFilter()->GetHeaderList() ); + fJCORRAN->SetTrackList( fFilterTask->GetFilter()->GetTrackList() ); + fJCORRAN->SetMCTrackList( fFilterTask->GetFilter()->GetMCTrackList() ); + fJCORRAN->GetCard()->WriteCard(fOutput); + + PostData( 1, fOutput ); + //TH1::AddDirectory( orignalTH1AdddirectoryStatus ); + //cout<<"DEBYG :: TH1::AddDirectory get orignal Value = "<<( orignalTH1AdddirectoryStatus?"True":"False" )< 5) cout << "------- AliJDiHadronCorrTask Exec-------"<GetFilter()->GetEventSuccess() = " << fFilterTask->GetFilter()->GetEventSuccess() << endl; + if( fFilterTask->GetFilter()->GetEventSuccess() ){ + fJCORRAN->UserExec(); + PostData(1, fOutput ); + } + + + if(fDebug > 5) cout << "\t------- End UserExec "<Init(); +} + +//______________________________________________________________________________ +void AliJDiHadronCorrTask::Terminate(Option_t *) +{ + + fJCORRAN->Terminate(); + OpenFile(1); + fOutput->cd(); + + cout<<"# Write Data "<Write(0,TObject::kOverwrite); + PostData(1,fOutput); + cout<<"AliJDiHadronCorrTask Analysis DONE !!"< +#include + +// AliJEfficiency +// ... +// ... +// ... +// ... +// TODO + +using namespace std; + +AliJEfficiency::AliJEfficiency(): + fMode(kAuto), + fPeriod(-1), + fTrackCut(), + fRunTable(), + fDataPath("$ALICE_ROOT/PWGCF/Correlations/macros/jcorran"), + fName(""), + fPeriodStr(""), + fMCPeriodStr(""), + fRunNumber(0), + fTag(""), + fInputRootName(""), + fInputRoot(NULL), + fCentBin(0x0) +{ + +} + +AliJEfficiency::AliJEfficiency(const AliJEfficiency& obj) : + fMode(obj.fMode), + fPeriod(obj.fPeriod), + fTrackCut(obj.fTrackCut), + fRunTable(obj.fRunTable), + fDataPath(obj.fDataPath), + fName(obj.fName), + fPeriodStr(obj.fPeriodStr), + fMCPeriodStr(obj.fMCPeriodStr), + fRunNumber(obj.fRunNumber), + fTag(obj.fTag), + fInputRootName(obj.fInputRootName), + fInputRoot(obj.fInputRoot), + fCentBin(obj.fCentBin) +{ + // copy constructor TODO: handling of pointer members + JUNUSED(obj); +} + +AliJEfficiency& AliJEfficiency::operator=(const AliJEfficiency& obj){ + // equal sign operator TODO: content + JUNUSED(obj); + return *this; +} + +TString AliJEfficiency::GetEffName() { + /* + 1. kNotUse : no Load, efficiency is 1 always + 2. has fInputRootName : Load that or crash + 3. has fName : Load fName [+runnumber] or crash + 4. has runnumber : Find Good MC period from AliJRunTable, or crash + 3. has period : Find Good MC period from AliJRunTable, or crash + +*/ + if( fMode == kNotUse ) { + cout<<"J_WARNING : Eff Mode is \"NOTUSE\". eff is 1 !!!"< 0 && fPeriod < 0 ) { + fPeriod = fRunTable.GetRunNumberToPeriod( fRunNumber ); + } + fPeriodStr = fRunTable.GetPeriodName( fPeriod ); + } + //==== Select McPeriod + //==== 1. Use fMCPeriodStr + //==== 2. Use fPeriod + if( fMCPeriodStr.Length() == 0 ){ + fMCPeriodStr = fRunTable.GetMCPeriod( fPeriod ); + } + //==== Select fRunNumber + //==== MODE 1 : runnumber = 0; + if( fMode == kPeriod ) fRunNumber = 0; + else if( fRunNumber < 0 ){ + cout<< "J_ERROR : Runumber must be >=0. Input runnumber is "<Exit(1); + } + + fInputRootName = Form("Eff-%s-%s-%s-%d-%s.root", fName.Data(), fPeriodStr.Data(), fMCPeriodStr.Data(), int(fRunNumber), fTag.Data() ); + } + + return fInputRootName; +} + +TString AliJEfficiency::GetEffFullName() { + GetEffName(); + fInputRootName = fDataPath + "/" + fInputRootName; + return fInputRootName; +} + + +bool AliJEfficiency::Load(){ + // Load Efficiency File based on fMode + if( fMode == kNotUse ) { + cout<<"J_WARNING : Eff Mode is \"NOTUSE\". eff is 1 !!!"<Exit(1); + } + + //fEffDir[0] = (TDirectory*)fInputRoot->Get("EffRE"); + ///fEffDir[1] = (TDirectory*)fInputRoot->Get("EffMC"); + fEffDir[2] = (TDirectory*)fInputRoot->Get("Efficiency"); + //iif( fEffDir[0] && fEffDir[1] && fEffDir[2] ) + if( !fEffDir[2] ) + { + cout<< "J_ERROR : Directory EFF is not exist"<Exit(1); + } + + fCentBin = (TAxis*)fEffDir[2]->Get("CentralityBin"); + if( !fCentBin ){ + cout<< "J_ERROR : No CentralityBin in directory"<Exit(1); + } + + + int nVtx = 1; + int nCentBin = fCentBin->GetNbins(); + for( int ivtx=0;ivtxGet(Form("gCor%02d%02d%02d", ivtx,icent,icut)); + //cout<<"J_LOG : Eff graph - "<GetXbins()->At(i)<<" "; + } + cout<FindBin( cent ) -1 ; + if( icent < 0 || icent > fCentBin->GetNbins()-1 ) { + cout<<"J_WARNING : Centrality "< 30 ) pt = 30; // Getting eff of 30GeV for lager pt + double cor = gr->Eval(pt); + if ( cor < 0.2 ) cor = 0.2; + return cor; +} + +void AliJEfficiency::Write(){ + // Write Efficiency information to root file + if( fMode == kNotUse ){ + cout<<"J_LOG : Efficiency mode is \"NotUse\", nothing will be Written" <GetName()<mkdir("Efficiency"); + eff->cd(); + int nVtx = 1; + int nCentBin = fCentBin->GetNbins(); + cout<Write(Form("gCor%02d%02d%02d", ivtx,icent,icut)); + } + } + } + fCentBin->Write("CentralityBin"); + cwd->cd(); +} + diff --git a/PWGCF/Correlations/JCORRAN/AliJEfficiency.h b/PWGCF/Correlations/JCORRAN/AliJEfficiency.h new file mode 100644 index 00000000000..dcb1e261bd2 --- /dev/null +++ b/PWGCF/Correlations/JCORRAN/AliJEfficiency.h @@ -0,0 +1,65 @@ +#ifndef ALIJEFFICIENCY_H +#define ALIJEFFICIENCY_H +// Class to Load and Get efficiency inforamtion +// .. +// TODO + +#include +#include +#include "AliJTrackCut.h" +#include "AliJRunTable.h" +#include "AliJConst.h" +#include +#include +#include +using namespace std; + +class AliJEfficiency{ + public: + enum Mode { kNotUse, kPeriod, kRunNumber, kAuto }; + enum Type { kRE, kMC, kMerge }; + AliJEfficiency(); + AliJEfficiency(const AliJEfficiency& obj); + AliJEfficiency& operator=(const AliJEfficiency& obj); + + void SetMode( int i ){ fMode = i; } + + void SetDataPath(TString s ){ fDataPath=s; } + void SetEffFile(TString s ){ fInputRootName=s; } + void SetName(TString s ){ fName=s; } + void SetPeriod(int period){ fPeriod = period; } + void SetPeriod(TString s){ fPeriodStr = s; } + void SetMCPeriod(TString s){ fMCPeriodStr = s; } + void SetRunNumber( Long64_t runnum ){ fRunNumber=runnum; } + void SetTag(TString s){ fTag=s; } + + TString GetName() const { return fName; } + double GetCorrection( double pt, int icut, double cent ) const ; + TString GetEffName() ; + TString GetEffFullName() ; + bool Load(); + void PrintOut() const { + cout< +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include + +#include +#include +#include + +#include "AliJEfficiencyScanner.h" +#include "AliJTrack.h" +#include "AliJMCTrack.h" +#include "AliJPhoton.h" +#include "AliJEventHeader.h" +#include "AliJRunHeader.h" +#include +#include + + +ClassImp(AliJEfficiencyScanner); + +//______________________________________________________________________________ +AliJEfficiencyScanner::AliJEfficiencyScanner() : + TNamed(), + fTrackList(0), + fMCTrackList(0x0), + fEventHeader(0x0), + fRunHeader(0x0), + fhVertexZMC(0x0), + fhVertexZTrigg(0x0), + fhVertexZTriggVtx(0x0), + fhVZRawMC(0x0), + fhVZRecMC(0x0), + fhVZRecAccMC(0x0), + fh2VtxCent(0x0), + fhL0Input(0x0), + fhTriggerAlice(0x0), + fhZVtxMCAll(0x0), + fhZVtxMCTrigg(0x0), + fhZVtxMCTriggVtx(0x0), + fhZVtxRecAll(0x0), + fhZVtxRecTrigg(0x0), + fhZVtxRecTriggVtx(0x0), + fVtxReFunc(0x0), + fVtxMCFunc(0x0), + fVtxRatioFunc(0x0), + fVtxRatioMax(1) +{ + //Default constructor + for( int ivtx=0;ivtx~AliJEfficiencyScanner(); + new(this) AliJEfficiencyScanner(ap); + return *this; +} + +//______________________________________________________________________________ +AliJEfficiencyScanner::~AliJEfficiencyScanner() +{ + // destructor +} + +//________________________________________________________________________ + +void AliJEfficiencyScanner::UserCreateOutputObjects() +{ + //=== create the jcorran outputs objects + cout<<"DEBUG Start AliJEfficiencyScanner::UserCreateOutputObjects() "<<"\t"< 50 ) break; + if( pt < 3 ) pt+= 0.05; + else if( pt < 5 ) pt+= 0.1; + else if( pt < 10 ) pt+= 1; + else pt+= 1; + } + cout<<"n Ptbin = "<SetDirectory(gDirectory); + + int nVtxBin = kNVtxBin; + int nCentBin = kNCentBin; + if( fRunHeader->IsPP() ) nCentBin = 1; + + TString name =""; + for( int ivtx=0;ivtxSetParameters(1 , -7.14076e-01, 6.27110 ); + fVtxMCFunc = new TF1("VtxMCFunc", "gaus",v0,v1); + fVtxMCFunc->SetParameters(1, -4.53674e-01, 5.27088e+00 ); + fVtxRatioFunc = new TF1("VtxRatioFunc", "VtxReFunc/VtxMCFunc",v0,v1); + fVtxRatioMax = fVtxRatioFunc->GetMaximum(); + + + + cout << "Add(fAliJRunHeader) in UserCreateObject() ======= " << endl; + cout<<"DEBUG END AliJEfficiencyScanner::UserCreateOutputObjects() "<GetTriggerMaskJCorran() & 8; // 1:kMB 8:kINT7 //TODO + UInt_t trigAlice = eventHeader->GetTriggerMaskAlice(); +/* +cout<<"Trigger"<GetTriggerMaskJCorran()&(1<GetTriggerMaskAlice()&(1<GetL0TriggerInputs(); + /* + bool isL0V0A = l0Input & (1UL<<9); + bool isL0V0C = l0Input & (1UL<<10); + bool isL0V0AND = l0Input & (1UL<<4); + bool isL0V0OR = l0Input & (1UL<<1); + bool isL0V0BeamGas = l0Input & (1UL<<2); + bool isL0SMB = l0Input & (1UL<<3); + bool isL0T0X = l0Input & (1UL<<0); + */ + + + + for( UInt_t i=0;i<32;i++ ){ + if( l0Input & 1UL<Fill(i); + if( trigAlice & 1UL<Fill(i); +/* + if( isL0V0A != isV0A ) cout<<"J_WARN 0 : L0:V0A != Class:V0A "<GetCentrality(); + int iCent = int( centrality/(100./nCentBin)); + if( iCent< 0 || iCent>20 ) return; + //if( centrality < 0 || centrality > 100 ) return; + if( fRunHeader->IsPP() ) iCent = 0; + + //== Vertex + //==== Reco + int ncontributors = eventHeader->GetVtxMult(); + double zVtxRec = eventHeader->GetZVertex(); + Bool_t goodRecVertex = (ncontributors>0) && (fabs(zVtxRec)<=zVtxCut); + int iVtx = 0; + //==== MC + double zVtxMC = eventHeader->GetZVertexMC(); + //==== vtx sampling + /* + if( zVtxMC > fVtxRatioFunc->GetXmin() && zVtxMC < fVtxRatioFunc->GetXmax() ){ + double vtxRatio = fVtxRatioFunc->Eval(zVtxMC)/fVtxRatioMax; + double random = gRandom->Uniform(0,1); + if( random > vtxRatio ) return; + } + */ + + fhVZRawMC->Fill(zVtxMC); + fhVertexZMC->Fill(ncontributors,zVtxMC); + // for crosscheck MC input events + fhZVtxMCAll->Fill(zVtxMC); + fhZVtxRecAll->Fill(zVtxRec); + + if(triggeredEventMB){ + fhVertexZTrigg->Fill(ncontributors,zVtxMC); + // for crosscheck passing trigger condition + fhZVtxMCTrigg->Fill(zVtxMC); + fhZVtxRecTrigg->Fill(zVtxRec); + + if(ncontributors>0){//reconstructed vertex + fhVZRecMC->Fill(zVtxRec); + // for crosscheck passing trigger condition + reconstruted vtx + fhZVtxMCTriggVtx->Fill(zVtxMC); + fhZVtxRecTriggVtx->Fill(zVtxRec); + } + if(goodRecVertex){ + fhVertexZTriggVtx->Fill(ncontributors,zVtxMC); + fhVZRecAccMC->Fill(zVtxRec); + } + } + + fh2VtxCent->Fill( zVtxRec, centrality ); + + // TODO ? MC or REC? + + int nRawMultPri = 0; + int nGenMultPri[AliJTrackCut::kJNTrackCuts] = {0}; + int nGenMultAll[AliJTrackCut::kJNTrackCuts] = {0}; + + //============================================== + // LOOP over MC + //============================================== + + //if( fabs(zVtxMC) > zVtxCut ) return; + int nMCTrks = 0; + if( fRunHeader->IsMC() ) + nMCTrks = GetJMCTracks()->GetEntriesFast(); + for( int it=0; it< nMCTrks; it++ ){ + AliJMCTrack * track = GetJMCTrack( it );//Always IsPhysicalPrimary + if( !track ) continue; + if( !track->IsTrue( AliJMCTrack::kPrimary ) ) continue; + // TODO need? if( ! track->IsFinal() ) continue; + double eta = track->Eta(); + double pt = track->Pt(); + if( fabs(eta) > etaCut ) continue; + if( ! track->IsCharged() ) continue; + + + nRawMultPri++; + fhChargedPtMC[iVtx][iCent]->Fill(pt); //ALL charged physical primaries + if(triggeredEventMB){//triggered + fhChargedPtMCTrigg[iVtx][iCent]->Fill(pt); + fh2DChargedPtTrigg[iVtx][iCent]->Fill(pt, eta); + if(goodRecVertex){ //triggered+vertex + fhChargedPtMCTriggVtx[iVtx][iCent]->Fill(pt); + fh2DChargedPtTriggVtx[iVtx][iCent]->Fill(pt, eta); + } + } + } + + //-------------------------------------------------------------- + //---- Reconstracted TRACKS + //-------------------------------------------------------------- + const int nTrkCut = AliJTrackCut::kJNTrackCuts; + if( ! triggeredEventMB ) return; + if( ! goodRecVertex ) return; + int nTrks = GetJTracks()->GetEntriesFast(); + for(Int_t it = 0; it < nTrks; it++) { + AliJTrack * track = GetJTrack(it); + if( !track ) continue; + bool isTriggered = track->GetFilterMap(); + if( !isTriggered ) continue; + + + //== init Vars of Track + double eta = track->Eta(); + double etaTPC = eta; + double etaGCG = eta; + double ptRec = track->Pt(); + double ptTPC = track->PtTPC(); + if( fabs(ptTPC) < 1e-2 ) ptTPC=ptRec; + else{ + TVector3 v(track->GetTPCTrack()); + etaTPC = v.Eta(); + } + double ptGCG = track->PtGCG(); + if( fabs(ptGCG) < 1e-2 ) ptGCG=ptRec; + else{ + TVector3 v(track->GetGCGTrack()); + etaGCG = v.Eta(); + } + double ptMC = -1; + int iPrimary = kJFake; + + //== Skip tracks with out of Eta + if( fabs(eta) > etaCut && fabs(etaTPC)>etaCut && fabs(etaGCG)>etaCut) continue; + + //== Find MC Info + for( int imc=0;imcIsTrue( AliJMCTrack::kPrimary ) ) continue; + if( mcTrack && (TMath::Abs(track->GetLabel()) == TMath::Abs(mcTrack->GetLabel())) ){ + iPrimary = kJPhysicsPrimary; + ptMC = mcTrack->Pt(); + break; + } + } + + + //== FILL HIST + for( int icut=0;icutFill(ptRec, eta); + fh2DChargedPtRec[iVtx][iCent][icut]->Fill(ptMC, eta); + fhChargedPtMCRecoCentVtx[iVtx][iCent][icut][iPrimary][kJGlobal]->Fill( ptRec ); + if( iPrimary == kJPhysicsPrimary ) nGenMultPri[icut]++; + nGenMultAll[icut]++; + //fhDCA2VertexXY[iVtx][iCent][icut]->Fill( track->GetDCAtoVertexXY() ); + //fhDCA2VertexZ[iVtx][iCent][icut]->Fill( track->GetDCAtoVertexZ() ); + } + if( fabs(etaTPC) < etaCut ) + fhChargedPtMCRecoCentVtx[iVtx][iCent][icut][iPrimary][kJTPCOnly]->Fill( ptTPC ); + if( fabs(etaGCG) < etaCut ) + fhChargedPtMCRecoCentVtx[iVtx][iCent][icut][iPrimary][kJGCG]->Fill( ptGCG ); + if( (icut==0 && fabs(etaTPC) < etaCut) || (icut!=0&&fabs(eta)Fill( ptMC ); + } + } + } + + for( int icut=0;icutFill( nRawMultPri, nGenMultPri[icut] ); + fh2MultGenRawAll[icut]->Fill( nRawMultPri, nGenMultAll[icut] ); + } + //cout<<"DEBUG END AliJEfficiencyScanner::UserExec"< +#include "AliJRunHeader.h" +#include +#include + +#include +#include +#include "AliJMCTrack.h" +#include "AliJTrack.h" +#include +#include +#include + +//============================================================== + +#ifndef AliJMaxDimBuffer +#define AliJMaxDimBuffer +const int kMaxDimBuffer = 300;//max length of a line read to a buffe +#endif + +class AliJEventHeader; +class AliJRunHeader; +class AliJTrack; +class AliAnalysisTaskSE; + +class TH1D; +class TH2D; + +class AliJEfficiencyScanner : public TNamed { + + public: + enum { kJPhysicsPrimary, kJFake, kNPrimaryStatus }; + enum { kJMCTrack, kJGlobal, kJTPCOnly, kJGCG , kNTrackType }; + enum { kNVtxBin=1 }; + enum { kNCentBin=21}; + AliJEfficiencyScanner(); + AliJEfficiencyScanner(const char *name); + AliJEfficiencyScanner(const AliJEfficiencyScanner& ap); + AliJEfficiencyScanner& operator = (const AliJEfficiencyScanner& ap); + virtual ~AliJEfficiencyScanner(); + + // methods to fill from AliAnalysisTaskSE + virtual void UserCreateOutputObjects(); + virtual void Init(); + virtual void LocalInit() { Init(); } + virtual void UserExec(Option_t *option); + virtual void Terminate(Option_t * opt = ""); + + void SetJTrackList( TClonesArray * l ) { fTrackList = l ; } + void SetJMCTrackList( TClonesArray * l ) { fMCTrackList = l ; } + void SetJEventHeader( AliJEventHeader * h ){ fEventHeader = h ; } + void SetJRunHeader( AliJRunHeader *h ){ fRunHeader = h; } + + bool IsSelected( AliJTrack * track, int itrigger )const { return AliJTrackCut::GetInstance().IsSelected(track, itrigger); } + + AliJTrack * GetJTrack( int i ){ return (AliJTrack*) fTrackList->At(i); } + AliJMCTrack * GetJMCTrack( int i ){ return (AliJMCTrack*) fMCTrackList->At(i); } + TClonesArray * GetJMCTracks() { return fMCTrackList; } + TClonesArray * GetJTracks() { return fTrackList; } + AliJEventHeader * GetJEventHeader(){ return fEventHeader; } + AliJRunHeader * GetJRunHeader(){ return fRunHeader; } + + TH1 * AddTH1(TString name, TH1*h ){ + h->SetName(name); + h->SetTitle(name); + h->Sumw2(); + h->SetDirectory(gDirectory); + return h; + } + TH1D * AddTH1D( TString name, TH1D*h){ return (TH1D*)AddTH1(name,h); } + TH2D * AddTH2D( TString name, TH2D*h){ return (TH2D*)AddTH1(name,h); } + + private: + + Int_t DebugLevel(){ return 5; } + inline void DEBUG(int level, int type, TString msg1, TString msg2=""){ + if(DebugLevel()>level) std::cout<~AliJEfficiencyTask(); + new(this) AliJEfficiencyTask(ap); + return *this; +} + +//______________________________________________________________________________ +AliJEfficiencyTask::~AliJEfficiencyTask() +{ + // destructor + + delete fEfficiencyScanner; + +} + +//________________________________________________________________________ + +void AliJEfficiencyTask::UserCreateOutputObjects() +{ + //=== create the jcorran outputs objects + if(fDebug > 1) printf("AliJEfficiencyTask::UserCreateOutPutData() \n"); + + //=== Get AnalysisManager + AliAnalysisManager *man = AliAnalysisManager::GetAnalysisManager(); + if(!man->GetOutputEventHandler()) { + Fatal("UserCreateOutputObjects", "This task needs an AOD handler"); + return; + } + + fFilterTask = (AliJCORRANTask*)(man->GetTask( fFilterTaskName )); + + OpenFile(1); + + fEfficiencyScanner->SetJRunHeader( fFilterTask->GetJRunHeader() );//TODO + fEfficiencyScanner->SetJTrackList( fFilterTask->GetFilter()->GetTrackList() ); + fEfficiencyScanner->SetJMCTrackList( fFilterTask->GetFilter()->GetMCTrackList() ); + fEffHistDir = gDirectory->mkdir("EffHist"); + fEffHistDir->cd(); + fEfficiencyScanner->UserCreateOutputObjects(); + PostData( 1, fEffHistDir ); + + cout << "Add(fAliRunHeader) in UserCreateObject() ======= " << endl; + +} + +//______________________________________________________________________________ +void AliJEfficiencyTask::UserExec(Option_t* /*option*/) +{ + + // Processing of one event + if(fDebug > 5) cout << "------- AliJEfficiencyTask Exec-------"<GetFilter()->GetEventSuccess() ){ + fEfficiencyScanner->SetJEventHeader( (AliJEventHeader*) fFilterTask->GetFilter()->GetHeaderList()->At(0) ); + fEfficiencyScanner->UserExec(""); + PostData(1, fEffHistDir ); + } + + + if(fDebug > 5) cout << "\t------- End UserExec "<Init(); +} + +//______________________________________________________________________________ +void AliJEfficiencyTask::Terminate(Option_t *) +{ + + fEfficiencyScanner->Terminate(); + OpenFile(1); + fEffHistDir->Write(); + cout<<"JEfficiency Analysis DONE !!"< +#include "AliJEventPool.h" + +#include + +#include "AliJTrack.h" +#include "AliJPhoton.h" +#include + +#include "AliJBaseTrack.h" +#include "AliJPhoton.h" + + +#include "AliJPiZero.h" + +#include "AliJCard.h" +#include "AliJCorrelations.h" +#include "AliJHistos.h" + + +// event mixing +// blah +// blah +// blah +// blah + +AliJEventPool::AliJEventPool(AliJCard *cardin, AliJHistos *histosin, AliJCorrelations *coin, particleType particle ) : + fcard(cardin), + fcorrelations(coin), + fhistos(histosin), + ftk(NULL), + ftk1(NULL), + ftk2(NULL), + fthisPoolType(particle), + fpoolList(NULL) +{ + // constructor + + if(fcard->GetNoOfBins(kCentrType) > kMaxNoCentrBin ){ + cout<<"ERROR: No of Centrality bins exceed max dim in AliJEventPool.h"<GetNoOfBins(kCentrType);ic++){ + cout<<"Mixing pool depth for icbin = "<< ic << " is " << fcard->GetEventPoolDepth(ic) <<" for <"< and prototype "<GetEventPoolDepth(ic) > MAXNOEVENT ){ + cout<<"ERROR: Event pool depth exeed max="<GetNoOfBins(kCentrType);ic++){ + for(int ie=0;ieGetEventPoolDepth(ic); ie++){ + fLists[ic][ie] = new TClonesArray(kParticleProtoType[particle],1500); + } + flastAccepted[ic] = -1; //to start from 0 + fwhereToStore[ic] = -1; //to start from 0 + fnoMix[ic] = 0; + fnoMixCut[ic] = 0; + } + + ftk = new AliJBaseTrack; + ftk1 = new AliJBaseTrack; + ftk2 = new AliJBaseTrack; + +} + +AliJEventPool::~AliJEventPool( ){ + // destructor + delete ftk; + delete ftk1; + delete ftk2; +} + +AliJEventPool::AliJEventPool(const AliJEventPool& obj) : + fcard(obj.fcard), + fcorrelations(obj.fcorrelations), + fhistos(obj.fhistos), + ftk(obj.ftk), + ftk1(obj.ftk1), + ftk2(obj.ftk2), + fthisPoolType(obj.fthisPoolType), + fpoolList(obj.fpoolList) +{ + // copy constructor + JUNUSED(obj); +} + +AliJEventPool& AliJEventPool::operator=(const AliJEventPool& obj){ + // equal sign operator + JUNUSED(obj); + return *this; +} + + +//______________________________________________________________________________ +void AliJEventPool::Mix( TClonesArray *triggList, + corrFillType cFTyp, + float cent, float Z, float thisMult, int iev){ + // mixer + int cBin = fcard->GetBin(kCentrType, cent); + int zBin = fcard->GetBin(kZVertType, Z); + int noTrigg=triggList->GetEntriesFast(); + int noAssoc=0; + +// cout << "c: " << cBin << endl; + + + for(int backCounter=0; backCounter <= flastAccepted[cBin]; backCounter++){ + fpoolList = fLists [cBin] [backCounter]; + noAssoc = fpoolList->GetEntries(); + + if(noAssoc<=0) continue; + + //mixit======= + fnoMix[cBin]++; + + if( + fcard->SimilarCentrality(fcentrality[cBin][backCounter], cent, cBin) && + fcard->SimilarMultiplicity(fmult[cBin][backCounter], thisMult) && + fcard->GetBin(kZVertType, fZVertex[cBin][backCounter])==zBin && + fevent[cBin][backCounter] != iev ) + { + fnoMixCut[cBin]++; + //================================================= + // try to use only one track from each fevent + //================================================= + for(int ii=0;iiAt(ii); + //fhistos->fhTriggPtBin[kMixed][cBin][iptt]->Fill(ptt); //who needs that? + for(int jj=0;jjAt(jj); + fcorrelations->FillHisto(cFTyp,kMixed, cBin, zBin, ftk1, ftk2); + } //inner loop mixing + }//outer loop mixing + }//if good for mix + }//mixed fevent loop +} + +//______________________________________________________________________________ +void AliJEventPool::AcceptList(TClonesArray *inList, float cent, float Z, float inMult, int iev){ + ////////////////////////////////////////////////////////////// + // circular buffer. New fevent added after the previous one, + // mixing goes backwards + ////////////////////////////////////////////////////////////// + int cBin = fcard->GetBin(kCentrType, cent); + flastAccepted[cBin]++; + fwhereToStore[cBin]++; + if( flastAccepted[cBin] >= fcard->GetEventPoolDepth(cBin) ) flastAccepted[cBin] = fcard->GetEventPoolDepth(cBin)-1; + if( fwhereToStore[cBin] >= fcard->GetEventPoolDepth(cBin) ) fwhereToStore[cBin] = 0; + fevent [cBin][fwhereToStore[cBin]] = iev; + fZVertex [cBin][fwhereToStore[cBin]] = Z; + fcentrality[cBin][fwhereToStore[cBin]] = cent; + fmult [cBin][fwhereToStore[cBin]] = inMult; + + fLists[cBin][fwhereToStore[cBin]]->Clear(); + for(int i=0;iGetEntriesFast();i++){ + if( fthisPoolType == kPhoton || fthisPoolType == kDecayphoton ){ + AliJPhoton *tkp = (AliJPhoton*)inList->At(i); + new ((*fLists[cBin][fwhereToStore[cBin]])[i]) AliJPhoton(*tkp); + } + else if( fthisPoolType == kPizero || fthisPoolType == kEta ){ + AliJPiZero *tkpz = (AliJPiZero*)inList->At(i); + new ((*fLists[cBin][fwhereToStore[cBin]])[i]) AliJPiZero(*tkpz); + } + else{ + AliJTrack *tk3 = (AliJTrack*)inList->At(i); + new ((*fLists[cBin][fwhereToStore[cBin]])[i]) AliJTrack(*tk3); + } + } + +} + + + + + +//==================== Sampling =========================== +void AliJEventPool::Mysample(TH1D *fromh, TH1D *toh ) +{ + // sampler + if(fabs(toh->GetBinWidth(1)-fromh->GetBinWidth(1))>1e-5){ + cout<<" Attempt to integrate histograms with non-compatible binning"<GetBinWidth(1), toh->GetBinWidth(1), fabs(toh->GetBinWidth(1)-fromh->GetBinWidth(1)) ); + return; + } + + for(int idphi=1; idphi<=toh->GetNbinsX(); idphi++){ + double sum=0,err=0, a,b,e; + for (int i = 1;i <= fromh->GetNbinsX();i++) + { + double phi1 = fromh->GetBinCenter(i); + double fdphi = toh->GetBinCenter(idphi); + double phi2 = atan2(sin(phi1+fdphi),cos(phi1+fdphi)); + a=fromh->GetBinContent(i); + b=fromh->GetBinContent(fromh->FindBin(phi2)); + sum += a*b; + err += a*b*(a+b); + } + if( idphi==1 || idphi== toh->GetNbinsX() ) sum /= 2.0; + toh->SetBinContent(idphi,toh->GetBinContent(idphi)+sum); + e=toh->GetBinError(idphi); + toh->SetBinError(idphi,sqrt(err+e*e)); + } +} + +//______________________________________________________________________________ + + + + + + + + + + + + + + + + + + + + + diff --git a/PWGCF/Correlations/JCORRAN/AliJEventPool.h b/PWGCF/Correlations/JCORRAN/AliJEventPool.h new file mode 100644 index 00000000000..d826f2b86b9 --- /dev/null +++ b/PWGCF/Correlations/JCORRAN/AliJEventPool.h @@ -0,0 +1,99 @@ +//=========================================================== +// AliJEventPool.h +// +//=========================================================== + +#ifndef ALIJEVENTPOOL_H +#define ALIJEVENTPOOL_H + +#include +#include +#include +#include + +using namespace std; + +#include + +class TClonesArray; +class AliJBaseTrack; +class AliJPhoton; +class AliJTrack; +class AliJCard; +class AliJCorrelations; +class AliJHistos; +class TH1D; + +#define MAXNOEVENT 1000 // Maximum no of events in pools (400 used for QM anal.) + +class AliJEventPool { + + public: + AliJEventPool(AliJCard *cardin, AliJHistos *histosin, AliJCorrelations *coin, particleType particle ); + virtual ~AliJEventPool( ); + AliJEventPool(const AliJEventPool& obj); + AliJEventPool& operator=(const AliJEventPool& obj); + + + public: + void Mix( TClonesArray *triggList, + corrFillType cFTyp, + float cent, float Z, float thisMult, int iev); + + //void MixRNDM( AliJEventPool *cross, void (AliJCorrelations::*fillHisto)(fillType, int, AliJBaseTrack*, AliJBaseTrack*) ); + + void AcceptList(TClonesArray *inList, float cent, float Z, float inMult, int iev); + + void Mysample(TH1D *fromh, TH1D *toh ); + void PrintOut(){for(int i=0;i0?fnoMixCut[i]*1.0/fnoMix[i]:0)<< endl;} + + protected: + + int fevent[kMaxNoCentrBin][MAXNOEVENT]; // comment me + float fZVertex[kMaxNoCentrBin][MAXNOEVENT]; // comment me + float fcentrality[kMaxNoCentrBin][MAXNOEVENT]; // comment me + float fmult[kMaxNoCentrBin][MAXNOEVENT]; // comment me + long flastAccepted[kMaxNoCentrBin]; // comment me + long fwhereToStore[kMaxNoCentrBin]; // comment me + long fnoMix[kMaxNoCentrBin]; // comment me + long fnoMixCut[kMaxNoCentrBin]; // comment me + + TClonesArray *fLists[kMaxNoCentrBin][MAXNOEVENT]; // mix lists + AliJCard *fcard; // card + AliJCorrelations *fcorrelations; // correlation object + AliJHistos *fhistos; // histos + AliJBaseTrack *ftk; // track + AliJBaseTrack *ftk1; // track + AliJBaseTrack *ftk2; // track + particleType fthisPoolType; // pool type + + TClonesArray *fpoolList; // pool list + + //int trials[MAXNOEVENT]; + +}; + +#endif + + + + + + + + + + + + + + + + + + + + + + diff --git a/PWGCF/Correlations/JCORRAN/AliJFilter.cxx b/PWGCF/Correlations/JCORRAN/AliJFilter.cxx new file mode 100644 index 00000000000..a22c77e502a --- /dev/null +++ b/PWGCF/Correlations/JCORRAN/AliJFilter.cxx @@ -0,0 +1,1143 @@ +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include + + +#include "AliJFilter.h" +#include "AliAnalysisManager.h" +#include "AliAnalysisTaskSE.h" +#include "AliESDEvent.h" +#include "AliMCEvent.h" +#include "AliStack.h" +#include "AliGenEventHeader.h" +#include "AliGenCocktailEventHeader.h" +#include "AliGenPythiaEventHeader.h" +#include "AliInputEventHandler.h" +#include "AliESDCaloCluster.h" +#include "AliAODEvent.h" +#include "AliAODHeader.h" +#include "AliAODHandler.h" +#include "AliLog.h" +#include "AliESDVertex.h" +#include "AliESDtrack.h" +#include "AliAODTrack.h" +#include "AliAnalysisFilter.h" +#include "AliESDtrackCuts.h" +#include "AliAODVertex.h" +#include "AliAODTracklets.h" +#include "AliAODPid.h" +#include "AliAODMCHeader.h" +#include "AliAODMCParticle.h" +#include "AliESDUtils.h" +//#include "AliESDVZERO.h" +#include "AliCentrality.h" +#include "AliAODTracklets.h" +#include "AliMultiplicity.h" +#include "AliJConst.h" +#include "AliESDRun.h" +#include "AliDAQ.h" +#include "AliESDVZERO.h" +#include "AliExternalTrackParam.h" +#include "AliHeader.h" +//== EMCAL +#include "AliESDCaloCluster.h" +#include "AliEMCALGeometry.h" +#include "AliVCluster.h" +#include "AliVCaloCells.h" +#include "AliEMCALRecoUtils.h" +#include "AliEMCALPIDUtils.h" + +#include "AliJTrack.h" +#include "AliJMCTrack.h" +#include "AliJPhoton.h" +//#include "AliJCaloCell.h" +#include "AliJEventHeader.h" +#include "AliJRunHeader.h" + +#include "AliPIDResponse.h" +#include "AliPIDCombined.h" +#include "AliPHOSGeoUtils.h" +#include "AliAnalysisUtils.h" + + +ClassImp(AliJFilter); + +//______________________________________________________________________________ +AliJFilter::AliJFilter() : + TNamed(), + fEsdTrackCuts(0x0), + fESDFilter(0x0), + fIsRealOrMC(0), + fStoreEventPlaneSource(0), + fOADBPath(), + fCaloClustersArr(0), + fClusterThreshold(0), + fTrackThreshold(0), + fEventSuccess(0), + fMcMap(0), + fTrackList(0), + fMCTrackList(0x0), + fPhotonList(0x0), + fCaloCellList(0x0), + fHeaderList(0x0), + fRunInfoList(0x0), + fPIDResponse(0x0), + fPIDCombined(0x0), + fVZEROData(0x0), + fTZEROData(0x0), + //fFMDData(0x0), + fZDCData(0x0), + fEMCLabels(0), + fEMCTreeLabels(0), + fAliJRunHeader(0x0), + fEMCALGeometry(0x0), + fEMCALRecoUtils(0x0), + fPHOSGeom(0x0), + fAnaUtils(0x0), + fMyTask(0x0) +{ + //Default constructor +} + +//______________________________________________________________________________ +AliJFilter::AliJFilter(const char *name,AliAnalysisTaskSE *task): + TNamed(name,name), + fEsdTrackCuts(0x0), + fESDFilter(0x0), + fIsRealOrMC(0), + fStoreEventPlaneSource(0), + fOADBPath(), + fCaloClustersArr(0), + fClusterThreshold(0), + fTrackThreshold(0), + fEventSuccess(0), + fMcMap(0), + fTrackList(0), + fMCTrackList(0x0), + fPhotonList(0x0), + fCaloCellList(0x0), + fHeaderList(0x0), + fRunInfoList(0x0), + fPIDResponse(0x0), + fPIDCombined(0x0), + fVZEROData(0x0), + fTZEROData(0x0), + //fFMDData(0x0), + fZDCData(0x0), + fEMCLabels(0), + fEMCTreeLabels(0), + fAliJRunHeader(0x0), + fEMCALGeometry(0x0), + fEMCALRecoUtils(0x0), + fPHOSGeom(0x0), + fAnaUtils(0x0), + fMyTask(0x0) +{ + // Constructor + if(task->DebugLevel() > 5) cout << "---- AliJFilter Constructor ----"<~AliJFilter(); + new(this) AliJFilter(ap); + return *this; +} + +//______________________________________________________________________________ +AliJFilter::~AliJFilter() +{ + // destructor + delete fMcMap; + delete fTrackList; + delete fMCTrackList; + delete fPhotonList; + delete fCaloCellList; + delete fHeaderList; + delete fAliJRunHeader; + delete fRunInfoList; + delete fPIDResponse; + delete fPIDCombined; + delete fEMCALRecoUtils; + delete fEMCALGeometry; + delete fPHOSGeom; + delete fAnaUtils; + delete fVZEROData; + delete fTZEROData; + delete fZDCData; + // delete fFMDData; + + +} + +//________________________________________________________________________ + +void AliJFilter::UserCreateOutputObjects() +{ + //=== create the jcorran outputs objects + if(fMyTask->DebugLevel() > 1) printf("AliJFilter::UserCreateOutPutData() \n"); + + //== RUN HEADER + cout<<"TEST2 "<SetName("RunInfoList"); + fRunInfoList->SetOwner(); + fRunInfoList->Clear(); + fRunInfoList->Add(fAliJRunHeader); + + //=== Other Objects + fCaloClustersArr = new TRefArray(); + fEMCALGeometry = AliEMCALGeometry::GetInstance("EMCAL_COMPLETEV1"); + fEMCALRecoUtils = new AliEMCALRecoUtils(); + fPHOSGeom = new AliPHOSGeoUtils(); + fAnaUtils = new AliAnalysisUtils(); + fAnaUtils->SetUseOutOfBunchPileUp( kTRUE ); + fMcMap = new TArrayI(); + + //=== Set Tree and TClonesArray + //== TRACKS + AddList("AliJTrackList", "AliJTrack", &fTrackList, 1000); + if( fAliJRunHeader->GetStoreEMCalInfo() ){ + AddList("AliJPhotonList", "AliJPhoton", &fPhotonList, 1000); + //BS AddList("AliJCaloCell", "AliJCaloCell", &fCaloCellList, 1000); + } + if( IsMC() ) + AddList("AliJMCTrackList", "AliJMCTrack", &fMCTrackList, 1000); + //== Event Header + AddList("AliJEventHeaderList", "AliJEventHeader", &fHeaderList, 1000); + + //== EventPlane SRC + if( fAliJRunHeader->GetStoreEventPlaneSource() ){ + fVZEROData = new AliESDVZERO; + fTZEROData = new AliESDTZERO; + fZDCData = new AliESDZDC; + } + //== PID + // fPIDCombined = new AliPIDCombined; + // fPIDCombined->SetDefaultTPCPriors(); + // fPIDCombined->SetDetectorMask(AliPIDResponse::kDetTPC+AliPIDResponse::kDetTOF); + // fPIDResponse = ((AliInputEventHandler*) (man->GetInputEventHandler()))->GetPIDResponse(); + // fPIDResponse->SetOADBPath(AliAnalysisManager::GetOADBPath()); + // if (!fOADBPath.IsNull()) fPIDResponse->SetOADBPath(fOADBPath.Data()); + + cout << "Add(fAliJRunHeader) in UserCreateObject() ======= " << endl; + +} + +//______________________________________________________________________________ +void AliJFilter::UserExec(Option_t* /*option*/) +{ + // user loop + AliJRunHeader *runh = fAliJRunHeader; + Bool_t hasGoodTrack, hasGoodCluster; + + fEventSuccess = kFALSE; + + // Processing of one event + DEBUG( 5, 1, "------- AliJFilter Exec-------" ); + if(!((fMyTask->Entry()-1)%100)) AliInfo(Form(" Processing event # %lld", fMyTask->Entry())); + + //=== Init Variables + fTrackList->Clear(); + if( IsMC() ){ + fMCTrackList->Clear(); + fEMCLabels.clear(); + fEMCTreeLabels.clear(); + } + + if( fAliJRunHeader->GetStoreEMCalInfo() ){ + fPhotonList->Clear("C"); + fCaloCellList->Clear(); + } + fHeaderList->Clear(); + + hasGoodCluster = kTRUE; + hasGoodTrack = kTRUE; + + //=== CHECK ESD, AOD, MC event + if( !Event() ) return; + + if( FromESD() ) { //Reading ESD + DEBUG( 5, 1, "\t------- Start ESD " ); + if( !ESDEvent() ) return; + if( runh->GetWithoutSDD() && !(ESDEvent()->GetTriggerMask() & (1<<13)) ) return; + + if( IsMC() ){ + if( ! MCEvent() ) return; + } + } + + if( FromAOD() ) { + DEBUG( 5, 1, "\t------- Start AOD " ); + if( !AODEvent() ) return; + } + + + // pileup rejection + if( fAnaUtils->IsPileUpEvent( Event() )) + return; + + //--------------------------------------------------------------- + // RUN Header + //--------------------------------------------------------------- + if(!runh->GetRunNumber()){ //new run has started : I suppose no change of run in process + runh->SetRunNumber( Event()->GetRunNumber() ); + if( FromESD() ){ + //==== General ====// + runh->SetBeamEnergy( ESDEvent()->GetBeamEnergy() ); + runh->SetBeamType( ESDEvent()->GetBeamType() ); + //==== Detector status ==// + if( ESDEvent()->GetCurrentL3() > 0 ) runh->SetL3MagnetFieldPolarity(1); + if( ESDEvent()->GetCurrentL3() < 0 ) runh->SetL3MagnetFieldPolarity(-1); + runh->SetL3MagnetFieldIntensity( ESDEvent()->GetMagneticField() ); + runh->SetCurrentL3( ESDEvent()->GetCurrentL3() ); + runh->SetCurrentDip( ESDEvent()->GetCurrentDip() ); + runh->SetUniformBMap( ESDEvent()->IsUniformBMap() ); + //==== Triggers ====// + const AliESDRun* esdRun = ESDEvent()->GetESDRun(); + for(Int_t triggerBit=0; triggerBitSetActiveTriggersAlice( triggerBit, esdRun->GetTriggerClass(triggerBit) ); + } + } + else if( FromAOD() ){ + //==== General ====// + cout << "Run # = "<< AODEvent()->GetRunNumber() << endl; + runh->SetRunNumber( AODEvent()->GetRunNumber() ); + //TODO runh->SetBeamEnergy( ESDEvent()->GetBeamEnergy() ); + //TODO runh->SetBeamType( ESDEvent()->GetBeamType() ); + //==== Detector status ==// + //TODO runh->Setl3MgFieldPolarity(1); + runh->SetL3MagnetFieldIntensity( AODEvent()->GetMagneticField() ); + runh->SetCurrentL3( AODEvent()->GetMagneticField()*30000.0/5.00668 ); + runh->SetCurrentDip( AODEvent()->GetMuonMagFieldScale()*6000.0 ); + runh->SetUniformBMap( kFALSE ); // TODO is this? + } + cout << "Add(fAliJRunHeader) is done =============" << endl; + } + + //--------------------------------------------------------------- + // EventHeader and read Others + //--------------------------------------------------------------- + if( FromESD() ){ //Reading ESD + DEBUG( 5, 1, "\t------- Start READ ESD " ); + + ReadESDHeader( ESDEvent() ); + ReadESDTracks( ESDEvent() ); + + if( fAliJRunHeader->GetStoreEMCalInfo() ){ + ReadESDCaloClusters( ESDEvent() ); + ReadESDCaloCells( ESDEvent() ); + } + if( IsMC() ){ + ReadMCTracksFromESD(); + //RemapMCLabels(); + } + }else if( FromAOD() ){ + DEBUG( 5, 1, "\t------- Start READ AOD " ); + ReadAODHeader( AODEvent() ); + ReadAODTracks( AODEvent() ); + if( fAliJRunHeader->GetStoreEMCalInfo() ){ + ReadAODCaloClusters( AODEvent() ); + ReadAODCaloCells( AODEvent() ); + } + if( IsMC() ){ + ReadMCTracksFromAOD(); + //RemapMCLabels(); + } + + }else{ + cout << "Error: Not correct InputDataFormat especified " << endl; + return; + } + + if( hasGoodCluster || hasGoodTrack ){ + //=== TODO : need this? + AliAODHandler* outputHandler = + (AliAODHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler()); + outputHandler->SetFillAOD(kTRUE); + outputHandler->SetFillExtension(kTRUE); + fEventSuccess = kTRUE; + } + else{ + fTrackList->Clear(); + if( IsMC() ){ + fMCTrackList->Clear(); + fEMCLabels.clear(); + fEMCTreeLabels.clear(); + } + + if( fAliJRunHeader->GetStoreEMCalInfo() ){ + fPhotonList->Clear("C"); + fCaloCellList->Clear(); + } + fHeaderList->Clear(); + } + + DEBUG( 5, 1, "\t------- End UserExec " ); +} + +//______________________________________________________________________________ +void AliJFilter::Init() +{ + // Intialisation of parameters + AliInfo("Doing initialization") ; + + // TString formula(fEsdTrackCuts->GetMaxDCAToVertexXYPtDep()); + // if(formula.Length()>0){ // momentum dep DCA cut for AOD + // formula.ReplaceAll("pt","x"); + // } +} + +//______________________________________________________________________________ +void AliJFilter::Terminate(Option_t *) +{ + // termination + fTrackList->Clear(); + if( IsMC() ) fMCTrackList->Clear(); + if( fAliJRunHeader->GetStoreEMCalInfo() ){ + fPhotonList->Clear(); + fCaloCellList->Clear(); + } + fHeaderList->Clear(); + + // Processing when the event loop is ended + cout<<"PWG4JCORRAN Analysis DONE !!"<GetNumberOfTracks(); + DEBUG( 5, 1 , Form("ESD::NumberOfTracks = %d",nt), "AliJFilter::ReadESDTracks" ); + + //==== Prepare TPC, GCG track ====// + Float_t ptMaxTPC = 0; + Float_t ptMinTPC = 1E10; + Float_t ptMaxGCG = 0; + Float_t ptMinGCG = 1E10; + for(int i = 0;i<32;i++){ + AliESDtrackCuts* cuts = (AliESDtrackCuts*)fESDFilter->GetCuts()->At(i); + if(!cuts) continue; + Float_t tmp1= 0,tmp2 = 0; + cuts->GetPtRange(tmp1,tmp2); + if( TESTBIT ( fAliJRunHeader->GetStoreTPCTrackBitMask(), i ) ){ + if(tmp1ptMaxTPC)ptMaxTPC=tmp2; + } + if( TESTBIT(fAliJRunHeader->GetStoreGCGTrackBitMask() , i ) ){ + if(tmp1ptMaxGCG)ptMaxGCG=tmp2; + } + } + + //==== loop over tracks ====// + for(Int_t it = 0; it < nt; it++) { + + AliESDtrack *track = esd->GetTrack(it); + if( !track ) continue; + UInt_t filterMap = fESDFilter->IsSelected( track ); + if(! filterMap ) continue; // apply track selection criteria + + //====create a new AliJTrack and fill the track info + AliJTrack * ctrack = new( (*fTrackList)[fTrackList->GetEntriesFast()] ) AliJTrack; + ctrack->SetPxPyPzE(track->Px(), track->Py(), track->Pz(), 0 ); + Double32_t pos[3]; + track->GetXYZ(pos); + ctrack->SetTrackPos( pos ); + ctrack->SetTPCdEdx( track->GetTPCsignal() ); + ctrack->SetParticleType(kJNone); + ctrack->SetCharge(track->Charge()); + ctrack->SetFilterMap( filterMap ); + ctrack->SetLabel( track->GetLabel() ); + + ReadESDPID( track, ctrack ); + //==== TPC Tracks ====// + if( filterMap & fAliJRunHeader->GetStoreTPCTrackBitMask() ) { + ConvertESDTPCOnlyTracks( esd, it, ctrack, ptMinTPC, ptMaxTPC ); + } + //==== GCG Tracks ====// + if( filterMap & fAliJRunHeader->GetStoreGCGTrackBitMask() ) { + ConvertESDGCGTracks( esd, it, ctrack, ptMinGCG, ptMaxGCG ); + } + + Float_t b[2]; + Float_t bCov[3]; + track->GetImpactParameters(b,bCov); + // ctrack->SetDCAtoVertexXY( b[0] ); + // ctrack->SetDCAtoVertexZ( b[1] ); + + //if( track->P()>1 ) DEBUG( 5, 1, Form("P = %f", track->P() ) ) ; + + } // end tracks loop +} + +//______________________________________________________________________________ +void AliJFilter::ConvertESDTPCOnlyTracks(AliESDEvent* esd, int iTrack, AliJTrack * ctrack, double ptmin, double ptmax) +{ + + const AliESDVertex *vtxSPD = esd->GetPrimaryVertexSPD(); + + Double_t pos[3] = { 0. }; + Double_t covTr[21]={0.}; + //Double_t pid[10]={0.}; + + Double_t p[3] = { 0. }; + + Double_t pDCA[3] = { 0. }; // momentum at DCA + Double_t rDCA[3] = { 0. }; // position at DCA + Float_t dDCA[2] = {0.}; // DCA to the vertex d and z + Float_t cDCA[3] = {0.}; // covariance of impact parameters + + + AliESDtrack* esdTrack = esd->GetTrack(iTrack); //carefull do not modify it othwise need to work with a copy + + // Track selection + + AliESDtrack *track = AliESDtrackCuts::GetTPCOnlyTrack(const_cast(esd),esdTrack->GetID()); + if(!track) return; + + if(track->Pt()>0.) + { + // only constrain tracks above threshold + AliExternalTrackParam exParam; + // take the B-field from the ESD, no 3D fieldMap available at this point + Bool_t relate = false; + relate = track->RelateToVertexTPC(vtxSPD,esd->GetMagneticField(),kVeryBig,&exParam); + if(!relate){ + delete track; + return; + } + // fetch the track parameters at the DCA (unconstraint) + if(track->GetTPCInnerParam()){ + track->GetTPCInnerParam()->GetPxPyPz(pDCA); + track->GetTPCInnerParam()->GetXYZ(rDCA); + } + // get the DCA to the vertex: + track->GetImpactParametersTPC(dDCA,cDCA); + // set the constrained parameters to the track + track->Set(exParam.GetX(),exParam.GetAlpha(),exParam.GetParameter(),exParam.GetCovariance()); + } + + track->GetPxPyPz(p); + + double p2[3]; + esdTrack->GetInnerPxPyPz(p2); + + Float_t pT = track->Pt(); + if(pTptmax){ + delete track; + return; + } + + track->GetXYZ(pos); + track->GetCovarianceXYZPxPyPz(covTr); + + ctrack->SetTPCTrack(p[0], p[1], p[2]); + + delete track; +} + + +void AliJFilter::ConvertESDGCGTracks(AliESDEvent *esd, int iTrack, AliJTrack *ctrack, double ptMin, double ptMax) +{ + + Double_t pos[3] = { 0. }; + Double_t covTr[21]={0.}; + Double_t p[3] = { 0. }; + + Double_t pDCA[3] = { 0. }; // momentum at DCA + Double_t rDCA[3] = { 0. }; // position at DCA + Float_t dDCA[2] = {0.}; // DCA to the vertex d and z + Float_t cDCA[3] = {0.}; // covariance of impact parameters + + + AliESDtrack* esdTrack = esd->GetTrack(iTrack); //carefull do not modify it othwise need to work with a copy + const AliExternalTrackParam * exParamGC = esdTrack->GetConstrainedParam(); + if(!exParamGC) return; + + // fetch the track parameters at the DCA (unconstrained) + esdTrack->GetPxPyPz(pDCA); + esdTrack->GetXYZ(rDCA); + // get the DCA to the vertex: + esdTrack->GetImpactParameters(dDCA,cDCA); + + if (!esdTrack->GetConstrainedPxPyPz(p)) return; + + + Float_t pT = exParamGC->Pt(); + if(pTptMax){ + return; + } + + esdTrack->GetConstrainedXYZ(pos); + exParamGC->GetCovarianceXYZPxPyPz(covTr); + + ctrack->SetGCGTrack(p[0], p[1], p[2]); +} + + + +//_________________________________________________________________________________- +void AliJFilter::ReadESDPID(AliESDtrack *track, AliJTrack *ctrack) +{ + // To reduce the size of output, the variables which cannot be calculated later are only kept + // expected TOF signal, TPC momentum for expected TPC signal. Measured values are stored in ReadESDTrack() + // 1. expected TOF signal + Double_t times[AliPID::kSPECIES]; + track->GetIntegratedTimes(times); + for(int ip=0; ip < (AliJTrack::kNAliJTrkPID); ip++) { + ctrack->SetExpectedTOFsignal(AliJTrack::AliJTrkPID(ip), times[ip]); + + } + // 2. TPC momentum + Double_t momTPC = track->GetTPCmomentum(); + ctrack->SetTPCmomentum(momTPC); +} + +//______________________________________________________________________________ +Bool_t AliJFilter::ReadAODTracks(const AliAODEvent * aod) +{ + // AOD track reader + Bool_t hasGoodTrack; + hasGoodTrack = kFALSE; + + // Read the AliAODtrack and fill the list of AliJTrack containers + Int_t nt = aod->GetNumberOfTracks(); + Int_t listnt = 0; + + DEBUG(5, 1, Form("AOD::NumberOfTracks = %d",nt) ); + + //==== loop over tracks ====// + for(Int_t it = 0; it < nt; it++) { + + AliAODTrack *track = aod->GetTrack(it); + //if(track->GetFilterMap() & (1 << 7) ) continue; + //if(!AcceptAODTrack(track)) continue; + //if(! fEsdTrackCuts->IsSelected(track)) continue; //apply loose selection criteria + //FK//if(track->GetType() != AliAODTrack::kPrimary) continue; // only primaries + // + + AliJTrack * ctrack = new( (*fTrackList)[listnt++] ) AliJTrack; + ctrack->SetID( track->GetID() ); + ctrack->SetPxPyPzE(track->Px(), track->Py(), track->Pz(), 0 ); + Double32_t pos[3]; + track->GetXYZ(pos); + ctrack->SetTrackPos( pos ); + //TODO if( fStoreTPCTrack ) + ctrack->SetParticleType(kJNone); + ctrack->SetCharge(track->Charge()); + ctrack->SetStatus(track->GetStatus());// + ctrack->SetFlags( track->GetFlags() ); + ctrack->SetLabel( track->GetLabel() ); + // //FilterMap + // UInt_t filterMap=0; + // for( unsigned int i=0;iTestFilterBit( BIT(i) )){ + // SETBIT( filterMap , i); + // } + // } + ctrack->SetFilterMap( track->GetFilterMap() ); + + //PID TODO + double const * pid = track->PID(); + ctrack->SetPID(AliJTrack::kElectronAliJ,pid[AliAODTrack::kElectron],AliJTrack::kTOF); + ctrack->SetPID(AliJTrack::kMuonAliJ, pid[AliAODTrack::kMuon], AliJTrack::kTOF); + ctrack->SetPID(AliJTrack::kPionAliJ, pid[AliAODTrack::kPion], AliJTrack::kTOF); + ctrack->SetPID(AliJTrack::kKaonAliJ, pid[AliAODTrack::kKaon], AliJTrack::kTOF); + ctrack->SetPID(AliJTrack::kProtonAliJ, pid[AliAODTrack::kProton], AliJTrack::kTOF); + //TPC + ctrack->SetTPCnClust(track->GetTPCNcls()); + ctrack->SetTPCdEdx( track->GetTPCsignal() ); + ctrack->SetTOFsignal( track->GetTOFsignal() ); + ctrack->SetLabel( track->GetLabel() ); + for( int i=0;iSetBit( i, track->TestBit( i )); + } + + // check track threshold + if( track->Pt() > fTrackThreshold ) + hasGoodTrack = kTRUE; + + //if(fMyTask->DebugLevel() > 5 && track->P()>1 ) cout << "P = " << track->P() << endl; + } // end tracks loop + + return hasGoodTrack; +} + + +//______________________________________________________________________________ +AliJEventHeader* AliJFilter::ReadCommonHeader(AliVEvent *event){ + //Read the AliVEvent and fill the list of AliJEventHeader containers + //create a header and fill it + AliJEventHeader *hdr = new( (*fHeaderList)[fHeaderList->GetEntriesFast()] ) AliJEventHeader; + + + // Get Centrality as a percent from 0% to 100% + AliCentrality *cent = event->GetCentrality(); + if( cent ){ + hdr->SetCentrality( cent->GetCentralityPercentile("V0M")); + hdr->SetCentralityArray(AliJEventHeader::kcV0M, cent->GetCentralityPercentile("V0M")); + hdr->SetCentralityArray(AliJEventHeader::kcFMD, cent->GetCentralityPercentile("FMD")); + hdr->SetCentralityArray(AliJEventHeader::kcTRK, cent->GetCentralityPercentile("TRK")); + hdr->SetCentralityArray(AliJEventHeader::kcTKL, cent->GetCentralityPercentile("TKL")); + hdr->SetCentralityArray(AliJEventHeader::kcCL0, cent->GetCentralityPercentile("CL0")); + hdr->SetCentralityArray(AliJEventHeader::kcCL1, cent->GetCentralityPercentile("CL1")); + hdr->SetCentralityArray(AliJEventHeader::kcV0MvsFMD, cent->GetCentralityPercentile("V0MvsFMD")); + hdr->SetCentralityArray(AliJEventHeader::kcTKLvsV0, cent->GetCentralityPercentile("TKLvsV0")); + hdr->SetCentralityArray(AliJEventHeader::kcZEMvsZDC, cent->GetCentralityPercentile("ZEMvsZDC")); + hdr->SetCentralityArray(AliJEventHeader::kcV0A, cent->GetCentralityPercentile("V0A")); + hdr->SetCentralityArray(AliJEventHeader::kcV0C, cent->GetCentralityPercentile("V0C")); + } + hdr->SetTriggerMaskAlice(event->GetTriggerMask()); //ULong64_t + hdr->SetTriggerMaskJCorran(ConvertTriggerMask()); //UInt_t + hdr->SetEventType(event->GetEventType()); + hdr->SetBunchCrossNumber(event->GetBunchCrossNumber()); + + int ncontributors = 0; + const AliVVertex * vtxESD = event->GetPrimaryVertex(); + if(vtxESD){ + hdr->SetXVertex(vtxESD->GetX()); //FK// EFF + hdr->SetYVertex(vtxESD->GetY()); //FK// EFF + hdr->SetZVertex(vtxESD->GetZ()); + //hdr->SetZVertexErr(vtxESD->GetZRes()); + double covMat[6]; + vtxESD->GetCovarianceMatrix(covMat); + hdr->SetZVertexErr(TMath::Sqrt(covMat[5])); // GetZRes := TMath::Sqrt(fCovZZ) + ncontributors = vtxESD->GetNContributors(); // get number of contributors to vertex + hdr->SetVtxMult( vtxESD->GetNContributors() ); + }else{ + hdr->SetZVertex(9999); + hdr->SetZVertexErr(9999); + } + hdr->SetVtxMult(ncontributors); //FK// EFF contrib to vertex + return hdr; +} +//______________________________________________________________________________ +void AliJFilter::ReadESDHeader(AliESDEvent *esd) +{ + // Read the AliESDEvent and fill the list of AliJEventHeader containers + if(!esd) return; + if( fAliJRunHeader->GetRefitESDVertexTracks() ) + AliESDUtils::RefitESDVertexTracks( esd ); // TODO only for LHC11a right? + AliJEventHeader *hdr = ReadCommonHeader( esd ); + // AliMultiplicity *fSPDMult =(AliMultiplicity *) esd->GetMultiplicity(); + // if(fSPDMult) hdr->SetSPDTrackletMult(fSPDMult->GetNumberOfTracklets()); + // This is moved from ReadCommonHeader. AOD should have same.TODO!! + AliESDVZERO *v0 = esd->GetVZEROData(); + + if( v0 ) hdr->SetV0Mult(v0->GetMTotV0A() + v0->GetMTotV0C()); + if( v0 ) hdr->SetV0AMult(v0->GetMTotV0A()); + if( v0 ) hdr->SetV0CMult(v0->GetMTotV0C()); + + const AliESDRun* esdRun = esd->GetESDRun(); + //cout <<"========================"<GetDetectorsInReco() & AliDAQ::kSPD) << endl; + //cout << (esdRun->GetDetectorsInReco() & AliDAQ::kSSD) << endl; + //cout << (esdRun->GetDetectorsInReco() & AliDAQ::kSDD) << endl; + //cout << (esdRun->GetDetectorsInReco() & AliDAQ::kTPC) << endl; + if(esdRun->GetDetectorsInReco() & AliDAQ::kSPD) hdr->SetSPDTrackletMult(AliESDtrackCuts::GetReferenceMultiplicity( esd, AliESDtrackCuts::kTracklets, 1.0 )); + if((esdRun->GetDetectorsInReco() & AliDAQ::kSSD) || (esdRun->GetDetectorsInReco() & AliDAQ::kSDD)) hdr->SetITSSATrackletMult(AliESDtrackCuts::GetReferenceMultiplicity( esd, AliESDtrackCuts::kTrackletsITSSA, 1.0 )); + if(esdRun->GetDetectorsInReco() & AliDAQ::kTPC) hdr->SetITSTPCTrackletMult(AliESDtrackCuts::GetReferenceMultiplicity( esd, AliESDtrackCuts::kTrackletsITSTPC, 1.0 )); + + + //TODO Store Detector data + if( fAliJRunHeader->GetStoreEventPlaneSource() ){ + *fVZEROData = *esd->GetVZEROData(); + *fTZEROData = AliESDTZERO(*esd->GetESDTZERO()); + *fZDCData = *esd->GetESDZDC(); + } + hdr->SetEventID( esd->GetEventNumberInFile()); + //const AliESDVertex * vtxESD = esd->GetPrimaryVertex(); + //if( vtxESD->GetStatus() == 0 ) hdr->SetVtxMult( 0 ); + // if fNcontributes > 0 then status is always true. do we need this? + + //==== MC ====/ + if( IsMC() ){ + const AliVVertex * primaryMCVertex = MCEvent()->GetPrimaryVertex(); + //cout<<"AliMCEvent = "<= 0) { + fPHOSGeom->AbsToRelNumbering(absId,relId); + fPHOSGeom->AbsToRelNumbering(absId,relId); + return relId[0]-1; + } else return -1; + }//PHOS + + return -1; +} + +//______________________________________________________________________________ +Double_t * AliJFilter::GetCellsAmplitude( bool isemcal, AliVCluster *cluster, AliVCaloCells *emCells, AliVCaloCells *phoCells ) +{ + // cell amplitude reader + Int_t iCell, nCell; + UShort_t *cellAddrs; + Double_t *amps; + + // get cluster cells + nCell = cluster->GetNCells(); + + amps = new Double_t[nCell]; + + // get the cell addresses + cellAddrs = cluster->GetCellsAbsId(); + + // get the cell amplitudes + for( iCell = 0; iCell < nCell; iCell++ ){ + if( isemcal ) + amps[iCell] = emCells->GetCellAmplitude( cellAddrs[iCell] ); + else + amps[iCell] = phoCells->GetCellAmplitude( cellAddrs[iCell] ); + + } + + return amps; +} + +//_____________________________________________________________________________ + +UInt_t AliJFilter::ConvertTriggerMask(){ + + //convert alice trigger mask to jcorran trigger mask + UInt_t triggerMaskJC=0; + if(((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler())) + ->IsEventSelected() & AliVEvent::kMB){ + // minimum bias TBit 0 + triggerMaskJC |= (1<SetActiveTriggersJCorran( kMinBiasTriggerBitJCorran, "MinBiasTriggerBitJCorran"); + } + + if(((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler())) + ->IsEventSelected() & AliVEvent::kHighMult){ + //high multiplicity trigger TBit 1 + triggerMaskJC |= (1<SetActiveTriggersJCorran( kHighMultTriggerBitJCorran,"HighMultTriggerBitJCorran"); + } + + if((((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler())) + ->IsEventSelected() & AliVEvent::kEMC1) || + (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler())) + ->IsEventSelected() & AliVEvent::kEMC7 )){ + //EMCAL L0 TBit2 + triggerMaskJC |= (1<SetActiveTriggersJCorran( kEmc0TriggerBitJCorran,"Emc0TriggerBitJCorran"); + } + + if(((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler())) + ->IsEventSelected() & AliVEvent::kEMCEGA){ + //EMCAL Gamma TBit3 + triggerMaskJC |= (1<SetActiveTriggersJCorran( kEmc1GammaTriggerBitJCorran,"Emc1GammaTriggerBitJCorran"); + } + + if(((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler())) + ->IsEventSelected() & AliVEvent::kEMCEJE){ + //EMCAL JET TBit4 + triggerMaskJC |= (1<SetActiveTriggersJCorran( kEmc1JetTriggerBitJCorran,"Emc1JetTriggerBitJCorran"); + } + + if(((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler())) + ->IsEventSelected() & AliVEvent::kCentral){ + //central trigger TBit 5 + triggerMaskJC |= (1<SetActiveTriggersJCorran( kCentralTriggerBitJCorran,"CentralTriggerBitJCorran"); + } + + if(((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler())) + ->IsEventSelected() & AliVEvent::kSemiCentral){ + //semi-central trigger TBit 6 + triggerMaskJC |= (1<SetActiveTriggersJCorran( kSemiCentralTriggerBitJCorran,"SemiCentralTriggerBitJCorran"); + } + + if(((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler())) + ->IsEventSelected() & AliVEvent::kFastOnly){ + //semi-central trigger TBit 6 + triggerMaskJC |= (1<SetActiveTriggersJCorran( kFastOnlyBitJCorran ,"FastOnlyBitJCorran"); + } + + if(((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler())) + ->IsEventSelected() & AliVEvent::kINT7){ + // minimum bias TBit 0 + triggerMaskJC |= (1<SetActiveTriggersJCorran( kINT7TriggerBitJCorran, "INT7TriggerBitJCorran"); + } + + return triggerMaskJC; +} + + +//______________________________________________________________________________ +void AliJFilter::ReadMCTracksFromESD(){ + //store MC information from AliStack + if(!MCEvent()) return; + AliStack *stack = MCEvent()->Stack(); + if(!stack) return; + Int_t np = MCEvent()->GetNumberOfTracks(); + + // AliGenEventHeader* genHeader = fMC->GenEventHeader(); + // AliGenPythiaEventHeader* pythiaGenHeader = dynamic_cast(genHeader); + // Double_t ptHard = 0; + // Double_t nTrials = 1; // Trials for MC trigger weigth for real data + // nTrials = pythiaGenHeader->Trials(); + // ptHard = pythiaGenHeader->GetPtHard(); + // Int_t nprim = stack->GetNtrack(); + + Long64_t ntrack = 0; + + for(Long64_t iTrack = 0; iTrack < np; iTrack++){ + AliMCParticle *track = (AliMCParticle*) MCEvent()->GetTrack(iTrack); + if(!track){ + Printf("ERROR: Could not receive track %d",(int) iTrack); + continue; + } + Bool_t isPrimary = stack->IsPhysicalPrimary(iTrack); + if(isPrimary){ + //create a new JMCTrack and fill the track info + AliJMCTrack *ctrack = new( (*fMCTrackList)[ntrack++] ) AliJMCTrack; + + TParticle *partStack = stack->Particle(iTrack); + Int_t pdg = partStack->GetPdgCode(); + + Char_t ch = (Char_t) partStack->GetPDG()->Charge(); + Int_t label = track->GetLabel(); + + ctrack->SetLabel(label); + ctrack->SetPdgCode(pdg); + ctrack->SetPxPyPzE( partStack->Px(), partStack->Py(), partStack->Pz(), partStack->Energy()); + ctrack->SetCharge(ch); + ctrack->SetFlag(AliJMCTrack::kPrimary, isPrimary); + + ctrack->SetProductionVertex(partStack->Vx(),partStack->Vy(),partStack->Vz()); + }// loop for al primary tracks + } +} + +//-------------------------------------------------------------------- +void AliJFilter::ReadMCTracksFromAOD(){ + //retreive MC particles from event //FKEFF// + if(!AODEvent()) return; TClonesArray *mcArray = (TClonesArray*) AODEvent()-> + FindListObject(AliAODMCParticle::StdBranchName()); + if(!mcArray){ + Printf("No MC particle branch found"); + return; + } + + Long64_t ntrack = 0; + Long64_t np = mcArray->GetEntriesFast(); + + for(Long64_t it = 0; it < np; it++) { + AliAODMCParticle *track = (AliAODMCParticle*) mcArray->At(it); + if(!track){ + Error("ReadEventAODMC", "Could not receive particle %d",(int) it); + continue; + } + bool isPrimary = track->IsPhysicalPrimary(); + if(isPrimary){ + //create a new JMCTrack and fill the track info + AliJMCTrack *ctrack = new ((*fMCTrackList)[ntrack++]) AliJMCTrack;; + + Int_t pdg = track->GetPdgCode(); + + Char_t ch = (Char_t) track->Charge(); + Int_t label = track->GetLabel(); + + ctrack->SetLabel(label); + ctrack->SetPdgCode(pdg); + ctrack->SetPxPyPzE( track->Px(), track->Py(), track->Pz(), track->E()); + ctrack->SetCharge(ch); + ctrack->SetFlag(AliJMCTrack::kPrimary, isPrimary); + + ctrack->SetProductionVertex(track->Xv(),track->Yv(),track->Zv()); + } + } + +} + + +//-------------------------------------------------------------------- +void AliJFilter::RemapMCLabels(){ + // remaps all MC labels to the new arrays + + Int_t i, j, label, mother0, mother1; + AliJTrack *track; + AliJPhoton *cluster; + // BS AliJCaloCell *cell; + AliJMCTrack *mctrack; + + // tracks + for( i = 0; i < fTrackList->GetEntries(); i++ ){ + track = (AliJTrack*)fTrackList->At( i ); + + track->SetLabel( fMcMap->At( track->GetLabel() )); + } + + // clusters + if( fAliJRunHeader->GetStoreEMCalInfo() ){ + for( i = 0; i < fPhotonList->GetEntries(); i++ ){ + cluster = (AliJPhoton*)fPhotonList->At( i ); + for( j = 0; j < cluster->GetNEMCLabel(); j++ ){ + label = cluster->GetEMCLabel( j ); + // no label clusters protection + if( label >= 0 ) + cluster->SetEMCLabel( j, fMcMap->At( label )); + } + } + + /* BS + // cells + for( i = 0; i < fCaloCellList->GetEntries(); i++ ){ + cell = (AliJCaloCell*)fCaloCellList->At( i ); + label = cell->GetMcLabel(); +// no label cells protection +if( label >= 0 ) +cell->SetMcLabel( fMcMap->At( cell->GetMcLabel() )); +} +*/ +} + +// MC particles +for( i = 0; i < fMCTrackList->GetEntries(); i++ ){ + mctrack = (AliJMCTrack*)fMCTrackList->At( i ); + + mother0 = mctrack->GetMother( 0 ); + mother1 = mctrack->GetMother( 1 ); + + if( mother0 >= 0 ) + mother0 = fMcMap->At( mother0 ); + if( mother1 >= 0 ) + mother1 = fMcMap->At( mother1 ); + + mctrack->SetMother( mother0, mother1 ); +} +} + +//-------------------------------------------------------------------- + + +void AliJFilter::PrintOut() const { + //AliJRunHeader * RunInfo = fAliJRunHeader; +} + +//******************************************** +// UTILS +//******************************************** +void AliJFilter::AddList(const char* aname, const char* cname, TClonesArray **obj, int nlist){ + *obj = new TClonesArray(cname, nlist); + (*obj)->SetName(aname); + (*obj)->SetOwner(); +} + diff --git a/PWGCF/Correlations/JCORRAN/AliJFilter.h b/PWGCF/Correlations/JCORRAN/AliJFilter.h new file mode 100644 index 00000000000..de6f046c6ca --- /dev/null +++ b/PWGCF/Correlations/JCORRAN/AliJFilter.h @@ -0,0 +1,222 @@ +// $Id: AliJFilter.h,v 1.5 2012/04/19 15:19:52 jkral Exp $ + +//______________________________________________________________________________ +// Analysis task for high pt particle correlations +// author: R.Diaz, J. Rak, D.J. Kim +// ALICE Group University of Jyvaskyla +// Finland +// +// Fill the analysis containers for ESD or AOD +// Note: Adapted for AliAnalysisTaskSE +////////////////////////////////////////////////////////////////////////////// + +#ifndef ALIJFILTER_H +#define ALIJFILTER_H + +#include "TNamed.h" +#include "AliJRunHeader.h" +#include "AliESDEvent.h" +#include "AliAODEvent.h" +#include "AliAnalysisTaskSE.h" +#include + +#include +#include + +//============================================================== + +#ifndef AliJMaxDimBuffer +#define AliJMaxDimBuffer +const int kMaxDimBuffer = 300;//max length of a line read to a buffe +#endif + +class AliJEventHeader; +class AliJRunHeader; +class AliJTrack; +class AliAnalysisTaskSE; + +class TH1D; +class TH2D; +class TNtuple; +class TList; +class TTree; +class TFormula; +class TRefArray; +class TArrayI; + +class AliMCEvent; +class AliESDEvent; +class AliESDtrack; +class AliAODEvent; +class AliAODTrack; +class AliESDtrackCuts; +class AliESDVZERO; +class AliESDCentrality; +class AliVCluster; +class AliVCaloCells; +class AliVEvent; + +class AliEMCALGeometry; +class AliEMCALGeoUtils; +class AliEMCALRecoUtils; +class AliPHOSGeoUtils; + +class AliMCEvent; +class AliAnalysisFilter; + +class AliESDTZERO; +class AliESDZDC; +class AliPIDResponse; +class AliPIDResponse; +class AliPIDCombined; +class AliESDTZERO; +class AliAnalysisUtils; + +using namespace std; + +class AliJFilter : public TNamed { + + public: + AliJFilter(); + AliJFilter(const char *name, AliAnalysisTaskSE *task); + AliJFilter(const AliJFilter& ap); + AliJFilter& operator = (const AliJFilter& ap); + virtual ~AliJFilter(); + + // methods to fill from AliAnalysisTaskSE + virtual void UserCreateOutputObjects(); + virtual void Init(); + virtual void LocalInit() { Init(); } + virtual void UserExec(Option_t *option); + virtual void Terminate(Option_t * opt = ""); + + + void SetTrackFilter( AliAnalysisFilter * filter ){ fESDFilter = filter; } + bool GetEventSuccess() const { return fEventSuccess; } + //are ESDs from real exp or MonteCarlo + // AliEMCALGeoUtils* GetEMCALGeoUtils (bool doDelete=kFALSE); + void SetClusterThreshold(double t) { fClusterThreshold = t; } + void SetTrackThreshold(double t) { fTrackThreshold = t; } + void SetMyTask( AliAnalysisTaskSE *t ) { fMyTask = t; } + TClonesArray *GetTrackList() const { return fTrackList; } + TClonesArray *GetPhotonList() const { return fPhotonList; } + TClonesArray *GetCaloCellList() const { return fCaloCellList; } + TClonesArray *GetMCTrackList() const { return fMCTrackList; } + TClonesArray *GetHeaderList() const { return fHeaderList; } + TList *GetRunInfoList() const { return fRunInfoList; } + + AliESDVZERO *GetESDVZERO() const { return fVZEROData; } + AliESDTZERO *GetESDTZERO() const { return fTZEROData; } + // AliESDFMD* fFMDData; + AliESDZDC* GetESDZDC() const { return fZDCData; } + + TClonesArray **GetTrackListP() { return &fTrackList; } + TClonesArray **GetPhotonListP() { return &fPhotonList; } + TClonesArray **GetCaloCellListP() { return &fCaloCellList; } + TClonesArray **GetMCTrackListP() { return &fMCTrackList; } + TClonesArray **GetHeaderListP() { return &fHeaderList; } + TList **GetRunInfoListP() { return &fRunInfoList; } + + AliESDVZERO** GetESDVZEROP() { return &fVZEROData; } + AliESDTZERO** GetESDTZEROP() { return &fTZEROData; } + // AliESDFMD* fFMDData; + AliESDZDC** GetESDZDCP() { return &fZDCData; } + + Bool_t GetStoreEventPlaneSource(){ return fAliJRunHeader->GetStoreEventPlaneSource(); } + Bool_t GetStoreEMCalInfo(){ return fAliJRunHeader->GetStoreEMCalInfo(); } + AliESDEvent * ESDEvent(){ return FromESD()? dynamic_cast(Event()):NULL;} + AliAODEvent * AODEvent(){ return FromAOD()? dynamic_cast(Event()):NULL;} + AliVEvent * Event(){ return fMyTask->InputEvent(); } + AliMCEvent * MCEvent(){ return IsMC()?fMyTask->MCEvent():NULL; } + + Bool_t IsMC(){ return fAliJRunHeader->IsMC(); } + Bool_t FromESD(){ return fAliJRunHeader->FromESD(); } + Bool_t FromAOD(){ return fAliJRunHeader->FromAOD(); } + + AliJRunHeader* GetAliJRunHeader() const { return fAliJRunHeader; } + void SetAliJRunHeader( AliJRunHeader* header ){ fAliJRunHeader=header; } + private: + + Int_t DebugLevel(){ return fMyTask->DebugLevel(); } + inline void DEBUG(int level, int type, TString msg1, TString msg2=""){ + if(DebugLevel()>level) std::cout< fIsRealOrMC; // flags if the input are real (0) ESDs or MonteCarlo ESDs (1) + TString fActiveTriggers[kRangeTriggerTableAlice]; // alice table mapping trigger bit to trigger name + TString fTriggerTableJCorran[kRangeTriggerTableJCorran]; // JCorran trigger table TBit 0 =MinBias + Bool_t fStoreEventPlaneSource; // store event plane + TString fOADBPath; // oadb path + TRefArray *fCaloClustersArr; //! calo cluster array + Double_t fClusterThreshold; // for event tropping + Double_t fTrackThreshold; // for event tropping + Bool_t fEventSuccess; //! if filter was successful with current event + + TArrayI *fMcMap; //! mc index map + + // jcorran output objects + TClonesArray * fTrackList; //! list of charged track objects + TClonesArray * fMCTrackList; //! list of charged track objects + TClonesArray * fPhotonList; //! list of photons objects + TClonesArray * fCaloCellList; //! list of calo cells + TClonesArray * fHeaderList; //! event details + TList * fRunInfoList; //! run details + AliPIDResponse *fPIDResponse; //! PID response object + AliPIDCombined *fPIDCombined; //! PID response object + + AliESDVZERO* fVZEROData; //! + AliESDTZERO* fTZEROData; //! + // AliESDFMD* fFMDData; + AliESDZDC* fZDCData; //! + + vector fEMCLabels; //! EMCal hit labels + vector fEMCTreeLabels; //! cascades for EMCal hits + + AliJRunHeader* fAliJRunHeader; //! run details (mg field, trigger mask,etc...) + AliEMCALGeometry * fEMCALGeometry; //! emcal geometry + AliEMCALRecoUtils * fEMCALRecoUtils; //! reco utils + AliPHOSGeoUtils * fPHOSGeom; //! phos geometry matrix + AliAnalysisUtils *fAnaUtils; //! analysis utils ALICE + AliAnalysisTaskSE *fMyTask; //! task pointer + + + ClassDef(AliJFilter, 1); +}; +#endif // AliJFilter_H diff --git a/PWGCF/Correlations/JCORRAN/AliJHistManager.cxx b/PWGCF/Correlations/JCORRAN/AliJHistManager.cxx new file mode 100644 index 00000000000..09b603ea8ca --- /dev/null +++ b/PWGCF/Correlations/JCORRAN/AliJHistManager.cxx @@ -0,0 +1,879 @@ +#include "AliJHistManager.h" +using namespace std; +////////////////////////////////////////////////////// +// AliJBin +////////////////////////////////////////////////////// + +AliJNamed::AliJNamed(TString name, TString title, TString opt, int mode) : + fName(name), + fTitle(title), + fOption(opt), + fMode(mode) +{ + // constructor +} + +AliJNamed::~AliJNamed(){ + // virtual destructor for base class +} + +TString AliJNamed::GetOption(TString key){ + TPMERegexp a("&"+key+"=?([^&]*)","i"); + int nMatch = a.Match(fOption); + if( nMatch < 2 ) return UndefinedOption(); + return a[1]; +} +void AliJNamed::SetOption( TString key, TString value){ + TPMERegexp a("&"+key+"=?[^&]*","i"); + int nMatch = a.Match(fOption); + TString newOpt = "&"+key +( value.Length()?"="+value:""); + if( value == UndefinedOption() ) newOpt = ""; + if( nMatch < 1 ) fOption += newOpt; + else fOption.ReplaceAll( a[0], newOpt ); +} +void AliJNamed::RemoveOption( TString key ){ + SetOption( key, UndefinedOption() ); +} +TString AliJNamed::UndefinedOption(){ + //static TString undefinedOption = "Undefined"; + //return undefinedOption; + return "Undefined"; +} + +////////////////////////////////////////////////////// +// AliJBin +////////////////////////////////////////////////////// + +//_____________________________________________________ +AliJBin::AliJBin(): + AliJNamed("AliJBin","%.2f-%2.f", "&Mode=Range", kRange), + fBinD(0), + fBinStr(0), + fIsFixedBin(false), + fIndexName("H"), + fHMG(NULL) +{;} +//_____________________________________________________ +AliJBin::AliJBin(TString config, AliJHistManager * hmg): + AliJNamed("AliJBin","%.2f-%2.f", "&Mode=Range", kRange), + fBinD(0), + fBinStr(0), + fIsFixedBin(false), + fIndexName("H"), + fHMG(NULL) +{ + cout<< config< t = Tokenize(config, " \t,"); + TString type = t[0]; + SetName( t[1] ); + fIndexName = t[2] ; + SetTitle( t[3] ); + fTitle.ReplaceAll("\"","" ); + SetFullOption( t[4] ); + fMode = GetMode( GetOption("mode") ); + AddToManager( hmg ); + TString s; + for( int i=5;iAdd(this); +} +//_____________________________________________________ +AliJBin & AliJBin::Set( TString name, TString iname, TString title, int mode){ + SetNameTitle( name, title ); + fIndexName = iname; + fMode = mode; + SetOption("mode",GetModeString(mode)); + return *this; +} +//_____________________________________________________ +TString AliJBin::GetModeString(int i){ + static TString mode[] = { "Single","Range","String" }; + if( i<0 || i>2 ) return ""; + return mode[i]; +} +int AliJBin::GetMode( TString mode ){ + for( int i=0;iGetNrows();i++ ) AddBin( (v->GetMatrixArray())[i] );FixBin(); + return *this; +} +//_____________________________________________________ +AliJBin& AliJBin::SetBin(const TString v){ + std::vector ar = Tokenize( v, "\t ,"); + for( UInt_t i=0; i Size() ) return ""; + if( fMode == kSingle ) + return TString(Form(fTitle.Data(), fBinD[i] )); + if( fMode == kRange ) + return TString(Form(fTitle.Data(), fBinD[i], fBinD[i+1])); + if( fMode == kString ) + return TString( Form(fTitle.Data(), fBinStr[i].Data()) ); + JERROR( TString("Bad Mode of AliJBin type ") + char(fMode) + " in " + fName+ "!!!" ); + return ""; +} +//_____________________________________________________ +TString AliJBin::GetString(){ + SetOption( "mode",GetModeString(fMode) ); + return "AliJBin\t"+fName+"\t"+fIndexName+"\t\""+fTitle+"\""+"\t"+fOption+"\t"+Join(fBinStr," "); + +} +//_____________________________________________________ +void AliJBin::Print(){ + std::cout<<"*"+GetString()<GetItem(); + if( !item ){ + BuildItem() ; + item = fAlg->GetItem(); + } + return item; +} +//_____________________________________________________ +void* AliJArrayBase::GetSingleItem(){ + if(fMode == kSingle )return GetItem(); + JERROR("This is not single array"); + return NULL; +} +//_____________________________________________________ +void AliJArrayBase::FixBin(){ + if( Dimension() == 0 ){ + AddDim(1);SetOption("Single"); + fMode = kSingle; + if( HasOption("dir","default")) RemoveOption("dir"); + } + ClearIndex(); + fAlg = new AliJArrayAlgorithmSimple(this); + fArraySize = fAlg->BuildArray(); +} +//_____________________________________________________ +int AliJArrayBase::Index(int d){ + if( OutOfDim(d) ) JERROR("Wrong Dim"); + return fIndex[d]; +} +void AliJArrayBase::SetIndex(int i, int d ){ + if( OutOfSize( i, d ) ) JERROR( "Wrong Index" ); + fIndex[d] = i; +} + +void AliJArrayBase::InitIterator(){ fAlg->InitIterator(); } +bool AliJArrayBase::Next(void *& item){ return fAlg->Next(item); } + + +////////////////////////////////////////////////////// +// AliJArrayAlgorithm +////////////////////////////////////////////////////// + +//_____________________________________________________ +AliJArrayAlgorithm::AliJArrayAlgorithm(AliJArrayBase * cmd): + fCMD(cmd) +{ + // constructor +} +//_____________________________________________________ +AliJArrayAlgorithm::~AliJArrayAlgorithm(){ + // destructor +} + +//_____________________________________________________ +AliJArrayAlgorithm::AliJArrayAlgorithm(const AliJArrayAlgorithm& obj) : + fCMD(obj.fCMD) +{ + // copy constructor TODO: proper handling of pointer data members +} + +//_____________________________________________________ +AliJArrayAlgorithm& AliJArrayAlgorithm::operator=(const AliJArrayAlgorithm& obj) +{ + // assignment operator + if(this != &obj){ + *fCMD = *(obj.fCMD); + } + return *this; +} + +////////////////////////////////////////////////////// +// AliJArrayAlgorithmSimple +////////////////////////////////////////////////////// + +//_____________________________________________________ +AliJArrayAlgorithmSimple::AliJArrayAlgorithmSimple(AliJArrayBase * cmd): + AliJArrayAlgorithm(cmd), + fDimFactor(0), + fArray(NULL), + fPos(0) +{ + // constructor +} +//_____________________________________________________ +AliJArrayAlgorithmSimple::~AliJArrayAlgorithmSimple(){ + // Dimension, GetEntries, SizeOf + if( fArray ) delete [] (void**)fArray; +} + +//_____________________________________________________ +AliJArrayAlgorithmSimple::AliJArrayAlgorithmSimple(const AliJArrayAlgorithmSimple& obj) : + AliJArrayAlgorithm(obj.fCMD), + fDimFactor(obj.fDimFactor), + fArray(obj.fArray), + fPos(obj.fPos) +{ + // copy constructor TODO: proper handling of pointer data members +} + +//_____________________________________________________ +AliJArrayAlgorithmSimple& AliJArrayAlgorithmSimple::operator=(const AliJArrayAlgorithmSimple& obj) +{ + // assignment operator TODO: proper implementation + if(this != &obj){ + *fCMD = *(obj.fCMD); + } + return *this; +} +//_____________________________________________________ +int AliJArrayAlgorithmSimple::BuildArray(){ + fDimFactor.resize( Dimension(), 1 ); + for( int i=Dimension()-2; i>=0; i-- ){ + fDimFactor[i] = fDimFactor[i+1] * SizeOf(i+1); + } // TODO split to BuildArray and lazyArray in GetItem + int arraySize = fDimFactor[0] * SizeOf(0); + fArray = new void*[arraySize]; + for( int i=0;iSetIndex( n1 , i ); + n-=n1*fDimFactor[i]; + } +} +void * AliJArrayAlgorithmSimple::GetItem(){ + return fArray[GlobalIndex()]; + +} +void AliJArrayAlgorithmSimple::SetItem(void * item){ + fArray[GlobalIndex()] = item; +} + + +////////////////////////////////////////////////////// +// AliJTH1 +////////////////////////////////////////////////////// +//_____________________________________________________ +AliJTH1::AliJTH1(): + fDirectory(NULL), + fSubDirectory(NULL), + fHMG(NULL), + fTemplate(NULL), + fBins(0) +{ + // default constructor + fName="AliJTH1"; +} + +//_____________________________________________________ +AliJTH1::AliJTH1(TString config, AliJHistManager * hmg): + fDirectory(NULL), + fSubDirectory(NULL), + fHMG(NULL), + fTemplate(NULL), + fBins(0) +{ + // constructor + std::vector t = Tokenize(config, " \t,"); + TString type = t[0]; + SetName( t[1] ); + SetTitle( t[2] ); + fTitle.ReplaceAll("\"",""); + SetFullOption( t[3] ); + fMode = HasOption("mode","Single")?kSingle:kNormal; + AddToManager( hmg ); + TString s; + for( int i=4;iAliJArrayBase::AddDim( bin->Size() ); + fBins.resize( ndim, NULL ); + fBins[ndim-1] = bin; + return ndim; +} + +int AliJTH1::AddDim(TString v) { + if( v == "END" ) { FixBin(); } + else{ + std::vector o= Tokenize(v, "\t ,"); + for( UInt_t i=0;iGetBin(s); + if( b ) this->AddDim(b); + else {JERROR("Wrong terminator of Array : \"" + s+"\" in " + fName ); } + } + } + return Dimension(); +} +//_____________________________________________________ +Int_t AliJTH1::Write(){ + TDirectory *owd = (TDirectory*) gDirectory; + InitIterator(); + void * item; + if( fSubDirectory ) fSubDirectory->cd(); + //else fDirectory->cd(); + while( Next(item) ){ + if( !item ) continue; + TH1 * obj = static_cast(item); + obj->Write( ); + //obj->Write( 0, TObject::kOverwrite ); + } + if( owd != gDirectory ) owd->cd(); + return 0; +} +//_____________________________________________________ +TString AliJTH1::GetString( ){ + TString s = Form( "%s\t%s\t\"%s\"\t%s\t", + ClassName(), fName.Data(), fTitle.Data(), fOption.Data() ); + for( int i=0;i i && fBins[i] != NULL ){ + s+= " "+fBins[i]->GetName(); + }else{ + s+= TString(" ")+Form("%d", SizeOf(i)); + } + } + return s; +} +//_____________________________________________________ +void AliJTH1::FixBin(){ + this->AliJArrayBase::FixBin(); + + if(!fHMG) { + AddToManager( AliJHistManager::CurrentManager() ); + } + if(!fDirectory) fDirectory = fHMG->GetDirectory(); +} + +//_____________________________________________________ +void AliJTH1::AddToManager(AliJHistManager *hmg){ + if(fHMG) return; // TODO handle error + fHMG = hmg; + hmg->Add(this); +} +//_____________________________________________________ +void AliJTH1::Print(){ + std::cout<<"*"<Clone(); + fTemplate->Sumw2(); + fTemplate->SetDirectory(0); + fName = h->GetName(); + fTitle = h->GetTitle(); +} +//_____________________________________________________ +TString AliJTH1::BuildName(){ + TString name = fName; + if( !HasOption("Single") ) + for( int i=0;i i && fBins[i] != NULL)?fBins[i]->GetIndexName():"H") + +Form("%02d",Index(i)); + } + return name; +} +//_____________________________________________________ +TString AliJTH1::BuildTitle(){ + TString title = fTitle; + for( int i=0;i i && fBins[i] != NULL)?" "+fBins[i]->BuildTitle(i):"") + +Form("%02d",Index(i)); + return title; +} +//_____________________________________________________ +void * AliJTH1::BuildItem(){ + TDirectory * owd = (TDirectory*) gDirectory; + gROOT->cd(); + TString name = BuildName(); + TH1 * item = NULL; + if( !fSubDirectory ){ + if( !HasOption("dir") ) { + fSubDirectory = fDirectory; + } + else { + fSubDirectory = fDirectory->GetDirectory(fName); + if( !fSubDirectory && !IsLoadMode() ){ + fSubDirectory = fDirectory->mkdir(fName); + } + } + } + if( IsLoadMode() ){ + //if( fSubDirectory ) JDEBUG(2, fSubDirectory->GetName() ); + if( fSubDirectory ) + item = dynamic_cast(fSubDirectory->Get( name )); + if( !item ){ + void ** rawItem = fAlg->GetRawItem(); + InitIterator(); + void * tmp; + while( Next(tmp) ){ + item = (TH1*)fSubDirectory->Get(BuildName()); + if(item ) break; + } + if( item ) { + item = dynamic_cast((static_cast(item))->Clone(name)); + item->Reset(); + item->SetTitle( BuildTitle() ); + item->SetDirectory(0); + *rawItem = (void*)item; + } + } + if( !item ){ JERROR("Any of "+fName+" doesn't exists. I need at least one");} + } + else{ // Gen Mode + TH1 * titem = NULL; + if(fNGenerated == 0 ) { + titem = fTemplate; + } + else titem =(TH1*) fTemplate->Clone(); + titem->SetDirectory( fSubDirectory ); + titem->Reset(); + titem->SetName( BuildName() ); + titem->SetTitle( BuildTitle() ); + fNGenerated++; + item=titem; + } + if( item ) fAlg->SetItem(item); + owd->cd(); + return (void*)item; +} +//_____________________________________________________ +bool AliJTH1::IsLoadMode(){ + return fHMG->IsLoadMode(); +} + + +////////////////////////////////////////////////////////////////////////// +// // +// AliJTH1Derived // +// // +////////////////////////////////////////////////////////////////////////// +template< typename T> +AliJTH1Derived::AliJTH1Derived(): + AliJTH1(), fPlayer(this) +{ +} +template< typename T> +AliJTH1Derived::~AliJTH1Derived(){ +} + + + + +////////////////////////////////////////////////////////////////////////// +// // +// AliJHistManager // +// // +// Array Base Class // +// // +////////////////////////////////////////////////////////////////////////// +AliJHistManager::AliJHistManager(TString name): + AliJNamed(name,"","",0), + fIsLoadMode(false), + fDirectory(gDirectory), + fConfigStr(), + fBin(0), + fHist(0), + fManager(0), + fBinNames(0), + fBinConfigs(0), + fHistNames(0), + fHistConfigs(0) +{ + // constructor + //CurrentManager(this); + fDirectory = gDirectory; +} + +//_____________________________________________________ +AliJHistManager::AliJHistManager(const AliJHistManager& obj) : + AliJNamed(obj.fName,obj.fTitle,obj.fOption,obj.fMode), + fIsLoadMode(obj.fIsLoadMode), + fDirectory(obj.fDirectory), + fConfigStr(obj.fConfigStr), + fBin(obj.fBin), + fHist(obj.fHist), + fManager(obj.fManager), + fBinNames(obj.fBinNames), + fBinConfigs(obj.fBinConfigs), + fHistNames(obj.fHistNames), + fHistConfigs(obj.fHistConfigs) +{ + // copy constructor TODO: proper handling of pointer data members +} + +//_____________________________________________________ +AliJHistManager& AliJHistManager::operator=(const AliJHistManager& obj) +{ + // assignment operator + if(this != &obj){ + // TODO: proper implementation + } + return *this; +} + +AliJHistManager* AliJHistManager::GlobalManager(){ + static AliJHistManager* singleton = new AliJHistManager("GlobalHistManager"); + return singleton; +} + +AliJHistManager* AliJHistManager::CurrentManager( AliJHistManager * hmg){ + static AliJHistManager* currentManager = AliJHistManager::GlobalManager(); + if( hmg ) currentManager = hmg; + return currentManager; +} + +AliJBin* AliJHistManager::GetBuiltBin(TString s ){ + for( int i=0;iGetName() == s ) return fBin[i]; + return NULL; +} +AliJBin* AliJHistManager::GetBin(TString s ){ + AliJBin* h = GetBuiltBin(s); + if(h) return h; + for( int i=0;iGetName() == s ) return fHist[i]; + return NULL; +} +AliJTH1 * AliJHistManager::GetTH1(TString s ){ + AliJTH1 * h = GetBuiltTH1(s); + if( h ) return h; + for( int i=0;iGetName() ) ) return; // TODO error handle + fBin.push_back( o ); +} +void AliJHistManager::Add(AliJTH1 *o ){ + if( !o ) return; + if( GetBuiltTH1( o->GetName() ) ) return; // TODO error handle + fHist.push_back( o ); +} +void AliJHistManager::Print(){ + if( IsLoadMode() ) { + cout<Print(); + } + cout<Print(); + } +} +void AliJHistManager::Write(){ + for( int i=0;iWrite(); +} + +void AliJHistManager::WriteConfig(){ + TDirectory *owd = gDirectory; + TDirectory * fHistConfigDir = gDirectory->mkdir("HistManager"); + fHistConfigDir->cd(); + TObjString * config = new TObjString(GetString().Data()); + config->Write("Config"); + owd->cd(); +} + +int AliJHistManager::LoadConfig(){ + SetLoadMode(true); + TObjString *strobj = (TObjString*)fDirectory->Get("HistManager/Config"); + if( !strobj ) return 0; //TODO + TString config = strobj->String(); + fConfigStr = config; + vector lines = Tokenize(config, "\n"); + cout<< Form("Read Config.%d objects found\n", (int)lines.size() ); + for( UInt_t i=0;i < lines.size();i++ ){ + TString line = lines.at(i); + std::vector t = Tokenize(line, " \t,"); + if(line.BeginsWith("AliJBin")) { + fBinNames.push_back( t[1] ); + fBinConfigs.push_back( line ); + }else if( line.BeginsWith("AliJ")){ + fHistNames.push_back( t[1] ); + fHistConfigs.push_back( line ); + } + } + return 1; +} + + +////////////////////////////////////////////////////// +// Utils +////////////////////////////////////////////////////// +vector Tokenize( TString s, TString d, int quote ){ + //int nd = d.Length(); + bool flagBeforeToken = 0; + bool inQuote = 0; + TString tok=""; + vector toks; + s += d[0]; + for( int i=0;i0){ + toks.push_back(tok); + tok.Clear(); + flagBeforeToken = 1; + } + }else{ + tok+=s[i]; + flagBeforeToken = 0; + } + } + return toks; +} + + +TString Join( vector& ss , TString del){ + if( ss.size() < 1 ) return ""; + TString s = ss[0]; + for( UInt_t i=1;iy ); } +#include + +void testAliJArray(){ + cout<<"START"<Fill(1); + fHMG->Print(); + + f->Write(); + fHMG->Write(); + fHMG->WriteConfig(); + +} diff --git a/PWGCF/Correlations/JCORRAN/AliJHistManager.h b/PWGCF/Correlations/JCORRAN/AliJHistManager.h new file mode 100644 index 00000000000..3d6a74518f7 --- /dev/null +++ b/PWGCF/Correlations/JCORRAN/AliJHistManager.h @@ -0,0 +1,423 @@ +// @(#)utils:$Id$ +// Author: Beonsu Chang 26/12/94 +#ifndef UTILS_ALIJARRAY_H +#define UTILS_ALIJARRAY_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define JERROR(x) {std::cout<<"!!! JERROR : "<Exit(100); } +#define JDEBUG(x,y) if(x<100){std::cout<<"JDEBUG : "<<#x<<" : "<<(y)<<" "<<__LINE__<<" "<<__FILE__<<" "< class AliJTH1Derived; +template class AliJTH1DerivedPlayer; + +////////////////////////////////////////////////////// +// Utils +////////////////////////////////////////////////////// +std::vector Tokenize( TString s, TString d, int quote=1 ); +TString Join( std::vector& ss , TString del=" "); +bool OutOf( int, int, int ); + +typedef std::vector ArrayInt; +typedef std::vector ArrayDouble; +//typedef AliJArray ArrayVoid*; + +////////////////////////////////////////////////////////////////////////// +// // +// AliJNamed // +// // +// +// // +////////////////////////////////////////////////////////////////////////// +//________________________________________________________________________ +class AliJNamed{ + public: + AliJNamed( TString name, TString title, TString opt, int mode ); + virtual ~AliJNamed(); + TString GetName(){ return fName; } + TString GetTitle(){ return fTitle; } + TString GetOption(){ return fOption; } + TString GetOption(TString key); + bool HasOption(TString key){ return GetOption(key)!=UndefinedOption(); } + bool HasOption(TString key, TString val){ return GetOption(key)==val; } // TODO sensitive? + void SetName( const char * s ) { fName=s; } + void SetTitle( const char * s ) { fTitle=s; } + void SetNameTitle( TString n, TString t ){ SetName(n);SetTitle(t); } + void SetFullOption( const char * s ) { fOption=s; } + void SetOption( TString key, TString value="" ); + void RemoveOption( TString key ); // TODO + //void SetOptionWithString( TString s );// TODO + static TString UndefinedOption(); + protected: + TString fName; + TString fTitle; + TString fOption; + int fMode; +}; + +////////////////////////////////////////////////////////////////////////// +// // +// AliJBin // +// // +// +// // +////////////////////////////////////////////////////////////////////////// +//________________________________________________________________________ +class AliJBin : public AliJNamed { + public: + enum { kSingle, kRange, kString , kNMode}; + AliJBin(); + AliJBin(TString config, AliJHistManager * hmg); + AliJBin(const AliJBin& obj); + AliJBin& operator=(const AliJBin& obj); + AliJBin & Set( TString name, TString iname, TString Title, int mode=kRange); + void AddToManager( AliJHistManager* hmg ); + AliJBin & SetBin( const int n, const float * v ); + AliJBin & SetBin( const int n, const double * v ); + AliJBin & SetBin( TVector * v ); + AliJBin & SetBin( const TString v ); + AliJBin & SetBin( const int n ); + + double GetMin(){ return fBinD[0]; } + double GetMax(){ return fBinD[RawSize()-1]; } + + TString BuildTitle( int i ); + int RawSize(){ return fBinD.size(); } + int Size(){ return fMode==kRange?fBinD.size()-1:fBinD.size(); } + double At(int i){ return fBinD[i]; } + TString GetIndexName(){ return fIndexName; } + + void Print(); + TString GetString(); + + operator int(){ return Size(); } + + static TString GetModeString(int i); + static int GetMode( TString mode ); + private: + void AddBin( const TString & v ); + void AddBin( float v ); + virtual void FixBin(); + + std::vector fBinD; + std::vector fBinStr; + bool fIsFixedBin; + TString fIndexName; + AliJHistManager * fHMG; +}; + + + +////////////////////////////////////////////////////////////////////////// +// // +// AliJArrayBase // +// // +// Array Base Class // +// // +////////////////////////////////////////////////////////////////////////// + +//________________________________________________________________________ +class AliJArrayBase : public AliJNamed{ + public: + enum { kNormal, kSingle }; + virtual ~AliJArrayBase(); + AliJArrayBase& operator=(const AliJArrayBase& obj); + + int AddDim( int i){ fDim.push_back(i);return fDim.size();} + int Dimension(){ return fDim.size(); } + int GetEntries(){ return fArraySize; } + int SizeOf(int i) { return fDim.at(i); } + + ArrayInt& Index(){ return fIndex; } + int Index( int d ); + void SetIndex( int i, int d ); + void ClearIndex(){ fIndex.clear();fIndex.resize( Dimension(), 0 ); } + + void * GetItem(); + void * GetSingleItem(); + + ///void LockBin(bool is=true){}//TODO + //bool IsBinLocked(){ return fIsBinLocked; } + + virtual void FixBin(); + bool IsBinFixed(){ return fIsBinFixed; } + + bool OutOfDim( int d ){ return OutOf( d, 0, Dimension()-1 ); } + bool OutOfSize( int i, int d ){ return OutOfDim(d) || OutOf( i, 0, SizeOf(d)-1); } + + + // Virtual + virtual void * BuildItem()=0; + virtual TString BuildName()=0; + virtual TString BuildTitle()=0; + virtual void Print()=0; + virtual TString GetString()=0; + + //int Resize( int size, int dim=-1 ); // NextStep + void InitIterator(); + bool Next(void *& item ); + + protected: + AliJArrayBase(); // Prevent direct creation of AliJArrayBase + AliJArrayBase(const AliJArrayBase& obj); + + ArrayInt fDim; // Comment test + ArrayInt fIndex; /// Comment test + int fArraySize; /// Comment test3 + int fNGenerated; + bool fIsBinFixed; + bool fIsBinLocked; + AliJArrayAlgorithm * fAlg; + friend class AliJArrayAlgorithm; +}; + + +//________________________________________________________________________ +class AliJArrayAlgorithm { + public: + AliJArrayAlgorithm(AliJArrayBase * cmd); //TODO Move to private + AliJArrayAlgorithm(const AliJArrayAlgorithm& obj); + AliJArrayAlgorithm& operator=(const AliJArrayAlgorithm& obj); + virtual ~AliJArrayAlgorithm(); + int Dimension(){ return fCMD->Dimension(); } + int SizeOf(int i){ return fCMD->SizeOf(i); } + int GetEntries(){ return fCMD->GetEntries(); } + int Index(int i){ return fCMD->Index(i); } + virtual int BuildArray()=0; + virtual void * GetItem()=0; + virtual void SetItem(void * item)=0; + virtual void InitIterator()=0; + virtual bool Next(void *& item) = 0; + virtual void ** GetRawItem()=0; + virtual void * GetPosition()=0; + virtual bool IsCurrentPosition(void * pos)=0; + virtual void SetPosition(void * pos )=0; + virtual void DeletePosition( void * pos ) =0; + protected: + AliJArrayBase * fCMD; +}; + +//________________________________________________________________________ +class AliJArrayAlgorithmSimple : public AliJArrayAlgorithm { + public: + AliJArrayAlgorithmSimple( AliJArrayBase * cmd); + AliJArrayAlgorithmSimple(const AliJArrayAlgorithmSimple& obj); + AliJArrayAlgorithmSimple& operator=(const AliJArrayAlgorithmSimple& obj); + virtual ~AliJArrayAlgorithmSimple(); + virtual int BuildArray(); + int GlobalIndex(); + void ReverseIndex(int iG ); + virtual void * GetItem(); + virtual void SetItem(void * item); + virtual void InitIterator(){ fPos = 0; } + virtual void ** GetRawItem(){ return &fArray[GlobalIndex()]; } + virtual bool Next(void *& item){ + item = fPos (new int( fPos )); } + virtual bool IsCurrentPosition(void * pos){ return *static_cast(pos)==fPos; } + virtual void SetPosition(void *pos){ fPos=*static_cast(pos);ReverseIndex(fPos); } + virtual void DeletePosition(void *pos){ delete static_cast(pos); } + private: + ArrayInt fDimFactor; + void **fArray; + int fPos; +}; + + +////////////////////////////////////////////////////////////////////////// +// // +// AliJTH1 // +// // +// Array Base Class // +// // +////////////////////////////////////////////////////////////////////////// +//________________________________________________________________________ +class AliJTH1 : public AliJArrayBase{ + public: + AliJTH1(); + AliJTH1(TString config, AliJHistManager * hmg); + AliJTH1(const AliJTH1& obj); + AliJTH1& operator=(const AliJTH1& obj); + virtual ~AliJTH1(); + + int AddDim( int i){ fDim.push_back(i);return fDim.size();} + int AddDim( AliJBin * bin ); + int AddDim( TString v); + void AddToManager( AliJHistManager * hmg ); + + // Virtual from AliJArrayBase + virtual void * BuildItem() ; + virtual TString GetString(); + virtual void Print(); + virtual void FixBin(); + // Virtual from this + virtual Int_t Write(); + //virtual Int_t WriteAll(); + virtual const char * ClassName(){ return "AliJTH1"; } + + // Not Virtual + virtual TString BuildName(); + virtual TString BuildTitle(); + bool IsLoadMode(); + void SetTemplate(TH1* h); + + + + protected: + + TDirectory *fDirectory; + TDirectory *fSubDirectory; + AliJHistManager *fHMG; + TH1 *fTemplate; + std::vector fBins; +}; +////////////////////////////////////////////////////////////////////////// +// // +// AliJTH1Derived // +// // +// Array Base Class // +// // +////////////////////////////////////////////////////////////////////////// +template< typename T > +class AliJTH1Derived : public AliJTH1 { + protected: + public: + AliJTH1Derived(); + AliJTH1Derived(TString config, AliJHistManager *hmg): + AliJTH1(config, hmg),fPlayer(this){} + virtual ~AliJTH1Derived(); + + //AliJTH1DerivedPlayer & operator[](int i){ fPlayer.Init();return fPlayer[i]; } + // AliJTH1DerivedPlayer & operator[](int i){ fPlayer.Init();fPlayer[i];return fPlayer; } + AliJTH1DerivedPlayer & operator[](int i){ fPlayer.Init();fPlayer[i];return fPlayer; } + T * operator->(){ return static_cast(GetSingleItem()); } + operator T*(){ return static_cast(GetSingleItem()); } + // Virtual from AliJArrayBase + + // Virtual from AliJTH1 + virtual const char * ClassName(){ return Form("AliJ%s",T::Class()->GetName()); } + + AliJTH1Derived& operator<<(int i){ AddDim(i);return *this; } + AliJTH1Derived& operator<<(AliJBin& v){ AddDim(&v);return *this; } + AliJTH1Derived& operator<<(TString v){ AddDim(v);return *this; } + AliJTH1Derived& operator<<(T v){ SetTemplate(&v);return *this; } + protected: + AliJTH1DerivedPlayer fPlayer; + +}; + + +////////////////////////////////////////////////////////////////////////// +// AliJTH1DerivedPlayer // +////////////////////////////////////////////////////////////////////////// +template< typename T> +class AliJTH1DerivedPlayer { + public: + AliJTH1DerivedPlayer( AliJTH1Derived * cmd ):fLevel(0),fCMD(cmd){}; + AliJTH1DerivedPlayer& operator[](int i){ + if( fLevel > fCMD->Dimension() ) { JERROR("Exceed Dimension"); } + if( OutOf( i, 0, fCMD->SizeOf(fLevel)-1) ){ JERROR(Form("wrong Index %d of %dth in ",i, fLevel)+fCMD->GetName()); } + fCMD->SetIndex(i, fLevel++); + return *this; + } + void Init(){ fLevel=0;fCMD->ClearIndex(); } + T* operator->(){ return static_cast(fCMD->GetItem()); } + operator T*(){ return static_cast(fCMD->GetItem()); } + operator TObject*(){ return static_cast(fCMD->GetItem()); } + operator TH1*(){ return static_cast(fCMD->GetItem()); } + private: + int fLevel; + AliJTH1Derived * fCMD; +}; + +typedef AliJTH1Derived AliJTH1D; +typedef AliJTH1Derived AliJTH2D; +typedef AliJTH1Derived AliJTProfile; + + +////////////////////////////////////////////////////////////////////////// +// // +// AliJHistManager // +// // +// Array Base Class // +// // +////////////////////////////////////////////////////////////////////////// +class AliJHistManager: public AliJNamed{ + public: + AliJHistManager(TString name ); + AliJHistManager(const AliJHistManager& obj); + AliJHistManager& operator=(const AliJHistManager& obj); + void Add( AliJBin * o ); + void Add( AliJTH1 * o ); + + int GetNBin(){ return fBin.size()>fBinNames.size()?fBin.size():fBinNames.size(); } // TODO + int GetNHist(){ return fHist.size()>fHistNames.size()?fHist.size():fHistNames.size(); } // TODO + void Print(); + int LoadConfig(); + TDirectory * GetDirectory(){ return fDirectory;} + void SetDirectory(TDirectory* d){ fDirectory = d; } + static AliJHistManager* GlobalManager(); + static AliJHistManager* CurrentManager( AliJHistManager * hmg=NULL); + void SetLoadMode(bool b=true){ fIsLoadMode = b; } + bool IsLoadMode(){ return fIsLoadMode; } + TString GetString(){ + TString st; + for( int i=0;iGetString()+"\n"; + for( int i=0;iGetString()+"\n"; + } + return st; + } + void Write(); + void WriteConfig(); + + AliJBin * GetBin( TString name); + AliJBin * GetBuiltBin( TString name); + AliJTH1 * GetTH1( TString name ); + AliJTH1 * GetBuiltTH1( TString name ); + AliJTProfile& GetTProfile( TString name){ return dynamic_cast(*GetTH1(name)); } + AliJTH1D& GetTH1D( TString name){ return dynamic_cast(*GetTH1(name)); } + AliJTH2D& GetTH2D( TString name){ return dynamic_cast(*GetTH1(name)); } + bool fIsLoadMode; + TDirectory * fDirectory; + + TString GetHistName(int i){ return fHistNames[i]; } + + AliJTH1 * GetAliJTH1(int i){ return GetTH1(fHistNames[i]); } + int GetNAliJTH1(){ return fHistNames.size(); } + + + private: + TString fConfigStr; + std::vector fBin; + std::vector fHist; + std::vector fManager; + std::vector fBinNames; + std::vector fBinConfigs; + std::vector fHistNames; + std::vector fHistConfigs; +}; +#endif diff --git a/PWGCF/Correlations/JCORRAN/AliJHistos.cxx b/PWGCF/Correlations/JCORRAN/AliJHistos.cxx new file mode 100644 index 00000000000..cf8f29cdb09 --- /dev/null +++ b/PWGCF/Correlations/JCORRAN/AliJHistos.cxx @@ -0,0 +1,1082 @@ +/************************************************************************** + * Copyright(c) 1998-2014, 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. * + **************************************************************************/ + +// Comment describing what this class does needed! + +#include "AliJHistos.h" +#include "AliJCard.h" +#include "AliJBaseTrack.h" +#include "AliJPhoton.h" +#include "AliJTrack.h" + +//______________________________________________________________________________ +AliJHistos::AliJHistos(AliJCard* cardP) : + fCard(cardP), + fHMG(NULL), + fCentBin(), + fVtxBin(), + fPTtBin(), + fPTaBin(), + fXEBin(), + fKLongBin(), + fRGapBin(), + fEtaGapBin(), + fPhiGapBin(), + fMassBin(), + fTypBin(), + fTypBin3(), + fPairPtBin(), + fhMixStat(), + fTestHist(), + fhPtNear(), + fhPtFar(), + fhPhi(), + fhDphiAssoc(), + fhDphiAssocXEbin(), + fhDphiAssoc2DIAA(), + fhDphiAssoc2D(), + fhDphiDetaKlong(), + fhDphiDetaKlongR(), + fhDphiDetaXe(), + fhDphiDetaXeR(), + fhDphiDetaPta(), + fhDphiDetaPtaR(), + fhBgAssocKlong(), + fhBgAssocKlongR(), + fhBgAssocXe(), + fhBgAssocXeR(), + fhBgAssocPta(), + fhBgAssocPtaR(), + fhDphiAssocIsolTrigg(), + fhMeanPtAssoc(), + fhMeanZtAssoc(), + fhPtAssocUE(), + fhPtaEtaGapN(), + fhPtaRGapN(), + fhPtAssocUEIsolTrigg(), + fhPtAssocN(), + fhPtAssocF(), + fhCosThetaStar(), + fhCMSrap(), + fpCMSrap(), + fhInvMass(), + fhPairPtMass(), + fhPairDPhi(), + fhPairDpT(), + fhPairPtDphi(), + fhPairPt(), + fhDEtaNear(), + fhDEtaNearM(), + fhDEtaNearXEbin(), + fhDEtaNearMXEbin(), + fhDRNearPt(), + fhDRFarPt(), + fhDRNearPtMoon(), + fhDRFarPtMoon(), + fhDRNearPtMoonM(), + fhDRFarPtMoonM(), + fhDEtaFar(), + fhIphiTrigg(), + fhIetaTrigg(), + fhIphiAssoc(), + fhIetaAssoc(), + fhFixPtBin(), + fhTriggPtBin(), + fhTriggPtBinIsolTrigg(), + fhTriggMult(), + fhAssocPtBin(), + fhxEN(), + fhxEF(), + fhxEFIsolTrigg(), + fhPoutF(), + fhxEPtBin(), + fhJT(), + fhJTBg(), + fhJTBgR(), + fhJTKlong(), + fhJTKlongBg(), + fhJTKlongBgR(), + fhJTPta(), + fhJTPtaBg(), + fhJTPtaBgR(), + fhLPpt(), + fhLPpairPt(), + fhChargedPt(), + fhChargedPtNoCorr(), + fhChargedPtJacek(), + fhChargedPtJacekEta(), + fhChargedPtFiete(), + fhVdelta2(), + fhVdelta3(), + fhVN(), + fhTrackingEfficiency(), + fpV2(), + fpV3(), + fpVdeltaNorm(), + fhChargedEta(), + fhLPeta(), + fhAssocMult(), + fhChargedMult(), + fhChargedMultCut(), + fhChargedMultCent(), + fhXt(), + fhXtWeighted(), + fhXtWeightedHT(), + fhPtForXt(), + fhConeActivity(), + fhConeActivityIsolated(), + fhPerpConeActivity(), + fhPerpConeActivityIsolated(), + fhV0AMult(), + fhZVertRaw(), + fhZVertRawErr(), + fhZVert(), + fhCentr(), + fhiCentr(), + fhEventPerRun(), + fhVertexZTriggVtx(), + fhIsolatedLPpt(), + fhBkgActivity(), + fhDphiLPJet(), + fhDEtaLPJet(), + fhDPtLPJet(), + fhLPJetPTt(), + fhLPJetPt(), + fhLPJetEtaPTt(), + fhLPJetRapidityPTt(), + fhLPJetMassPTt(), + fhLeadingJetWLPPTt(), + fhJetPt(), + fhLeadingJetPt(), + fhLeadingJetWLPPt(), + fhJetAssymPTt(), + fhJetMassPTt(), + fhJetUEPt(), + fhJetDphi(), + fhJetDeta(), + fhJetMultPt(), + fhJetRho(), + fhJetRhoSigma(), + fhJetPartMult(), + fhRecoDiJetM(), + fhRecoDiJetdPhi(), + fhRecoDiJetkT(), + fhNParton71(), + fhNStringGroup(), + fhNStringGroupFrom(), + fhNTracksInStringGroupFrom(), + fhRapidity71From(), + fhPt71From(), + fhTrackSelection(), + fNJacek(0), + fPttJacek(0), + fNEta(0), + fEta(0), + fNJanFiete(0), + fJanFiete(0), + fhEvents(), + fhEventTrigger(), + fmaxEtaRange(0), + fmaxTriggEtaRange(0), + ftriggFiducCut(0), + fnUE(0), + fnUEfar(0), + fLowRange(0), + fHighRange(0) +{ // constructor + + fmaxEtaRange = fCard->Get("EtaRange"); + ftriggFiducCut = fCard->Get("TriggerFiducialEtaCut"); //FK// Fiduc cut + fmaxTriggEtaRange = fmaxEtaRange - ftriggFiducCut; //FK// Trigger range + + fHMG = AliJHistManager::GlobalManager(); + //for (int hiklong = 0; hiklong < fCard->GetNoOfBins(kLongType); hiklong++) + //kRGapType kEtaGapType + fCentBin .Set("Cent", "C", "C %2.0f-%2.0f%%" ).SetBin( fCard->GetVector("CentBinBorders")); + fVtxBin .Set("Vtx", "V", "" ).SetBin(fCard->GetVector("zVertBins")); + fPTtBin .Set("PTt", "T", "").SetBin(fCard->GetVector("TriggPtBorders")); + fPTaBin .Set("PTa", "A", "").SetBin(fCard->GetVector("AssocPtBorders")); + fXEBin .Set("XE", "X", "x_{E}: %2.1f-%2.1f" ).SetBin(fCard->GetVector("xEBorders")); + fKLongBin .Set("KLong", "L", "k_{#parallel}: %2.1f-%2.1f").SetBin(fCard->GetVector("KlongBorders")); + fRGapBin .Set("RGap", "R", "").SetBin(fCard->GetVector("RGapThresholds")); + fEtaGapBin .Set("EtaGap", "E", "").SetBin(fCard->GetVector("EtaGapThresholds")); + fPhiGapBin .Set("PhiGap", "P", "" ).SetBin(fCard->GetVector("EtaGapThresholds")); + fMassBin .Set("Mass", "M", "Mass").SetBin(fCard->GetVector("PairInvariantMassBins")); + fTypBin .Set("Type", "D", "", AliJBin::kSingle ).SetBin( "0 1" ); + fTypBin3 .Set("Type3", "D", "", AliJBin::kSingle ).SetBin( "0 1 2 3" ); + //card->IsLessThanUpperPairPtCut(-ipairpt) + fPairPtBin .Set("PairPt", "", AliJBin::kSingle ).SetBin( fCard->GetN("UpperPairPtCut") ); + + const int nJacek = 73 ; + double pttJacek[nJacek+1] = {0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, + 1, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2, 2.2, 2.4, 2.6, 2.8, 3, 3.2, 3.4, 3.6, 3.8, 4, 4.5, 5, 5.5, 6, 6.5, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 40, 45, 50, 60, 70, 80, 90, 100}; + + //const int nJacek = 59 ; + //double pttJacek[nJacek] = { 0.15, 0.20, 0.25, 0.30, 0.35, 0.40, 0.45, 0.5, 0.55, 0.60, 0.65, 0.70, 0.75, 0.80, 0.85, 0.9, 0.95, 1., + // 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2, 2.2, 2.4, 2.6, 2.8, 3., 3.2, 3.4, 3.6, 3.8, 4., 4.5, 5., 5.5, 6., 6.5, 7., 8., 9., 10, + // 11., 12., 13., 14., 15., 16., 18., 20, 22, 24, 26., 28., 30.}; + + fNJacek = nJacek; // Number of bins + fPttJacek = new double[fNJacek+1]; + for(int i = 0; i <= fNJacek; i++){ + fPttJacek[i] = pttJacek[i]; + } + + const int nEta = 3; + double eta[nEta+1] = {-0.8,-0.2,0.3,0.8};// eta bins + + fNEta = nEta; // Number of bins + fEta = new double[fNEta+1]; + for(int i = 0; i <= fNEta; i++){ + fEta[i] = eta[i]; + } + + const int nJanFiete=200; + double janFiete[nJanFiete+1]={0, 0.25, 0.5, 0.75, 1, 1.25, 1.5, 1.75, 2, 2.25, 2.5, 2.75, 3, 3.25, 3.5, 3.75, 4, 4.25, 4.5, 4.75, 5, 5.25, 5.5, + 5.75, 6, 6.25, 6.5, 6.75, 7, 7.25, 7.5, 7.75, 8, 8.25, 8.5, 8.75, 9, 9.25, 9.5, 9.75, 10, 10.25, 10.5, 10.75, 11, 11.25, 11.5, 11.75, + 12, 12.25, 12.5, 12.75, 13, 13.25, 13.5, 13.75, 14, 14.25, 14.5, 14.75, 15, 15.25, 15.5, 15.75, 16, 16.25, 16.5, 16.75, 17, 17.25, 17.5, + 17.75, 18, 18.25, 18.5, 18.75, 19, 19.25, 19.5, 19.75, 20, 20.25, 20.5, 20.75, 21, 21.25, 21.5, 21.75, 22, 22.25, 22.5, 22.75, 23, 23.25, + 23.5, 23.75, 24, 24.25, 24.5, 24.75, 25, 25.25, 25.5, 25.75, 26, 26.25, 26.5, 26.75, 27, 27.25, 27.5, 27.75, 28, 28.25, 28.5, 28.75, 29, + 29.25, 29.5, 29.75, 30, 30.25, 30.5, 30.75, 31, 31.25, 31.5, 31.75, 32, 32.25, 32.5, 32.75, 33, 33.25, 33.5, 33.75, 34, 34.25, 34.5, 34.75, + 35, 35.25, 35.5, 35.75, 36, 36.25, 36.5, 36.75, 37, 37.25, 37.5, 37.75, 38, 38.25, 38.5, 38.75, 39, 39.25, 39.5, 39.75, 40, 40.25, 40.5, + 40.75, 41, 41.25, 41.5, 41.75, 42, 42.25, 42.5, 42.75, 43, 43.25, 43.5, 43.75, 44, 44.25, 44.5, 44.75, 45, 45.25, 45.5, 45.75, 46, 46.25, + 46.5, 46.75, 47, 47.25, 47.5, 47.75, 48, 48.25, 48.5, 48.75, 49, 49.25, 49.5, 49.75, 50}; + + fNJanFiete = nJanFiete; // Number of bins + fJanFiete = new double[fNJanFiete+1]; + for(int i = 0; i <= fNJanFiete; i++){ + fJanFiete[i] = janFiete[i]; + } + + //fhtyp[1] = "Real"; + //fhtyp[2] = "Mixed"; + //fhtyp[3] = "Rap. Gap"; +} + +//______________________________________________________________________________ +AliJHistos::AliJHistos(const AliJHistos& obj) : + fCard(obj.fCard), + fHMG(obj.fHMG), + fCentBin(obj.fCentBin), + fVtxBin(obj.fVtxBin), + fPTtBin(obj.fPTtBin), + fPTaBin(obj.fPTaBin), + fXEBin(obj.fXEBin), + fKLongBin(obj.fKLongBin), + fRGapBin(obj.fRGapBin), + fEtaGapBin(obj.fEtaGapBin), + fPhiGapBin(obj.fPhiGapBin), + fMassBin(obj.fMassBin), + fTypBin(obj.fTypBin), + fTypBin3(obj.fTypBin3), + fPairPtBin(obj.fPairPtBin), + fhMixStat(obj.fhMixStat), + fTestHist(obj.fTestHist), + fhPtNear(obj.fhPtNear), + fhPtFar(obj.fhPtFar), + fhPhi(obj.fhPhi), + fhDphiAssoc(obj.fhDphiAssoc), + fhDphiAssocXEbin(obj.fhDphiAssocXEbin), + fhDphiAssoc2DIAA(obj.fhDphiAssoc2DIAA), + fhDphiAssoc2D(obj.fhDphiAssoc2D), + fhDphiDetaKlong(obj.fhDphiDetaKlong), + fhDphiDetaKlongR(obj.fhDphiDetaKlongR), + fhDphiDetaXe(obj.fhDphiDetaXe), + fhDphiDetaXeR(obj.fhDphiDetaXeR), + fhDphiDetaPta(obj.fhDphiDetaPta), + fhDphiDetaPtaR(obj.fhDphiDetaPtaR), + fhBgAssocKlong(obj.fhBgAssocKlong), + fhBgAssocKlongR(obj.fhBgAssocKlongR), + fhBgAssocXe(obj.fhBgAssocXe), + fhBgAssocXeR(obj.fhBgAssocXeR), + fhBgAssocPta(obj.fhBgAssocPta), + fhBgAssocPtaR(obj.fhBgAssocPtaR), + fhDphiAssocIsolTrigg(obj.fhDphiAssocIsolTrigg), + fhMeanPtAssoc(obj.fhMeanPtAssoc), + fhMeanZtAssoc(obj.fhMeanZtAssoc), + fhPtAssocUE(obj.fhPtAssocUE), + fhPtaEtaGapN(obj.fhPtaEtaGapN), + fhPtaRGapN(obj.fhPtaRGapN), + fhPtAssocUEIsolTrigg(obj.fhPtAssocUEIsolTrigg), + fhPtAssocN(obj.fhPtAssocN), + fhPtAssocF(obj.fhPtAssocF), + fhCosThetaStar(obj.fhCosThetaStar), + fhCMSrap(obj.fhCMSrap), + fpCMSrap(obj.fpCMSrap), + fhInvMass(obj.fhInvMass), + fhPairPtMass(obj.fhPairPtMass), + fhPairDPhi(obj.fhPairDPhi), + fhPairDpT(obj.fhPairDpT), + fhPairPtDphi(obj.fhPairDPhi), + fhPairPt(obj.fhPairPt), + fhDEtaNear(obj.fhDEtaNear), + fhDEtaNearM(obj.fhDEtaNearM), + fhDEtaNearXEbin(obj.fhDEtaNearXEbin), + fhDEtaNearMXEbin(obj.fhDEtaNearMXEbin), + fhDRNearPt(obj.fhDRNearPt), + fhDRFarPt(obj.fhDRFarPt), + fhDRNearPtMoon(obj.fhDRNearPtMoon), + fhDRFarPtMoon(obj.fhDRFarPtMoon), + fhDRNearPtMoonM(obj.fhDRNearPtMoonM), + fhDRFarPtMoonM(obj.fhDRFarPtMoonM), + fhDEtaFar(obj.fhDEtaFar), + fhIphiTrigg(obj.fhIphiTrigg), + fhIetaTrigg(obj.fhIetaTrigg), + fhIphiAssoc(obj.fhIphiAssoc), + fhIetaAssoc(obj.fhIetaAssoc), + fhFixPtBin(obj.fhFixPtBin), + fhTriggPtBin(obj.fhTriggPtBin), + fhTriggPtBinIsolTrigg(obj.fhTriggPtBinIsolTrigg), + fhTriggMult(obj.fhTriggMult), + fhAssocPtBin(obj.fhAssocPtBin), + fhxEN(obj.fhxEN), + fhxEF(obj.fhxEF), + fhxEFIsolTrigg(obj.fhxEFIsolTrigg), + fhPoutF(obj.fhPoutF), + fhxEPtBin(obj.fhxEPtBin), + fhJT(obj.fhJT), + fhJTBg(obj.fhJTBg), + fhJTBgR(obj.fhJTBgR), + fhJTKlong(obj.fhJTKlong), + fhJTKlongBg(obj.fhJTKlongBg), + fhJTKlongBgR(obj.fhJTKlongBgR), + fhJTPta(obj.fhJTPta), + fhJTPtaBg(obj.fhJTPtaBg), + fhJTPtaBgR(obj.fhJTPtaBgR), + fhLPpt(obj.fhLPpt), + fhLPpairPt(obj.fhLPpairPt), + fhChargedPt(obj.fhChargedPt), + fhChargedPtNoCorr(obj.fhChargedPtNoCorr), + fhChargedPtJacek(obj.fhChargedPtJacek), + fhChargedPtJacekEta(obj.fhChargedPtJacekEta), + fhChargedPtFiete(obj.fhChargedPtFiete), + fhVdelta2(obj.fhVdelta2), + fhVdelta3(obj.fhVdelta3), + fhVN(obj.fhVN), + fhTrackingEfficiency(obj.fhTrackingEfficiency), + fpV2(obj.fpV2), + fpV3(obj.fpV3), + fpVdeltaNorm(obj.fpVdeltaNorm), + fhChargedEta(obj.fhChargedEta), + fhLPeta(obj.fhLPeta), + fhAssocMult(obj.fhAssocMult), + fhChargedMult(obj.fhChargedMult), + fhChargedMultCut(obj.fhChargedMultCut), + fhChargedMultCent(obj.fhChargedMultCent), + fhXt(obj.fhXt), + fhXtWeighted(obj.fhXtWeighted), + fhXtWeightedHT(obj.fhXtWeightedHT), + fhPtForXt(obj.fhPtForXt), + fhConeActivity(obj.fhConeActivity), + fhConeActivityIsolated(obj.fhConeActivityIsolated), + fhPerpConeActivity(obj.fhPerpConeActivity), + fhPerpConeActivityIsolated(obj.fhPerpConeActivityIsolated), + fhV0AMult(obj.fhV0AMult), + fhZVertRaw(obj.fhZVertRaw), + fhZVertRawErr(obj.fhZVertRawErr), + fhZVert(obj.fhZVert), + fhCentr(obj.fhCentr), + fhiCentr(obj.fhiCentr), + fhEventPerRun(obj.fhEventPerRun), + fhVertexZTriggVtx(obj.fhVertexZTriggVtx), + fhIsolatedLPpt(obj.fhIsolatedLPpt), + fhBkgActivity(obj.fhBkgActivity), + fhDphiLPJet(obj.fhDphiLPJet), + fhDEtaLPJet(obj.fhDEtaLPJet), + fhDPtLPJet(obj.fhDPtLPJet), + fhLPJetPTt(obj.fhLPJetPTt), + fhLPJetPt(obj.fhLPJetPt), + fhLPJetEtaPTt(obj.fhLPJetEtaPTt), + fhLPJetRapidityPTt(obj.fhLPJetRapidityPTt), + fhLPJetMassPTt(obj.fhLPJetMassPTt), + fhLeadingJetWLPPTt(obj.fhLeadingJetWLPPTt), + fhJetPt(obj.fhJetPt), + fhLeadingJetPt(obj.fhLeadingJetPt), + fhLeadingJetWLPPt(obj.fhLeadingJetWLPPt), + fhJetAssymPTt(obj.fhJetAssymPTt), + fhJetMassPTt(obj.fhJetMassPTt), + fhJetUEPt(obj.fhJetUEPt), + fhJetDphi(obj.fhJetDphi), + fhJetDeta(obj.fhJetDeta), + fhJetMultPt(obj.fhJetMultPt), + fhJetRho(obj.fhJetRho), + fhJetRhoSigma(obj.fhJetRhoSigma), + fhJetPartMult(obj.fhJetPartMult), + fhRecoDiJetM(obj.fhRecoDiJetM), + fhRecoDiJetdPhi(obj.fhRecoDiJetdPhi), + fhRecoDiJetkT(obj.fhRecoDiJetkT), + fhNParton71(obj.fhNParton71), + fhNStringGroup(obj.fhNStringGroup), + fhNStringGroupFrom(obj.fhNStringGroupFrom), + fhNTracksInStringGroupFrom(obj.fhNTracksInStringGroupFrom), + fhRapidity71From(obj.fhRapidity71From), + fhPt71From(obj.fhPt71From), + fhTrackSelection(obj.fhTrackSelection), + fNJacek(obj.fNJacek), + fPttJacek(obj.fPttJacek), + fNEta(obj.fNEta), + fEta(obj.fEta), + fNJanFiete(obj.fNJanFiete), + fJanFiete(obj.fJanFiete), + fhEvents(obj.fhEvents), + fhEventTrigger(obj.fhEventTrigger), + fmaxEtaRange(obj.fmaxEtaRange), + fmaxTriggEtaRange(obj.fmaxTriggEtaRange), + ftriggFiducCut(obj.ftriggFiducCut), + fnUE(obj.fnUE), + fnUEfar(obj.fnUEfar), + fLowRange(obj.fLowRange), + fHighRange(obj.fHighRange) +{ + // copy constructor + JUNUSED(obj); +} + +//______________________________________________________________________________ +AliJHistos& AliJHistos::operator=(const AliJHistos& obj){ + // copy constructor + JUNUSED(obj); + return *this; +} + +//______________________________________________________________________________ +void AliJHistos::CreateAzimuthCorrHistos() +{ + // Comment needed here! + + int bins = 240; // 240 is divisible by 2,3,4,612*24=280 -1/3 and 0.5 and 5/3 are bin edges + //double fLowRange = -1.0/3, fHighRange= 5.0/3; + fLowRange = -9./20.; //lower range for dphi histos + fHighRange= fLowRange+2; //upper range for dphi histos; + double ptbw=10/100.0; //see hPt histo below, let's make 10 bins per 1GeV/c + + fnUE=20; + double uEa = fCard->GetBinBorder(kAssocType, 0), uEb = fCard->GetBinBorder(kAssocType, fCard->GetNoOfBins(kAssocType)); + double logUEbw = (log(uEb)-log(uEa))/fnUE; + for(int ij=0;ij<=fnUE;ij++) fUEBinsx[ij]=uEa*exp(ij*logUEbw); + + fnUEfar=10; + logUEbw = (log(uEb)-log(uEa))/fnUEfar; + for(int ij=0;ij<=fnUE;ij++) fUEBinsxFar[ij]=uEa*exp(ij*logUEbw); + + + if(fCard->GetNoOfBins(kCentrType) > kMaxNoCentrBin ){ + cout<<"ERROR: No of Centrality bins exceed max dim in AliJHistos.cxx "<SetBinContent( 1, double(ityp) ); + fTestHist[ityp][ic][ie][it][ix]->SetBinContent( 2, double(ic) ); + fTestHist[ityp][ic][ie][it][ix]->SetBinContent( 3, double(ie) ); + fTestHist[ityp][ic][ie][it][ix]->SetBinContent( 4, double(it) ); + fTestHist[ityp][ic][ie][it][ix]->SetBinContent( 5, double(ix) ); + } + } + } + } + } + fhDEtaNearXEbin + << TH1D( "hDEtaNearXEbin", "", 320, -2*fmaxEtaRange, 2*fmaxEtaRange) + << fCentBin << fVtxBin << fEtaGapBin << fPTtBin << fXEBin << "END"; + fhDEtaNearMXEbin + << TH1D( "hDEtaNearMXEbin", "", 320, -2*fmaxEtaRange, 2*fmaxEtaRange) + << fCentBin << fVtxBin << fEtaGapBin << fPTtBin << fXEBin << "END"; + //======================================= + // associated fpt fhistos without etaGaps + //======================================= + fhDphiAssocIsolTrigg + << TH1D( "hDphiAssocIsolTrigg", "", bins, fLowRange, fHighRange) + << fTypBin << fCentBin << fPTtBin << fPTaBin << "END";//FK// + fhMeanPtAssoc + << TProfile( "hMeanPtAssoc", "", bins, fLowRange, fHighRange) + << fCentBin << fPTtBin << fPTaBin << "END"; + fhMeanZtAssoc + << TProfile( "hMeanZtAssoc", "", bins, fLowRange, fHighRange) + << fCentBin << fPTtBin << fPTaBin << "END"; + fhAssocPtBin + << TH1D( "hAssocPtBin", "", (int)TMath::Ceil((pTa2-pTa1)/ptbw), pTa1, pTa2) + << fCentBin << fPTtBin << fPTaBin << "END"; + fhIphiAssoc + << TH1D( "fhIphiAssoc", "", bins, -kJPi-0.1, kJPi+0.1) + << fCentBin << fPTaBin << "END"; + fhIetaAssoc + << TH1D( "hIetaAssoc", "", 80, -fmaxEtaRange, fmaxEtaRange) + << fCentBin << fPTaBin << "END"; + fhDEtaFar + << TH1D( "hDEtaFar", "", 120, -2*fmaxEtaRange, 2*fmaxEtaRange) + << fTypBin << fCentBin << fPTtBin << "END"; + + //========================== + //UE fhistos + //========================== + fhPtAssocUE + << TH1D( "hPtAssocUE", "", fnUE, fUEBinsx) + << fCentBin << fEtaGapBin << fPTtBin << "END"; + fhPtaEtaGapN + << TH1D( "hPtaEtaGapN", "", fnUE, fUEBinsx) + << fCentBin << fEtaGapBin << fPTtBin << "END"; + fhPtaRGapN + << TH1D( "hPtaRGapN", "", fnUE, fUEBinsx) + << fCentBin << fRGapBin << fPTtBin << "END"; + fhPtAssocUEIsolTrigg + << TH1D( "hPtAssocUEIsolTrigg", "", fnUE, fUEBinsx) + << fPTtBin << "END";//FK// + fhPtAssocN + << TH1D( "hPtAssocN", "", fnUE, fUEBinsx) + << fPTtBin << "END"; + fhPtAssocF + << TH1D( "hPtAssocF", "", fnUE, fUEBinsx) + << fPTtBin << "END"; + + //======================= + //jT fhistos + //======================= + + int nJT = 100; + double jtLow = 0.05, jtHigh = 20; + + double logBinsJt[101]; + double logJt = (log(jtHigh)-log(jtLow))/nJT; + for(int ij=0;ij<=nJT;ij++) logBinsJt[ij]=jtLow*exp(ij*logJt); + + fhPoutF + << TH1D( "hPoutF", "", 300, 0, 15) + << fTypBin << fCentBin << fPTtBin << fPTaBin << "END";//FK// + //let's not compute mixed frandom background - takes a lot of time. + fhJTKlongBg + << TH1D( "hJTKlongBg", "", nJT, logBinsJt) + << fCentBin << fEtaGapBin << fPTtBin << fKLongBin << "END"; + fhDphiDetaKlong + << TH2D( "hDphiDetaKlong", "", 100, -2*fmaxEtaRange, 2*fmaxEtaRange, 100, -kJPi/2, kJPi/2) + << fCentBin << fEtaGapBin << fPTtBin << fKLongBin << "END"; + fhBgAssocKlong + << TH1D( "hBgAssocKlong", "", fnUE, fUEBinsx) + << fCentBin << fEtaGapBin << fPTtBin << fKLongBin << "END"; + //let's not compute mixed frandom background - takes a lot of time. + fhJTKlongBgR + << TH1D( "hJTKlongBgR", "", nJT, logBinsJt) + << fCentBin << fRGapBin << fPTtBin << fKLongBin << "END"; + fhDphiDetaKlongR + << TH2D( "hDphiDetaKlongR", "", 100, -2*fmaxEtaRange, 2*fmaxEtaRange, 100, -kJPi/2, kJPi/2) + << fCentBin << fRGapBin << fPTtBin << fKLongBin << "END"; + fhBgAssocKlongR + << TH1D( "hBgAssocKlongR", "", fnUE, fUEBinsx) + << fCentBin << fRGapBin << fPTtBin << fKLongBin << "END"; + fhJTKlong + << TH1D( "hJTKlong", "", nJT, logBinsJt) + << fTypBin << fCentBin << fPTtBin << fKLongBin << "END"; + // xe bins + fhJTBg + << TH1D( "hJTBg", "", nJT, logBinsJt) + << fCentBin << fEtaGapBin << fPTtBin << fXEBin << "END"; + fhDphiDetaXe + << TH2D( "hDphiDetaXe", "", 100, -2*fmaxEtaRange, 2*fmaxEtaRange, 100, -kJPi/2, kJPi/2) + << fCentBin << fEtaGapBin << fPTtBin << fXEBin << "END"; + fhBgAssocXe + << TH1D( "hBgAssocXe", "", fnUE, fUEBinsx) + << fCentBin << fEtaGapBin << fPTtBin << fXEBin << "END"; + fhJTBgR + << TH1D( "hJTBgR", "", nJT, logBinsJt) + << fCentBin << fRGapBin << fPTtBin << fXEBin << "END"; + fhDphiDetaXeR + << TH2D( "hDphiDetaXeR", "", 100, -2*fmaxEtaRange, 2*fmaxEtaRange, 100, -kJPi/2, kJPi/2) + << fCentBin << fRGapBin << fPTtBin << fXEBin << "END"; + fhBgAssocXeR + << TH1D( "hBgAssocXeR", "", fnUE, fUEBinsx) + << fCentBin << fRGapBin << fPTtBin << fXEBin << "END"; + fhJT + << TH1D( "hJT", "", nJT, logBinsJt) + << fTypBin << fCentBin << fPTtBin << fXEBin << "END"; + fhJTPtaBg + << TH1D( "hJTPtaBg", "", nJT, logBinsJt) + << fCentBin << fEtaGapBin << fPTtBin << fPTaBin << "END"; + fhDphiDetaPta + << TH2D( "hDphiDetaPta", "", 100, -2*fmaxEtaRange, 2*fmaxEtaRange, 100, -kJPi/2, kJPi/2) + << fCentBin << fEtaGapBin << fPTtBin << fPTaBin << "END"; + fhBgAssocPta + << TH1D( "hBgAssocPta", "", fnUE, fUEBinsx) + << fCentBin << fEtaGapBin << fPTtBin << fPTaBin << "END"; + fhJTPtaBgR + << TH1D( "hJTPtaBgR", "", nJT, logBinsJt) + << fCentBin << fRGapBin << fPTtBin << fPTaBin << "END"; + fhDphiDetaPtaR + << TH2D( "hDphiDetaPtaR", "", 100, -2*fmaxEtaRange, 2*fmaxEtaRange, 100, -kJPi/2, kJPi/2) + << fCentBin << fRGapBin << fPTtBin << fPTaBin << "END"; + fhBgAssocPtaR + << TH1D( "hBgAssocPtaR", "", fnUE, fUEBinsx) + << fCentBin << fRGapBin << fPTtBin << fPTaBin << "END"; + fhJTPta + << TH1D( "hJTPta", "", nJT, logBinsJt) + << fTypBin << fCentBin << fPTtBin << fPTaBin << "END"; +} + + +void AliJHistos::CreateIAAMoons() +{ + //--- IAA signal --- + fhDRNearPt + << TH1D( "hDRNearPt", "", fnUE, fUEBinsx) + << fTypBin << fCentBin << fVtxBin << fRGapBin << fPTtBin << "END"; + fhDRFarPt + << TH1D( "hDRFarPt", "", fnUEfar, fUEBinsxFar) + << fTypBin << fCentBin << fVtxBin << fRGapBin << fPTtBin << "END"; + + // --- Moons --- + fhDRNearPtMoon + << TH1D( "hDRNearPtMoon", "", fnUE, fUEBinsx) + << fCentBin << fVtxBin << fRGapBin << fPhiGapBin << fPTtBin << "END"; + fhDRNearPtMoonM + << TH1D( "hDRNearPtMoonM", "", fnUE, fUEBinsx) + << fCentBin << fVtxBin << fRGapBin << fPhiGapBin << fPTtBin << "END"; + + fhDRFarPtMoon + << TH1D( "hDRFarPtMoon", "", fnUE, fUEBinsx) + << fCentBin << fVtxBin << fRGapBin << fPhiGapBin << fPTtBin << "END"; + fhDRFarPtMoonM + << TH1D( "hDRFarPtMoonM", "", fnUE, fUEBinsx) + << fCentBin << fVtxBin << fRGapBin << fPhiGapBin << fPTtBin << "END"; + + //========================== + // 2D fhistos + //========================== + fhDphiAssoc2DIAA + << TH2D( "hDphiAssoc2DIAA", "", 100, -2*fmaxEtaRange, 2*fmaxEtaRange, 100, fLowRange, fHighRange) + << fTypBin << fCentBin << fVtxBin << fPTtBin << fPTaBin << "END"; + fhDphiAssoc2D + << TH2D( "hDphiAssoc2D", "", 100, -2*fmaxEtaRange, 2*fmaxEtaRange, 100, fLowRange, fHighRange) + << fRGapBin << fPhiGapBin << "END"; +} + +void AliJHistos::CreateXEHistos(){ + //================================== + // xe slopes + //================================== + double xel=0.0, xeh=1.2; + int nbxE = int((xeh-xel)/0.04); + + fhxEPtBin + << TH1D( "hxEPtBin", "", nbxE, xel, xeh) + << fTypBin3 << fPTtBin << fPTaBin << "END"; + fhxEF + << TH1D( "hxEF", "", nbxE, xel, xeh) + << fTypBin << fPTtBin <<"END"; + fhxEFIsolTrigg + << TH1D( "hxEFIsoTrigg", "", nbxE, xel, xeh) + << fTypBin << fPTtBin << "END"; + fhxEN + << TH1D("hxEN", "", nbxE, xel, xeh) + << fTypBin << fPTtBin << "END"; + +} + +void AliJHistos::CreatePairPtCosThetaStar(){ + // pairs + int bins = 288; // 12*24 -1/3 and 0.5 and 5/3 are bin edges + double lowRange = -1./3, highRange= 5./3; + //================= + //pairPT + //================= + fhPairPtDphi + << TH1D( "hPairPtDphi", "", bins, lowRange, highRange) + << fTypBin << fPTtBin << fPTaBin << "END"; + fhPairPt + << TH1D( "hPairPt", "", 210, 0, 70) + << fTypBin << fPTtBin << fPTaBin << "END"; + //================================== + // CosThetaStar fhistos + //================================== + //cout<<"ippt="<IsLessThanUpperPairPtCut(-fPairPtBin)<SetXTitle( "0 - all, 1 - SDD selected, 2 - has vertex, 3 - good vertex, 4 - trigger + MB, 5 - trigger, 6 - BX, 7 - centrality" ); +} + +void AliJHistos::CreateJetHistos(){ + // jet histos + int nBINS=200; + double logBinsX[nBINS+1], limL=0.1, limH=200; + double logBW = (log(limH)-log(limL))/nBINS; + for(int ij=0;ij<=nBINS;ij++) logBinsX[ij]=limL*exp(ij*logBW); + + fhLPJetPt + << TH1D( "hLPJetPt", "", nBINS, logBinsX) + << fCentBin << "END"; + fhJetPt + << TH1D( "hJetPt", "", nBINS, logBinsX) + << fCentBin << "END"; + fhLeadingJetPt + << TH1D( "hLeadingJetPt", "", nBINS, logBinsX) + << fCentBin << "END"; + fhLeadingJetWLPPt + << TH1D( "hLeadingJetWLPPt", "", nBINS, logBinsX) + << fCentBin << "END"; + fhLPJetPTt + << TH1D( "hLPJetPTt", "", nBINS, logBinsX) + << fCentBin << fPTtBin << "END"; + fhLeadingJetWLPPTt + << TH1D( "hLeadingJetWLPPTt", "", nBINS, logBinsX) + << fCentBin << fPTtBin << "END"; + fhLPJetEtaPTt + << TH1D( "hLPJetEtaPTt", "", 100, -1, 1) + << fCentBin << fPTtBin << "END"; + fhLPJetRapidityPTt + << TH1D( "hLPJetRapidityPTt", "", 100, -1, 1) + << fCentBin << fPTtBin << "END"; + fhLPJetMassPTt + << TH1D( "hLPJetMassPTt", "", nBINS, logBinsX) + << fCentBin << fPTtBin << "END"; + fhDphiLPJet + << TH1D( "hDphiLPJet", "", 160, -kJPi/2., kJPi/2.) + << fCentBin << fPTtBin << "END"; + fhDEtaLPJet + << TH1D( "hDEtaLPJet", "", 240, -1.2, 1.2) + << fCentBin << fPTtBin << "END"; + // LP jet vs Leading Jet + fhDPtLPJet + << TH1D( "hDPtLPJet", "", 100, 0, 10.) + << fCentBin << fPTtBin << "END"; + //================================== + fhJetDphi << TH1D( "hJetDphi", "#Delta#phi", 100,-TMath::Pi(), TMath::Pi()) + << fTypBin << fPTtBin <<"END"; + fhJetDeta << TH1D("hJetDeta","#Delta#eta ",100,-1, 1) + << fTypBin << fPTtBin <<"END"; + fhJetMultPt << TH1D("hJetMultPt","Jet Multiplicity ",100,0-0.5, 100-0.5) + << fPTtBin <<"END"; + fhJetRho << TH1D("hJetRho","#rho",200,0, 50) + << fPTtBin <<"END"; + fhJetRhoSigma << TH1D("hJetRhoSigma","#sigma",200,0, 50) + << fPTtBin <<"END"; + // How many particles in a jet + fhJetPartMult << TH1D("hJetPartMult","Number of consituents",100, 0-0.5, 100-0.5) + << fPTtBin <<"END"; + fhRecoDiJetM + << TH1D("hRecoDiJetM", "Invariant Mass", 201,-0.5, 200 ) + << "END"; + fhJetUEPt + << TH1D("hJetUEPt","UE particles p_{T} by Jet substract",nBINS,logBinsX) + << "END"; + // pytfPTaBin + fhNParton71 + << TH1D("hNParton71", "hNParton71", 100, -0.5, 100-0.5) + <<"END"; + fhNStringGroup + << TH1D("hNStringGroup", "hNStringGroup", 100, -0.5, 100-0.5) + <<"END"; + fhNStringGroupFrom << TH1D("hNStringGroupFrom", "hNStringGroupFrom", 100, -0.5, 100-0.5) << 2 <<"END"; + fhNTracksInStringGroupFrom << TH1D("hNTracksInStringGroupFrom", "hNTracksInStringGroupFrom", 100, -0.5, 100-0.5) << 2 << "END"; + fhRapidity71From << TH1D("hRapidity71From", "hRapidity71From", 100, -8, 8 ) << 2 << "END"; + fhPt71From + << TH1D("hPt71From", "hPt71From", 1000, 0, 100) + << 2 << "END"; + +} + +//______________________________________________________________________________ +void AliJHistos::CreateXtHistos() { + + // TODO MakeDirectory("xT"); + // Esko + TH1::SetDefaultSumw2(kTRUE); + cout << "GetDefaultSumw2() = " << TH1::GetDefaultSumw2() << endl; + + // xT binning + int nBinsXt=200; + double logBinsXt[nBinsXt+1]; + double xTLimL = 1e-5, xTLimH = 1.0, xTlogBW = (log(xTLimH)-log(xTLimL))/nBinsXt; + for(int ij=0;ij<=nBinsXt;ij++) logBinsXt[ij]=xTLimL*exp(ij*xTlogBW); + + + // pT binning + int nBinsPt=200; + double logBinsPt[nBinsPt+1]; + double pTLimL=0.1, pTLimH=200 , pTlogBW = (log(pTLimH)-log(pTLimL))/nBinsPt; + for(int ij=0;ij<=nBinsPt;ij++) logBinsPt[ij]=pTLimL*exp(ij*pTlogBW); + + fhConeActivity << TProfile("hActivity", "Mean activity inside cone", nBinsPt, logBinsPt ); + fhPerpConeActivity << TProfile("hPerpActivity", "Mean activity inside perpendicular cone", nBinsPt, logBinsPt ); + fhConeActivityIsolated << TProfile("hActivityIsolated", "Mean pion activity inside cone isolated", nBinsPt, logBinsPt ); + + fhPerpConeActivityIsolated << TProfile("hPerpActivityIsolated", "Mean activity inside perpendicular cone", nBinsPt, logBinsPt ); + fhPtForXt + << TH1D("hPtForXt","", fNJacek, fPttJacek ) + << 3 << fCentBin <<"END"; + + fhXt + << TH1D("hXt", "Charged xT", nBinsXt, logBinsXt ) + << 3 << fCentBin <<"END"; + + fhXtWeighted + << TH1D("hXtWeighted", "Charged xT", nBinsXt, logBinsXt ) + << 3 << fCentBin <<"END"; + + fhXtWeightedHT + << TH1D("hXtWeightedHT", "", nBinsXt, logBinsXt ) + << 3 << fCentBin <<"END"; +} + +//______________________________________________________________________________ +//void AliJHistos::ReadInclusiveHistos(TFile *inFile){ +void AliJHistos::ReadInclusiveHistos(const char *inclusFileName){ + // read inclusive histos + TFile *inclusFile = new TFile(inclusFileName, "READ"); + + //inFile->ls(); + //cout<<((TH1D*) inclusFile->Get(Form("hIetaTrigg%02d%02d", 0, 0)))->GetEntries() <GetNoOfBins(kCentrType);hic++) { + for (int hit = 0; hit < fCard->GetNoOfBins(kTriggType);hit++){ + fhIetaTriggFromFile[hic][hit] = (TH1D*) inclusFile->Get(Form("hIetaTrigg%02d%02d", hic, hit));//FK//mix2 + //fhistoList->Add(fhIetaTriggFromFile[hic][hit]); + fhIphiTriggFromFile[hic][hit] = (TH1D*) inclusFile->Get(Form("hIphiTrigg%02d%02d", hic, hit));//FK//mix2 + //fhistoList->Add(fhIphiTriggFromFile[hic][hit]); + cout<<"c=" << hic <<" tr="<< hit <<" "<Add(fhIetaAssocFromFile[hic][hia]); + fhIphiAssocFromFile[hic][hia] = (TH1D*) inclusFile->Get(Form("hIphiAssoc%02d%02d", hic, hia));//FK//mix2 + //fhistoList->Add(fhIphiAssocFromFile[hic][hia]); + cout<<"c=" << hic <<" as="<< hia <<" entries="<< fhIetaAssocFromFile[hic][hia]->GetEntries() <GetNoOfBins(kCentrType); + int numPtt = fCard->GetNoOfBins(kTriggType); + int numPta = fCard->GetNoOfBins(kAssocType); + int numEtaGaps = fCard->GetNoOfBins(kEtaGapType); + int numZvtx = fCard->GetNoOfBins(kZVertType); + + //------------ R e a d mixed D a t a ------------ + const int zFirstBin = 0 ; + const int etaGapFirstBin = 0 ; + for (int hic = 0;hic < numCent; hic++) { + for (int hit = 0; hit < numPtt;hit++){ + for (int hia = 0; hia < numPta; hia++){ + fhDEtaNearMixFromFile[hic][hit][hia]= (TH1D*) inclusFile->Get(Form("hDEtaNear/hDEtaNear%02d%02d%02d%02d%02d%02d", 1, hic, zFirstBin, etaGapFirstBin, hit, hia)); + for (int iEtaGap=0; iEtaGap < numEtaGaps; iEtaGap++){//fdphi slices + for (int hiz = 0; hiz < numZvtx; hiz++) { + if( iEtaGap==etaGapFirstBin && hiz==zFirstBin ) continue; + TH1D *hid = (TH1D*) inclusFile->Get(Form("hDEtaNear/hDEtaNear%02d%02d%02d%02d%02d%02d", 1, hic, hiz, iEtaGap, hit, hia)); + fhDEtaNearMixFromFile[hic][hit][hia]->Add(hid); + } + } + //normalize to traingle + double counts = fhDEtaNearMixFromFile[hic][hit][hia]->Integral(); + double bw = fhDEtaNearMixFromFile[hic][hit][hia]->GetBinWidth(1); + int rebin = 4; + if(counts<5000) rebin=8; + if(counts<3000) rebin=10; + if(counts<1000) rebin=16; + fhDEtaNearMixFromFile[hic][hit][hia]->Rebin(rebin); + if(counts>0) fhDEtaNearMixFromFile[hic][hit][hia]->Scale(2.*fmaxEtaRange/counts/bw/rebin);//triangle f(0)=1, f(1.6)=0 + //if(counts>0) fhDEtaNearMixFromFile[hic][hit][hia]->Scale(2.*fmaxEtaRange/counts/bw); + //cout<<"c=" << hic <<" as="<< hia <<" entries="<< fhDEtaNearMixFromFile[hic][hit][hia]->GetEntries() <GetNoOfBins(kCentrType);hic++) { + // for (int hit = 0; hit < fCard->GetNoOfBins(kTriggType);hit++){ + // for (int hia = 0; hia < fCard->GetNoOfBins(kAssocType); hia++){ + // hDphiAssocMixSpectraFile[hic][hit][hia]= (TH1D*) inclusFile->Get(Form("xhDphiAssoc%02dC%02dE00T%02dA%02d",1, hic, hit, hia));//FK//mix2 + // } + // } + //} +} diff --git a/PWGCF/Correlations/JCORRAN/AliJHistos.h b/PWGCF/Correlations/JCORRAN/AliJHistos.h new file mode 100644 index 00000000000..54077485410 --- /dev/null +++ b/PWGCF/Correlations/JCORRAN/AliJHistos.h @@ -0,0 +1,334 @@ +/* Copyright(c) 1998-2014, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +// Short comment describing what this class does needed! + +//=========================================================== +// AliJHistos.h +// +// J +//=========================================================== + +#ifndef ALIJHISTOS_H +#define ALIJHISTOS_H + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include "AliJConst.h" +#include "AliJHistManager.h" + +class AliJCard; +class AliJBaseTrack; +class AliJPhoton; +class AliJTrack; + +using namespace std; + +inline ostream &operator << (ostream &out_file, const TLorentzVector &Vec) +{ + out_file<<"Px="< +#endif + +#include +#include +#include +#include "AliJConst.h" +#include "AliJBaseTrack.h" + +using namespace std; + +class AliJJet : public AliJBaseTrack { +public: + AliJJet(); + AliJJet(float px,float py, float pz, float e, Int_t id, Short_t ptype, Char_t charge); // constructor + AliJJet(const AliJJet& a); + AliJJet(const TLorentzVector & a); + virtual ~AliJJet(){; } //destructor + AliJJet& operator=(const AliJJet& trk); + + void SetArea(double a){ fArea = a; } + Double_t GetArea() const{ return fArea; } + Double_t Area() const{ return fArea; } + void AddConstituent(TObject* t){ fConstituents.Add(t); } + TObjArray* GetConstituents(){ return &fConstituents; } + AliJBaseTrack * GetConstituent(int i) const{ return (AliJBaseTrack*)fConstituents[i]; } + +private: + Double_t fArea; // Area of the jet + TObjArray fConstituents; // Constituent tracks of the jets + + ClassDef(AliJJet,1) +}; +#endif diff --git a/PWGCF/Correlations/JCORRAN/AliJMCTrack.cxx b/PWGCF/Correlations/JCORRAN/AliJMCTrack.cxx old mode 100755 new mode 100644 index b4b96a17d69..19c111a8625 --- a/PWGCF/Correlations/JCORRAN/AliJMCTrack.cxx +++ b/PWGCF/Correlations/JCORRAN/AliJMCTrack.cxx @@ -1,5 +1,5 @@ /************************************************************************** - * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * Copyright(c) 1998-2014, ALICE Experiment at CERN, All rights reserved. * * * * Author: The ALICE Off-line Project. * * Contributors are mentioned in the code where appropriate. * @@ -7,12 +7,14 @@ * 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 notifce * + * 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. * **************************************************************************/ +// Comment describing what this class does needed! + // $Id: AliJMCTrack.cxx,v 1.2 2008/05/08 13:44:45 djkim Exp $ //////////////////////////////////////////////////// @@ -42,8 +44,8 @@ AliJMCTrack::AliJMCTrack() : fVz(0) { // default constructor - fMother[0] = fMother[1] = 0; - fDaughter[0] = fDaughter[1] = 0; + fMother[0] = fMother[1] = -1; + fDaughter[0] = fDaughter[1] = -1; } @@ -69,8 +71,8 @@ void AliJMCTrack::SetPdgCode(Int_t icode) { // Set PDG code, charge, recalculate E if( TMath::Abs(icode) > 32767 ) icode = 0; // Short_t fPdgCode=icode; - SetVectM(Vect(), GetPDGData().Mass()); - SetCharge( TMath::Nint(GetPDGData().Charge()) ); // is this right? +// SetVectM(Vect(), GetPDGData().Mass()); +// SetCharge( TMath::Nint(GetPDGData().Charge()) ); // is this right? } diff --git a/PWGCF/Correlations/JCORRAN/AliJMCTrack.h b/PWGCF/Correlations/JCORRAN/AliJMCTrack.h old mode 100755 new mode 100644 index 4fc4e073f04..df27e44eab5 --- a/PWGCF/Correlations/JCORRAN/AliJMCTrack.h +++ b/PWGCF/Correlations/JCORRAN/AliJMCTrack.h @@ -1,3 +1,8 @@ +/* Copyright(c) 1998-2014, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +// Short comment describing what this class does needed! + // $Id: AliJMCTrack.h,v 1.3 2008/05/08 15:19:52 djkim Exp $ //////////////////////////////////////////////////// @@ -26,15 +31,15 @@ class AliJMCTrack : public AliJBaseTrack { public: - enum { kPrimary=AliJBaseTrack::kNFlag, kPHOS, kEMCAL, kTPC, kNFlag };//For ALICE + enum { kPrimary=AliJBaseTrack::kNFlag, kPHOS, kEMCAL, kTPC, kInjected, kNFlag };//For ALICE enum { kFinal=AliJBaseTrack::kNFlag };// for MC //usage : this->SetFlag( kPrimary, kTRUE ); //usage : this->IsTrue( kFinal ); - AliJMCTrack(); //default constructor - AliJMCTrack(const AliJMCTrack& a); //copy constructor + AliJMCTrack(); //default constructor + AliJMCTrack(const AliJMCTrack& a); //copy constructor - ~AliJMCTrack(){;} //destructor + ~AliJMCTrack(){;} //destructor Int_t GetPdgCode() const {return fPdgCode;} Int_t GetMother (Int_t i) const {return fMother[i];} @@ -60,7 +65,7 @@ class AliJMCTrack : public AliJBaseTrack { //TODO Bool_t IsHadron() const; Bool_t IsCharged() const { return GetCharge(); } - Bool_t IsParton() const {return ( fPdgCode < -7 && fPdgCode < 7 && fPdgCode !=0 );} + Bool_t IsParton() const {return ( fPdgCode > -7 && fPdgCode < 7 && fPdgCode !=0 );} private: diff --git a/PWGCF/Correlations/JCORRAN/AliJPhoton.cxx b/PWGCF/Correlations/JCORRAN/AliJPhoton.cxx index 4b6b036cb7d..35068cd0973 100644 --- a/PWGCF/Correlations/JCORRAN/AliJPhoton.cxx +++ b/PWGCF/Correlations/JCORRAN/AliJPhoton.cxx @@ -1,3 +1,20 @@ +/************************************************************************** + * Copyright(c) 1998-2014, 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. * + **************************************************************************/ + +// Comment describing what this class does needed! + // $Id: AliJPhoton.cxx,v 1.4 2008/05/08 13:44:45 djkim Exp $ //////////////////////////////////////////////////// @@ -13,7 +30,7 @@ #include "AliJBaseTrack.h" #include "AliJPhoton.h" -#include "TF1.h" +#include ClassImp(AliJPhoton); //______________________________________________________________________________ @@ -33,10 +50,19 @@ AliJPhoton::AliJPhoton() : fM20(-999), fM02(-999), fEmcCpvDist(-999), - fNCells(0), + fNCells(-999), + fNTracksMatched(-999), fSuperModuleId(-999), fCellsAbsId(0x0), - fCellsAmpFraction(0x0) + fCellsAmpFraction(0x0), + fNEMCLabel(0), + fEMCLabel(0x0), + fEMax(-999), + fECross(-999), + fECore(-999), + fNLM(-999), + fCellsIndex(0x0) +// fCellsAmp(0x0) { // default constructor @@ -63,15 +89,48 @@ AliJPhoton::AliJPhoton(const AliJPhoton& a) : fM02(a.fM02), fEmcCpvDist(a.fEmcCpvDist), fNCells(a.fNCells), + fNTracksMatched(a.fNTracksMatched), fSuperModuleId(a.fSuperModuleId), fCellsAbsId(NULL), - fCellsAmpFraction(NULL) + fCellsAmpFraction(NULL), + fNEMCLabel(a.fNEMCLabel), + fEMCLabel(NULL), + fEMax(a.fEMax), + fECross(a.fECross), + fECore(a.fECore), + fNLM(a.fNLM), + fCellsIndex(NULL) +// fCellsAmp(NULL) { //copy constructor for(Int_t i=0;i wPhoton) pdg = AliJConst::kPhoton ; - else if(fCaloPID[kPi0Ali] > wPi0) pdg = AliJConst::kPizero ; + if(fCaloPID[kPhotonAli] > wPhoton) pdg = kPhoton ; + else if(fCaloPID[kPi0Ali] > wPi0) pdg = kPizero ; //else if(fCaloPID[kElectronAli] > wElectron) pdg = electron ; //else if(fCaloPID[kEleConAli] > wElectron) pdg = electronCon ; //else if(chargedHadronWeight > wCharged) pdg = chargedHadron ; @@ -193,8 +331,8 @@ AliJConst::particleType AliJPhoton::GetParticleType() { } else{//EMCAL //Temporal solution, electrons and photons not differenciated - if(fCaloPID[kPhotonAli] + fCaloPID[kElectronAli] > wPhoton) pdg = AliJConst::kPhoton ; - else if(fCaloPID[kPi0Ali] > wPi0) pdg = AliJConst::kPizero ; + if(fCaloPID[kPhotonAli] + fCaloPID[kElectronAli] > wPhoton) pdg = kPhoton ; + else if(fCaloPID[kPi0Ali] > wPi0) pdg = kPizero ; //else if(chargedHadronWeight + neutralHadronWeight > wCharged) pdg = chargedHadron ; //else if(neutralHadronWeight + chargedHadronWeight > wNeutral) pdg = neutralHadron ; //else pdg = neutralUnknown ; diff --git a/PWGCF/Correlations/JCORRAN/AliJPhoton.h b/PWGCF/Correlations/JCORRAN/AliJPhoton.h index be56dbadc30..f967bdb22e2 100644 --- a/PWGCF/Correlations/JCORRAN/AliJPhoton.h +++ b/PWGCF/Correlations/JCORRAN/AliJPhoton.h @@ -1,3 +1,8 @@ +/* Copyright(c) 1998-2014, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +// Short comment describing what this class does needed! + // $Id: AliJPhoton.h,v 1.5 2008/05/08 15:19:52 djkim Exp $ //////////////////////////////////////////////////// @@ -25,8 +30,8 @@ class AliJPhoton : public AliJBaseTrack { public: enum AliJCaloType { kUndef = -1, - kPHOSCalo, - kEMCALCalo + kPHOSCalo, + kEMCALCalo }; enum AliJCaloPID{ @@ -35,79 +40,115 @@ class AliJPhoton : public AliJBaseTrack { kPionAli = 2, kKaonAli = 3, kProtonAli = 4, - kPhotonAli = 5, - kPi0Ali = 6, - kNeutronAli = 7, - kKaon0Ali = 8, - kEleConAli = 9, - kUnknownAli = 10 + kDeuteronAli = 5, + kTritonAli = 6, + kHe3Ali = 7, + kAlpha = 8, + kPhotonAli = 9, + kPi0Ali = 10, + kNeutronAli = 11, + kKaon0Ali = 12, + kEleConAli = 13, + kUnknownAli = 14 }; + enum { kIsConversion=AliJBaseTrack::kNFlag, kNFlag }; - AliJPhoton(); //default constructor + AliJPhoton(); //default constructor AliJPhoton(const AliJPhoton& a); //copy constructor - virtual ~AliJPhoton(){ //destructor - if(fCellsAbsId) delete [] fCellsAbsId; - if(fCellsAmpFraction) delete [] fCellsAmpFraction; - } + virtual ~AliJPhoton(); //destructor + + void Clear( Option_t * /* option */ ); // cleaner - float GetChi2() const {return fChi2;} - float GetTof() const {return fTof;} - float GetX() const {return fX;} - float GetY() const {return fY;} - float GetZ() const {return fZ;} - float GetProbPhot() const {return fProbPhot;} + Double32_t GetChi2() const {return fChi2;} + Double32_t GetTof() const {return fTof;} + Double32_t GetX() const {return fX;} + Double32_t GetY() const {return fY;} + Double32_t GetZ() const {return fZ;} + Double32_t GetProbPhot() const {return fProbPhot;} - void SetChi2(float chi2) {fChi2=chi2;} - void SetTof(float tof) {fTof=tof;} - void SetPositionX(float x) {fX=x;} - void SetPositionY(float y) {fY=y;} - void SetPositionZ(float z) {fZ=z;} - void SetProbPhot(float prob) {fProbPhot=prob;} + void SetChi2(Double32_t chi2) {fChi2=chi2;} + void SetTof(Double32_t tof) {fTof=tof;} + void SetPositionX(Double32_t x) {fX=x;} + void SetPositionY(Double32_t y) {fY=y;} + void SetPositionZ(Double32_t z) {fZ=z;} + void SetProbPhot(Double32_t prob) {fProbPhot=prob;} AliJPhoton& operator=(const AliJPhoton& photon); //TODO - Bool_t InPHOS() const {return fCaloType==kPHOSCalo ? kTRUE:kFALSE ;} - Bool_t InEMCAL() const {return fCaloType==kEMCALCalo ? kTRUE:kFALSE ;} + Bool_t IsPHOS() const {return fCaloType==kPHOSCalo ? kTRUE:kFALSE ;} + Bool_t IsEMCAL() const {return fCaloType==kEMCALCalo ? kTRUE:kFALSE ;} // getters void GetPID(Double_t *pid) const { for(Int_t i=0; i=0 && i < fNCells ) return fCellsAbsId[i]; else return -1;} Double32_t *GetCellsAmplitudeFraction() const {return fCellsAmpFraction;} - Double_t GetCellAmplitudeFraction(Int_t i) const { + Double32_t GetCellAmplitudeFraction(Int_t i) const { if (fCellsAmpFraction && i >=0 && i < fNCells ) return fCellsAmpFraction[i]; else return -1;} - AliJConst::particleType GetParticleType(); + Int_t GetNEMCLabel() const {return fNEMCLabel;} + Int_t GetEMCLabel( Int_t pos = 0 ) const { + if( fEMCLabel && pos >= 0 && pos < fNEMCLabel ) return fEMCLabel[pos]; + else return -1;} +// Double32_t *GetCellsAmplitude() const {return fCellsAmp;} +// Double32_t GetCellAmplitude(Int_t i) const { +// if (fCellsAmp && i >=0 && i < fNCells ) return fCellsAmp[i]; +// else return -1;} + particleType GetParticleType(); Int_t GetSuperModuleID() const { return fSuperModuleId; } void SetSuperModuleID(Int_t id) { fSuperModuleId = id; } Double32_t GetTrackDx() const {return fTrackDx;} Double32_t GetTrackDz() const {return fTrackDz;} + Double32_t GetEMax() const {return fEMax;} + Double32_t GetECross() const {return fECross;} + Double32_t GetECore() const {return fECore;} + Int_t GetNLM() const {return fNLM;} + Int_t *GetCellsIndex() const {return fCellsIndex; } + Int_t GetCellIndex(Int_t i) const { + if (fCellsIndex && i >=0 && i < fNCells ) return fCellsIndex[i]; + else return -1;} //setters void SetCaloType(AliJCaloType calo) {fCaloType = calo;} - void SetDistToBadChannel(Double_t dist) {fDistToBadChannel = dist;} - void SetDispersion(Double_t disp) {fDispersion = disp;} - void SetM20(Double_t m20) {fM20 = m20;} - void SetM02(Double_t m02) {fM02 = m02;} - void SetEmcCpvDist(Double_t dist) {fEmcCpvDist = dist;} - void SetPID(const Double_t *pid); + void SetDistToBadChannel(Double32_t dist) {fDistToBadChannel = dist;} + void SetDispersion(Double32_t disp) {fDispersion = disp;} + void SetM20(Double32_t m20) {fM20 = m20;} + void SetM02(Double32_t m02) {fM02 = m02;} + void SetEmcCpvDist(Double32_t dist) {fEmcCpvDist = dist;} + void SetPID(const Double32_t *pid); void SetNCells(Int_t n) { fNCells = n;} + void SetNTracksMatched( Int_t n ) { fNTracksMatched = n;} void SetCellsAbsId(const UShort_t *array); void SetCellsAmplitudeFraction(const Double32_t *array); - void SetTrackDx(Double_t trackDx) {fTrackDx = trackDx;} - void SetTrackDz(Double_t trackDz) {fTrackDz = trackDz;} + void SetNEMCLabel(Int_t n) { fNEMCLabel = n;} + void SetEMCLabel(const Int_t *array); + void SetEMCLabel(const Int_t pos, const Int_t lab) { + if( fEMCLabel && pos >= 0 && pos < fNEMCLabel ) + fEMCLabel[pos] = lab; } +// void SetCellsAmplitude(const Double32_t *array); + void SetTrackDx(Double32_t trackDx) {fTrackDx = trackDx;} + void SetTrackDz(Double32_t trackDz) {fTrackDz = trackDz;} + void SetEMax(Double32_t e) {fEMax = e; } + void SetECross(Double32_t e) {fECross = e; } + void SetECore(Double32_t e) {fECore = e; } + void SetNLM( Int_t n ) {fNLM = n;} + void SetCellIndex( const Int_t pos, const Int_t ind ); + void SetCellsIndex(const Int_t *array); + + void ClearCellsIndex(); private: @@ -119,19 +160,30 @@ class AliJPhoton : public AliJBaseTrack { //TODO AliJCaloType fCaloType; // PHOS or EMCAL photon - Double_t fCaloPID[kUnknownAli+1]; // [0.,1.,8] pointer to PID object - Double_t fDistToBadChannel; // Distance to nearest bad channel - Double_t fDispersion; // cluster dispersion, for shape analysis - Double_t fM20; // 2-nd moment along the main eigen axis - Double_t fM02; // 2-nd moment along the second eigen axis - Double_t fEmcCpvDist; // the distance from PHOS EMC rec.point to the closest CPV rec.point + Double32_t fCaloPID[kUnknownAli+1]; // [0.,1.,8] pointer to PID object + Double32_t fDistToBadChannel; // Distance to nearest bad channel + Double32_t fDispersion; // cluster dispersion, for shape analysis + Double32_t fM20; // 2-nd moment along the main eigen axis + Double32_t fM02; // 2-nd moment along the second eigen axis + Double32_t fEmcCpvDist; // the distance from PHOS EMC rec.point to the closest CPV rec.point Int_t fNCells ; //number of cells + Int_t fNTracksMatched; // number of tracks matched Int_t fSuperModuleId ; //super module id UShort_t *fCellsAbsId; //[fNCells] array of cell absId numbers - Double32_t *fCellsAmpFraction; //[fNCells][0.,1.,16] array with cell amplitudes fraction. - - ClassDef(AliJPhoton,1) + Double32_t *fCellsAmpFraction; //[fNCells][0.,1.,16] array with cell amplitudes fraction (elements are 0 if unfolding off) +// Double32_t *fCellsAmp; //[fNCells] array amplitudes of cluster cellsz + Int_t fNEMCLabel; // number of MC labels + Int_t *fEMCLabel; //[fNEMCLabel] MC labels + + // analysis time variables + Double32_t fEMax; //! maximum cell energy + Double32_t fECross; //! energy of cells in cross around max + Double32_t fECore; //! central cells energies + Int_t fNLM; //! number of local maxima + Int_t *fCellsIndex; //! cell indices in cell list + + ClassDef(AliJPhoton,2) }; diff --git a/PWGCF/Correlations/JCORRAN/AliJPiZero.cxx b/PWGCF/Correlations/JCORRAN/AliJPiZero.cxx new file mode 100644 index 00000000000..5f406bbbb20 --- /dev/null +++ b/PWGCF/Correlations/JCORRAN/AliJPiZero.cxx @@ -0,0 +1,185 @@ +/************************************************************************** + * Copyright(c) 1998-2014, 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. * + **************************************************************************/ + +// Comment describing what this class does needed! + +// $Id: AliJPiZero.cxx,v 1.3 2008/05/08 13:44:45 djkim Exp $ + +//////////////////////////////////////////////////// +/*! + \file AliJPiZero.cxx + \brief + \author J. Rak, D.J.Kim, R.Diaz (University of Jyvaskyla) + \email: djkim@jyu.fi + \version $Revision: 1.3 $ + \date $Date: 2008/05/08 13:44:45 $ +*/ +//////////////////////////////////////////////////// +#include +#include +#include +#include +#include +#include + +#include "AliJBaseTrack.h" +#include "AliJPhoton.h" + +#include "AliJPiZero.h" + + + +AliJPiZero::AliJPiZero(): + AliJBaseTrack(), + fAsymm(-999), + fMassBin(-999), + fIsGood(kFALSE), + fConvPlaneDelta(-999), + fPtBin(-1) +{ + //constructor + fPhoton[0] = 0; + fPhoton[1] = 0; +} +//______________________________________________________________________________ +AliJPiZero::AliJPiZero(const AliJPiZero& a): + AliJBaseTrack(a), + fAsymm(a.fAsymm), + fMassBin(a.fMassBin), + fIsGood(a.fIsGood), + fConvPlaneDelta(a.fConvPlaneDelta), + fPtBin(a.fPtBin) +{ + //copy constructor + fPhoton[0] = a.fPhoton[0]; + fPhoton[1] = a.fPhoton[1]; +} + +AliJPiZero& AliJPiZero::operator=(const AliJPiZero& pizero){ + //copy constructor + AliJBaseTrack::operator=(pizero); + fAsymm = pizero.fAsymm; + fMassBin = pizero.fMassBin; + fIsGood = pizero.fIsGood; + fPhoton[0] = pizero.fPhoton[0]; + fPhoton[1] = pizero.fPhoton[1]; + fConvPlaneDelta = pizero.fConvPlaneDelta; + fPtBin = pizero.fPtBin; + + return *this; +} + + +//______________________________________________________________________________ + +bool AliJPiZero::SetMass(AliJPhoton *g1, AliJPhoton *g2){ + //set pi0 four-momentum, assddymetry, inv. mass, pT, phi, theta, energy + + fAsymm = TMath::Abs((g1->E()-g2->E())/(g1->E()+g2->E())); + *(TLorentzVector*)this = *(TLorentzVector*)g1 + *(TLorentzVector*)g2; + + fPhoton[0] = g1; + fPhoton[1] = g2; + +// Double_t pimass; +// pimass = TMath::Sqrt( 2. * g1->E() * g2->E() * +// ( 1. - TMath::Cos( g1->Angle( g2->Vect() )))); + + return true; +} + +double AliJPiZero::DeltaConversion(){ + // check pair plane vector delta from expected conversion pair plain + + TVector3 pplain, phot1, phot2, pplaint, cplain, zplain, convplane; + + // pair vector in the pair plane + pplain = Vect(); +// cout << "-------------------" << endl; +// pplain.Print(); + + // perpendicular to the plane + phot1 = fPhoton[0]->Vect(); + phot2 = fPhoton[1]->Vect(); + pplaint = phot1.Cross( phot2 ); +// pplaint.Print(); + + // get the pair plane vector + cplain = pplain.Cross( pplaint ).Unit(); +// cplain.Print(); + + // z plane vector + zplain.SetXYZ( 0, 0, 1 ); +// zplain.Print(); + + // expected conversion plane vector + convplane = pplain.Cross( zplain ).Unit(); +// convplane.Print(); + + // get the plane vector cosine similarity + // both vectors must be unit for this to work + fConvPlaneDelta = TMath::Abs( TMath::ACos( cplain.Dot( convplane ))); +// cout << fConvPlaneDelta << endl; + + // the result comes out in 0,pi range. Depending on how the z plane vector + // was chosen (2 options). Merge the results into 0,1/2pi range + if( fConvPlaneDelta > TMath::Pi() / 2. ) + fConvPlaneDelta = TMath::Pi() - fConvPlaneDelta; + + return fConvPlaneDelta; +} + + + +//______________________________________________________________________________ + +// double AliJPiZero::operator- (const AliJPiZero &pi0){ +// +// //======================================== +// // retruns the closest distance between +// // photon hits bolonging to two pi0 +// //======================================== +// +// TLorentzVector v; +// double d = 1e3; +// v = fPhoton1 - pi0.fPhoton1; +// if(v.M() < d) d = v.M(); +// v = fPhoton2 - pi0.fPhoton2; +// if(v.M() < d) d = v.M(); +// v = fPhoton1 - pi0.fPhoton2; +// if(v.M() < d) d = v.M(); +// v = fPhoton2 - pi0.fPhoton2; +// if(v.M() < d) d = v.M(); +// return d; +// } +// +// //______________________________________________________________________________ +// AliJPiZero& AliJPiZero::operator= (const AliJPiZero& piz){ +// //operator= +// if(this != &piz){ +// AliJBaseTrack::operator=(piz); +// fPhoton1 = piz.fPhoton1; +// fPhoton2 = piz.fPhoton2; +// PhotSum = fPhoton1 + fPhoton2; +// fAsymm = piz.fAsymm; +// fMassBin = piz.fMassBin; +// } +// +// return *this; +// } + + + +ClassImp(AliJPiZero) diff --git a/PWGCF/Correlations/JCORRAN/AliJPiZero.h b/PWGCF/Correlations/JCORRAN/AliJPiZero.h new file mode 100644 index 00000000000..ced2de3e154 --- /dev/null +++ b/PWGCF/Correlations/JCORRAN/AliJPiZero.h @@ -0,0 +1,85 @@ +/* Copyright(c) 1998-2014, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +// Short comment describing what this class does needed! + +// $Id: AliJPiZero.h,v 1.4 2008/05/08 15:19:52 djkim Exp $ + +//////////////////////////////////////////////////// +/*! + \file AliJPiZero.h + \brief + \author J. Rak, D.J.Kim, R.Diaz (University of Jyvaskyla) + \email: djkim@jyu.fi + \version $Revision: 1.4 $ + \date $Date: 2008/05/08 15:19:52 $ + */ +//////////////////////////////////////////////////// + +#ifndef ALIJPIZERO_H +#define ALIJPIZERO_H + +#ifndef ROOT_TObject +#include +#endif + +#include +#include + +class AliJBaseTrack; +class AliJPhoton; +// #include "AliJBaseTrack.h" +// #include "AliJPhoton.h" + +//class AliJPhoton; +//class TObject; + +class AliJPiZero : public AliJBaseTrack { + + public: + AliJPiZero(); + virtual ~AliJPiZero(){;} //destructor + AliJPiZero(const AliJPiZero& a);//{PhotSum.SetPxPyPzE(0,0,0,0);} //constructor + AliJPiZero& operator=(const AliJPiZero& pizero); + + bool SetMass(AliJPhoton* g1, AliJPhoton* g2); + + float GetInvMass() const {return M();} + float GetAsymm() const {return fAsymm;} + + int GetMassBin() const {return fMassBin;} + void SetMassBin(int im) {fMassBin=im;} + void ResetToZero() {SetPxPyPzE(0, 0, 0, 0);fAsymm=0; fMassBin=-1; fIsGood=kFALSE; fConvPlaneDelta=-999; fPtBin=-1;} + AliJPhoton *GetPhoton( Int_t i ) const { return fPhoton[i]; } + void SetGood( Bool_t b ) { fIsGood = b;} + Bool_t GetGood() const { return fIsGood; } + void SetConvPlaneDelta( Double_t d ) {fConvPlaneDelta = d; } + Double_t GetConvPlaneDelta() const { return fConvPlaneDelta; } + void SetPtBin( Int_t b ) { fPtBin = b; } + Int_t GetPtBin() const { return fPtBin; } + + Double_t Theta() { return fPhoton[0]->Angle( fPhoton[1]->Vect() ); } + Double_t DPhi() { return TMath::Abs( fPhoton[0]->Phi() - fPhoton[1]->Phi() ); } + Double_t DZ() { return TMath::Abs( fPhoton[0]->GetZ() - fPhoton[1]->GetZ() ); } + + TVector3 GetP() const {return Vect();} + TLorentzVector GetSum() const {return *(TLorentzVector*)this;} + + double DeltaConversion(); + +// double operator- (const AliJPiZero &pi0); +// AliJPiZero& operator= (const AliJPiZero& piz); + + protected: + float fAsymm; //assymtery and inv. mass + int fMassBin; //mass bin + Bool_t fIsGood; //! + AliJPhoton *fPhoton[2]; //! + Double_t fConvPlaneDelta; //! plane delta form conversion plane + Int_t fPtBin; //! pt bin + + ClassDef(AliJPiZero,1) +}; + +#endif + diff --git a/PWGCF/Correlations/JCORRAN/AliJRunHeader.cxx b/PWGCF/Correlations/JCORRAN/AliJRunHeader.cxx old mode 100755 new mode 100644 index 27f8b136d13..4db4bcf03a1 --- a/PWGCF/Correlations/JCORRAN/AliJRunHeader.cxx +++ b/PWGCF/Correlations/JCORRAN/AliJRunHeader.cxx @@ -1,5 +1,5 @@ /************************************************************************** - * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * Copyright(c) 1998-2014, ALICE Experiment at CERN, All rights reserved. * * * * Author: The ALICE Off-line Project. * * Contributors are mentioned in the code where appropriate. * @@ -7,22 +7,24 @@ * 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 notifce * + * 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. * **************************************************************************/ +// Comment describing what this class does needed! + // $Id: AliJRunHeader.cxx,v 1.1 2008/02/04 13:28:47 rak Exp $ //////////////////////////////////////////////////// // -// \file AliJRunHeader.cxx -// \brief -// \author J. Rak, D.J.Kim, F.Krizek(University of Jyvaskyla) -// \email: djkim@cc.jyu.fi -// \version $Revision: 1.1 $ -// \date $Date: 2008/02/04 13:28:47 $ +// \file AliJRunHeader.cxx +// \brief +// \author J. Rak, D.J.Kim, F.Krizek(University of Jyvaskyla) +// \email: djkim@cc.jyu.fi +// \version $Revision: 1.1 $ +// \date $Date: 2008/02/04 13:28:47 $ // // Class encapsulation aliroot run header information //////////////////////////////////////////////////// @@ -34,96 +36,67 @@ ClassImp(AliJRunHeader); //---------------------------- AliJRunHeader::AliJRunHeader(): - TNamed("AliJRunHeader", ""), - fRunNumber(-1), - fRunType(""), - fESDInfo(""), - fL3MagnetPolarity(0), - fMagneticFieldL3(0), - fActiveTriggersAlice(), - fSizeOfTableJCorran(0), -// fAliceTriggerDef(), - fActiveTriggersJCorran(), - fAliceTriggerDef(), - fAliceFilterMapDef() +TNamed("AliJRunHeader", ""), +//==== General Info ====// +fRunNumber(0), +fRunType(""), +fBeamType(""), +fBeamTypeI(-1), +fBeamEnergy(0), +fIsMC(kFALSE), +//==== Production Info ====// +fInputFormat(-1), +fWithoutSDD(kFALSE), +fStoreEventPlaneSource(kFALSE), +fStoreEMCalInfo(kFALSE), +fStoreTPCTrackBitMask(0), +fStoreGCGTrackBitMask(0), +fESDInfo(""), +fRefitESDVertexTracks(false), +//==== Detector Status ====// +fL3MagnetPolarity(0), +fMagneticFieldL3(0), +fCurrentL3(0), +fCurrentDip(0), +fUniformBMap(kFALSE), +//==== Trigger Information ====// +fFiredTriggers(0), +fTriggerMask(0), +fTriggerCluster(0), +fSizeOfTableJCorran(0), +fActiveTriggersJCorran(kRangeTriggerTableJCorran,""), +fActiveTriggersAlice(kRangeTriggerTableAlice,"") { //constructor - - for(Int_t i=0;iSetString(triggers[t].Data()); - } - - fActiveTriggersAlice.SetOwner(kTRUE); -} -//________________________________________________________________________ - -void AliJRunHeader::SetActiveTriggersJCorran(const TString *triggers, Int_t range){ - //fill jcorran trigger table - for(Int_t t=0;tSetString(triggers[t].Data()); - } - fActiveTriggersJCorran.SetOwner(kTRUE); - fSizeOfTableJCorran = range; } -//________________________________________________________________________ Int_t AliJRunHeader::GetActiveTriggerBitAlice(TString TriggerName){ //get trigger bit corresponding to trigger name - Int_t tbit=-1; - for(Int_t t=0;tGetString())){ - tbit = t; - break; + for(UInt_t t=0;t "<& GetAliceTriggerDef() const { return fAliceTriggerDef; } - ULong64_t GetAliceTriggerDef( const TString name ) const { return GetBitMaskDef( fAliceTriggerDef, name); } - void AddAliceTriggerDef( const TString name, const ULong64_t mask){ fAliceTriggerDef[name]=mask; } - void RemoveAliceTriggerDef( const TString name){ fAliceTriggerDef.erase(name); } - - //--- Alice track FilterMap by BS like "kEsdTrackCutsL" - const std::map& GetAliceFilterMapDef() const { return fAliceFilterMapDef; } - ULong64_t GetAliceFilterMapDef( const TString name ) const { return GetBitMaskDef( fAliceFilterMapDef, name); } - void AddAliceFilterMapDef( const TString name, const ULong64_t mask){ fAliceFilterMapDef[name]=mask; } - void RemoveAliceFilterMapDef( const TString name){ fAliceFilterMapDef.erase(name); } - - //--- Common Method to handle BitMask Definition ( map ) - ULong64_t GetBitMaskDef( std::map def, const TString name ) const{ - std::map::iterator _iter = def.find(name); - //iter = def.find(name); - if( _iter == def.end() ){ return 0; } - else{ return _iter->second; } - } - - //-- Alice trigger table -- by Filip. "Trigger Class" like "+CMBACS2-B-NOPF-ALL" - void SetActiveTriggersAlice( const TString *triggers); - Int_t GetActiveTriggerBitAlice(TString TriggerName); - TString GetActiveTriggerAlice(Int_t TriggerBit) const { - return ((TObjString*) (fActiveTriggersAlice.At(TriggerBit)))->GetString(); - } - - //-- JCorran trigger table -- by Filip - void SetActiveTriggersJCorran(const TString *triggers, Int_t range); - TString GetActiveTriggerJCorran(Int_t TriggerBit) const { - return ((TObjString*) (fActiveTriggersJCorran.At(TriggerBit)))->GetString(); - } - - AliJRunHeader& operator=(const AliJRunHeader& header); + Bool_t GetRefitESDVertexTracks() const { return fRefitESDVertexTracks; } + void SetRefitESDVertexTracks( Bool_t refit ){ fRefitESDVertexTracks=refit; } + + //==== Detector Status ====// + Short_t GetL3MagnetFieldPolarity() const { return fL3MagnetPolarity; } + void SetL3MagnetFieldPolarity(Short_t p){ fL3MagnetPolarity=p; } + + Double_t GetL3MagnetFieldIntensity() const { return fMagneticFieldL3; } + void SetL3MagnetFieldIntensity(Double_t i) { fMagneticFieldL3=i; } + + Float_t GetCurrentL3() const { return fCurrentL3; } + void SetCurrentL3(Float_t current){ fCurrentL3 = current; } + + Float_t GetCurrentDip() const { return fCurrentDip; } + void SetCurrentDip(Float_t dip){ fCurrentDip=dip; } + + Bool_t IsUniformBMap() const { return fUniformBMap; } + void SetUniformBMap(Bool_t uniform){ fUniformBMap=uniform; } + + //==== Trigger Information ====// + TString GetFiredTriggers()const{ return fFiredTriggers; } + void SetFiredTriggers( TString trgs ){ fFiredTriggers=trgs; } + + ULong64_t GetTriggerMask()const{ return fTriggerMask; } + void SetTriggerMask( ULong64_t mask ){ fTriggerMask=mask; } + + UChar_t GetTriggerCluster() const { return fTriggerCluster; } + void SetTriggerCluster( UChar_t cluster ){ fTriggerCluster=cluster; } + + Int_t GetSizeOfTableJCorran() const { return fSizeOfTableJCorran; } + void SetSizeOfTableJCorran( Int_t size ){ fSizeOfTableJCorran=size; } + + std::vector GetActiveTriggersJCorran() const { return fActiveTriggersJCorran; } + void SetActiveTriggersJCorran( std::vector strs ){ fActiveTriggersJCorran=strs; } + TString GetActiveTriggersJCorran(int i) const { return fActiveTriggersJCorran[i]; } + void SetActiveTriggersJCorran(int i, TString str){ fActiveTriggersJCorran[i]=str; } + + std::vector GetActiveTriggersAlice() const { return fActiveTriggersAlice; } + void SetActiveTriggersAlice( std::vector strs ){ fActiveTriggersAlice=strs; } + TString GetActiveTriggersAlice(int i) const { return fActiveTriggersAlice[i]; } + void SetActiveTriggersAlice(int i, TString str){ fActiveTriggersAlice[i]=str; } + Int_t GetActiveTriggerBitAlice(TString TriggerName); + + //==== GENERAL STUFF for Class ====// void PrintOut(); protected: + //==== General Info ====// Int_t fRunNumber; //run number TString fRunType; // ex) LHC10h + TString fBeamType; // beam type kJPP, kJPbPb, kJPPb + Int_t fBeamTypeI; // beam type kJPP, kJPbPb, kJPPb + Float_t fBeamEnergy; // beam energy + Bool_t fIsMC; // MC data or real data + + //==== Production Info ====// + Int_t fInputFormat; // specify the input data format (kJESD or kJAOD) + Bool_t fWithoutSDD; // is SDD detector used or not + Bool_t fStoreEventPlaneSource; // store event plane + Bool_t fStoreEMCalInfo; // store event plane + UInt_t fStoreTPCTrackBitMask; // TPC bit mask + UInt_t fStoreGCGTrackBitMask; // GCG bit maks TString fESDInfo; // information of aliroot, root version while esd production -// Char_t* fESDInfo; // information of aliroot, root version while esd production + Bool_t fRefitESDVertexTracks; // refit to ESD vertex tracks + + //==== Detector Status ====// Short_t fL3MagnetPolarity; //Polarity of magnetic filed in L3 magnet (LHC convention: + -> +Bz) Double32_t fMagneticFieldL3; //Solenoid Magnetic Field in kG - TObjArray fActiveTriggersAlice; //array maping between trigger bit and trigger names - - Int_t fSizeOfTableJCorran; //size of jcorran table -// std::map fAliceTriggerDef; //Alice event trigger definition by BS like "kMB", "kHighMulti" -// std::map fAliceFilterMapDef;//Alice track FilterMap by BS like "kEsdTrackCutsL" - - TObjArray fActiveTriggersJCorran; //array maping between trigger bit and trigger names + Float_t fCurrentL3; // L3 current + Float_t fCurrentDip; // dipole current + Bool_t fUniformBMap; // beam uniformity + + //==== Trigger Information ====// + TString fFiredTriggers; // String with fired triggers + ULong64_t fTriggerMask; // Trigger Type (mask) + UChar_t fTriggerCluster; // Trigger cluster (mask) + Int_t fSizeOfTableJCorran; //size of jcorran table + std::vector fActiveTriggersJCorran; //array maping between trigger bit and trigger names + std::vector fActiveTriggersAlice; //array maping between trigger bit and trigger names //TBit 0 = MB - std::map fAliceTriggerDef; //Alice event trigger definition by BS like "kMB", "kHighMulti" - std::map fAliceFilterMapDef;//Alice track FilterMap by BS like "kEsdTrackCutsL" - //std::map::iterator iter; - ClassDef(AliJRunHeader,2) + ClassDef(AliJRunHeader,3) }; #endif + diff --git a/PWGCF/Correlations/JCORRAN/AliJRunTable.cxx b/PWGCF/Correlations/JCORRAN/AliJRunTable.cxx new file mode 100644 index 00000000000..89718d051a6 --- /dev/null +++ b/PWGCF/Correlations/JCORRAN/AliJRunTable.cxx @@ -0,0 +1,208 @@ +/************************************************************************** + * Copyright(c) 1998-2014, 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. * + **************************************************************************/ + +// Comment describing what this class does needed! + +#include "AliJRunTable.h" + +#include +#include +#include +#include +using namespace std; + +AliJRunTable::AliJRunTable() : + fCPeriod(0), + fCRunNumber(0), + fCPeriodMCName("undefined") +{ + Init(); +} + +void AliJRunTable::Init(){ + // comment needed + SetPeriodInformation( kUnknownPeriod, "UnknownPeriod", kPP, kRE, 0, -1, -1, "UnKnownPeriod" ); + SetPeriodInformation( kLHC10b, "LHC10b", kPP, kRE, 7000, 114737, 117223, "LHC10d1" ); + SetPeriodInformation( kLHC10c, "LHC10c", kPP, kRE, 7000, 118503, 121040, "LHC10d4" ); + SetPeriodInformation( kLHC10d, "LHC10d", kPP, kRE, 7000, 122195, 126437, "LHC10f6a" ); + SetPeriodInformation( kLHC10e, "LHC10e", kPP, kRE, 7000, 127712, 130850, "LHC10e20" ); + SetPeriodInformation( kLHC10h, "LHC10h", kPbPb, kRE, 2760, 136851, 139517, "LHC11a10a_bis" ); + SetPeriodInformation( kLHC11h, "LHC11h", kPbPb, kRE, 2760, 167813, 170309, "LHC12a17d_fix" ); + + //LHC11a + SetPeriodInformation(kLHC11a, "LHC11a", kPP, kRE, 2760, 144871, 146860, "LHC11b10a" ); + + // pp 7TeV LHC11bcde + SetPeriodInformation( kLHC11b, "LHC11b", kPP, kRE, 7000, 0, 0, "LHC12d2_plus" ); + SetPeriodInformation( kLHC11c, "LHC11c", kPP, kRE, 7000, 153533, 154789, "LHC12d2_plus" ); + SetPeriodInformation( kLHC11d, "LHC11d", kPP, kRE, 7000, 156620, 159580, "LHC12d2_plus" ); + SetPeriodInformation( kLHC11e, "LHC11e", kPP, kRE, 7000, 0, 0, "LHC12d2_plus" ); + + // LHC12g - TODO + SetPeriodInformation( kLHC12g, "LHC12g",kPA, kRE, 5020, 188356,188503, "LHC13b2" ); + SetPeriodInformation( kLHC12h, "LHC12h",kPA, kRE, 5020, 189122,192732, "LHC13b2" ); + SetPeriodInformation( kLHC13b, "LHC13b",kPA, kRE, 5020, 195344,195483, "LHC13b2-efix_p1" ); + SetPeriodInformation( kLHC13c, "LHC13c",kPA, kRE, 5020, 195529,195677, "LHC13b2-efix_p1" ); + SetPeriodInformation( kLHC13d, "LHC13d",kPA, kRE, 5020, 195724,195872, "LHC13b2-efix_p1" ); + SetPeriodInformation( kLHC13e, "LHC13e",kPA, kRE, 5020, 195955,196310, "LHC13b2-efix_p1" ); + SetPeriodInformation( kLHC13g, "LHC13g",kPA, kRE, 5020, 197669,200000, "LHC13b2-efix_p1" ); +} + + +TString AliJRunTable::GetPeriodName( int period ) const { + // TODO + if( period < 0 ) period = fCPeriod; + return fPeriodName[period]; +} + +int AliJRunTable::GetRunNumberToPeriod( int runnumber ){ + // comment needed + int period = -1; + for( int ip=0;ip= fRunRange[ip][0] && runnumber <= fRunRange[ip][1] ){ + cout<< fPeriodName[ip] <<"\t"<Exit(1); + } + return period; +} + +void AliJRunTable::SetPeriodInformation(int period, TString name, int beamtype, int datatype, int energy, int run0, int run1, TString MCPeriod){ + // comment needed + fPeriodName[period] = name; + fBeamType[period] = beamtype; + fDataType[period] = datatype; + fEnergy[period] = energy; + fRunRange[period][0] = run0; + fRunRange[period][1] = run1; + fMCPeriod[period] = MCPeriod; +} + + +int AliJRunTable::GetPeriodCode( TString perstr ) const{ + // comment needed + int period = kUnknownPeriod; + for( int ip=0;ip 0 ){ + fCPeriod = GetRunNumberToPeriod( fCRunNumber ); + }else + if( fCPeriodMCName.Length() > 0 ){ + fCPeriod = GetPeriodFromMCPeriod( fCPeriodMCName ); + }else{ + fCPeriod = kUnknownPeriod; + } + return true; +} + +// GetBeamStr is never used anywhere. Should it be removed altogether? +const char * AliJRunTable::GetBeamStr( int ib ) const { + // comment needed + if( ib < 0 ) ib = fBeamType[fCPeriod]; + switch (ib){ + case kPP : return "pp"; + case kPbPb: return "PbPb"; + case kPA: return "PA"; + } + return NULL; +} + +const char * AliJRunTable::GetDataStr( int ib ) const { + // comment needed + if( ib < 0 ) ib = fDataType[fCPeriod]; + switch (ib){ + case kRE: return "REAL"; + case kMC: return "MC"; + } + return NULL; +} +AliJRunTable& AliJRunTable::GetSpecialInstance(){ + // comment needed + static AliJRunTable instance; + return instance; +} + +// GetEnergyStr is never used anywhere. Should it be removed altogether? +const char * AliJRunTable::GetEnergyStr( int ib ) const { + // comment needed + if( ib < 0 ) ib = fEnergy[fCPeriod]; + if( ib < 1000 ) return Form("%dGeV",ib); + if( ib == 2760 ) return "2.76TeV"; + return Form("%dTeV",ib/1000); +} + +const AliJRunTable& AliJRunTable::GetInstance(){ + // comment needed + return GetSpecialInstance(); +} diff --git a/PWGCF/Correlations/JCORRAN/AliJRunTable.h b/PWGCF/Correlations/JCORRAN/AliJRunTable.h new file mode 100644 index 00000000000..efd6b621765 --- /dev/null +++ b/PWGCF/Correlations/JCORRAN/AliJRunTable.h @@ -0,0 +1,68 @@ +/* Copyright(c) 1998-2014, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +// Short comment describing what this class does needed! + +#ifndef ALIJRUNTABLE_H +#define ALIJRUNTABLE_H + +#include +#include +class AliJRunTable { +public: + enum { kUnknownPeriod, kLHC10b, kLHC10c, kLHC10d, kLHC10e, + kLHC10h, kLHC11a,kLHC11b , kLHC11c , kLHC11d, kLHC11e, kLHC11h, kLHC12g,kLHC12h, + kLHC13b, kLHC13c, kLHC13d, kLHC13e, kLHC13g, + kJNPeriod}; + enum { kRE, kMC }; + enum { kPP, kPbPb, kPA }; + AliJRunTable(); + void Init(); + void AddGoodRun(int period, int runnumber){ fGoodRun[period].push_back(runnumber); } + TString GetPeriodName( int period=-1 ) const; + int GetBeamType( int period ) const { return fBeamType[period]; } + TString GetMCPeriod( int period ) const { return fMCPeriod[period]; } + int GetPeriodCode(TString perstr) const; + int GetRunNumberToPeriod( int runnumber ); + void SetPeriodInformation(int period, TString name, int beamtype, int datatype, int energy, int run0, int run1, TString MCPeriod); + int GetBeamEnergy(int period) const { return fEnergy[period]; } + + int GetRunNumberFromString( const char * tstr ); + TString GetPeriodFromString( const char * tstr ) const; + TString GetMCPeriodFromString( const char * tstr) const; + int GetPeriodFromMCPeriod( const char * tstr ); + const char * GetBeamStr( int ib=-1 ) const; // Never used anywhere, should it be removed? + const char * GetDataStr( int ib=-1 ) const; // Never used anywhere, should it be removed? + const char * GetEnergyStr( int ib=-1 ) const; // Never used anywhere, should it be removed? + bool ParseString( const char * tstr ); + + int GetPeriod() const { return fCPeriod; } + TString GetPeriodMCName() const { return fCPeriodMCName; } + int GetBeamType() const { return fBeamType[fCPeriod]; } + TString GetBeamTypeStr() const { return IsPP()?"pp":IsPA()?"pA":IsHeavyIon()?"PbPb":""; } + void SetRunNumber( int run ){ fCRunNumber=run;fCPeriod=GetRunNumberToPeriod(run); } + int GetRunNumber() const { return fCRunNumber; } + + bool IsHeavyIon() const { return fBeamType[fCPeriod]==kPbPb; } + bool IsPA() const { return fBeamType[fCPeriod]==kPA; } + bool IsPP() const { return fBeamType[fCPeriod]==kPP; } + + AliJRunTable * operator()( int run ){ SetRunNumber(run);return this; } + static AliJRunTable& GetSpecialInstance(); + static const AliJRunTable& GetInstance(); + +private: + int fBeamType[kJNPeriod]; // comment needed + int fDataType[kJNPeriod]; // comment needed + int fEnergy[kJNPeriod]; // comment needed + long fRunRange[kJNPeriod][2]; // comment needed + TString fMCPeriod[kJNPeriod]; // comment needed + TString fPeriodName[kJNPeriod]; // comment needed + std::vector fGoodRun[kJNPeriod]; // comment needed + + int fCPeriod; // comment needed + int fCRunNumber; // comment needed + TString fCPeriodMCName; // comment needed +}; + +#endif diff --git a/PWGCF/Correlations/JCORRAN/AliJTrack.cxx b/PWGCF/Correlations/JCORRAN/AliJTrack.cxx old mode 100755 new mode 100644 index 87703054f71..33779f05614 --- a/PWGCF/Correlations/JCORRAN/AliJTrack.cxx +++ b/PWGCF/Correlations/JCORRAN/AliJTrack.cxx @@ -1,5 +1,5 @@ /************************************************************************** - * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * Copyright(c) 1998-2014, ALICE Experiment at CERN, All rights reserved. * * * * Author: The ALICE Off-line Project. * * Contributors are mentioned in the code where appropriate. * @@ -7,12 +7,14 @@ * 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 notifce * + * 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. * **************************************************************************/ +// Comment describing what this class does needed! + // $Id: AliJTrack.cxx,v 1.2 2008/01/21 11:56:39 djkim Exp $ //////////////////////////////////////////////////// @@ -38,17 +40,14 @@ AliJTrack::AliJTrack() : fFilterMap(0), fTPCnClust(-1), fTPCdEdx(-1), - fTOFbeta(0) + fTOFsignal(9999), + fTPCmom(0) { // default constructor - for( int i=0;i +#endif + +#include +#include +#include +#include + +using namespace std; + +class AliJTrackCounter : public TObject { + + public: + AliJTrackCounter(); //constructor + + AliJTrackCounter(int inind0, int inind1, int inlist0, int inlist1, double indphi); + + virtual ~AliJTrackCounter(){;} //destructor + + + void Reset(); + bool Exists() const {return fpt>=0 ? true : false;} + void Store(int inind, double inpt, int inBin){findex=inind; fpt=inpt; fptBin=inBin;} + int GetIndex() const {return findex;} + void SetIndex(int inIdx) {findex=inIdx;} + double Pt() const {return fpt;} // BS to compatible with AliJBaseTrack + double GetPt() const {return fpt;} + int GetPtBin() const {return fptBin;} + + int GetPairTrackID(int ip ) const {return (ip==0||ip==1) ? fpairTrackID[ip] : -1; } + int GetPairListID(int ip ) const {return (ip==0||ip==1) ? fpairListID[ip] : -1; } + double GetPairDPhi() const {return fdphi;} + + void Print(Option_t* option = "") const{ + // We must have option here because Print overrides the same function from TObject + // TODO: make some sensible use of option + cout<<"LPindex="< + +AliJTrackCut::AliJTrackCut() +{ +} + +/* FOR ESD +bool AliJTrackCut::IsSelected ( AliJTrack *track, int icut )const{ + // Comment needed + if( ! track ) return false; + if( 1 ) {// TODO fProdVersion == 10 ) + switch ( icut ){ + + case AliJTrackCut::kJTPCOnly : + return track->IsFiltered( 7 ); + + case AliJTrackCut::kJRaa : + return track->IsFiltered( 10 ); //TODO + + case AliJTrackCut::kJTPCplus : + return track->IsFiltered( 12 ); + + case AliJTrackCut::kJHybridA : + return track->IsFiltered( 14 ); + + case AliJTrackCut::kJHybridB : + return ( !track->IsFiltered( 14 ) && track->IsFiltered(15) ); + + case AliJTrackCut::kJHybrid : + return ( IsSelected(track,kJHybridA) || IsSelected(track, kJHybridB ) ); + + case AliJTrackCut::kJTPC2A : + return track->IsFiltered(11); + case AliJTrackCut::kJRaa2011 : + return track->IsFiltered(13); + case AliJTrackCut::kJH22011 : + return track->IsFiltered(16); + case AliJTrackCut::kJH32011 : + return track->IsFiltered(17); + + } + } + return false; +} + */ + +//==== FOR AOD +bool AliJTrackCut::IsSelected ( AliJTrack *track, int icut )const{ + // comment needed + if( ! track ) return false; + if( 1 ) {// TODO fProdVersion == 10 ) + switch ( icut ){ + + case AliJTrackCut::kJTPCOnly : + return track->IsFiltered( 7 ); + + case AliJTrackCut::kJRaa : + return track->IsFiltered( 10 ); //TODO + + case AliJTrackCut::kJHybrid : + return track->IsFiltered(8) || track->IsFiltered(9) ; + case AliJTrackCut::kJGlobalTightDCA : + return track->IsFiltered( 5 ); // 32 + case AliJTrackCut::kJGlobalDCA : + return track->IsFiltered( 4 ); // 32 + case AliJTrackCut::kJGlobalSDD : + return track->IsFiltered( 5 ) || track->IsFiltered( 6 ); + } + } + return false; +} + +bool AliJTrackCut::SetMomentum( AliJTrack *track, int icut ) const { + // comment needed + if( ! track ) return false; + if( 1 ) {// TODO fProdVersion == 10 ) + + switch ( icut ){ + /* + case AliJTrackCut::kJTPCOnly : + if( track->PtTPC() > 1e-9 ){ + track->SetUseTPCTrack(); + } + break; + case AliJTrackCut::kJTPCplus : + if( track->PtTPC() > 1e-9 ){ + track->SetUseTPCTrack(); + } + break; + case AliJTrackCut::kJHybrid : + if( (!IsSelected( track, kJHybridA )) && track->PtGCG() > 1e-9 ) + track->SetUseGCGTrack(); + break; + */ + default: + break; + } + + } + return true; +} + +AliJTrackCut& AliJTrackCut::GetSpecialInstance(){ + // comment needed + static AliJTrackCut instance; + return instance; +} +const AliJTrackCut& AliJTrackCut::GetInstance(){ + // comment needed + return GetSpecialInstance(); +} diff --git a/PWGCF/Correlations/JCORRAN/AliJTrackCut.h b/PWGCF/Correlations/JCORRAN/AliJTrackCut.h new file mode 100644 index 00000000000..731a7b754ae --- /dev/null +++ b/PWGCF/Correlations/JCORRAN/AliJTrackCut.h @@ -0,0 +1,26 @@ +/* Copyright(c) 1998-2014, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +// Short comment describing what this class does needed! + +#ifndef ALIJTRACKCUT_H +#define ALIJTRACKCUT_H + +class AliJTrack; + +class AliJTrackCut { + public: + enum { kJTPCOnly, kJRaa, kJGlobalTightDCA, kJGlobalDCA, kJGlobalSDD , kJHybrid, kJNTrackCuts }; + + AliJTrackCut(); + ~AliJTrackCut(){;} + bool IsSelected ( AliJTrack *track, int icut ) const; + bool SetMomentum( AliJTrack *track, int icut ) const; + int GetNCut() const { return kJNTrackCuts; } //TODO + static AliJTrackCut& GetSpecialInstance(); + static const AliJTrackCut& GetInstance(); + private: + +}; + +#endif diff --git a/PWGCF/Correlations/macros/jcorran/AddTaskJCORRANFilter.C b/PWGCF/Correlations/macros/jcorran/AddTaskJCORRANFilter.C new file mode 100755 index 00000000000..4aa4e92db3f --- /dev/null +++ b/PWGCF/Correlations/macros/jcorran/AddTaskJCORRANFilter.C @@ -0,0 +1,84 @@ +const Bool_t IsMC = kFALSE; //With real data kMC = kFALSE +const TString kInputData = "AOD"; +const TString kJCORRANInputFormat = "AOD"; // ESD, AODout, AODin +const Bool_t kDoStoreJOD = kTRUE; + +//_____________________________________________________________________ +AliAnalysisTask *AddTaskJCORRANFilter(){ + // Load Custom Configuration and parameters + // override values with parameters + UInt_t triggerSelection; + + AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); + + // AOD handler + AliAODInputHandler *aodHandler = new AliAODInputHandler(); + mgr->SetInputEventHandler(aodHandler); + + //================================================ + // TASKS + //================================================ + + // set the trigger selection + triggerSelection = AliVEvent::kAny; + // | AliVEvent::kHighMult + // | AliVEvent::kEMCEGA; + // | AliVEvent::kEMCEJE + // | AliVEvent::kEMC1 + // | AliVEvent::kEMC7 + // | AliVEvent::kCentral + // | AliVEvent::kSemiCentral; + //============================ + // JCORRANTask + //=========================== + + //==== JCORRAN TASK + AliJCORRANTask *jctask = new AliJCORRANTask("PWGCFJCORRANTask",kJCORRANInputFormat); + jctask->SetOutputAODName("jcorran.root"); + jctask->SetDebugLevel(0); + jctask->SetDoStoreJOD( kDoStoreJOD ); + cout<<"DEBUG 4"<< jctask->GetDoStoreJOD() <<"\t"<SetIsMC( IsMC ); + hdr->SetBeamTypeI( 0 ); // 0:pp 1:PbPb + hdr->SetWithoutSDD(false); + hdr->SetRunType("LHC13c"); + hdr->SetInputFormat( 1 ); // 0: ESD; + hdr->SetRefitESDVertexTracks(kFALSE); + hdr->SetStoreEventPlaneSource(kFALSE); + hdr->SetStoreTPCTrackBitMask( 1<<7 ); // TODO : For what? + hdr->SetStoreGCGTrackBitMask( 2^30-1 ); + hdr->SetStoreEMCalInfo( kFALSE ); // error with lego now. + + + jctask->SetJRunHeader( hdr ); + + AliJFilter *jfilter = jctask->GetFilter(); + jfilter->SetAliJRunHeader( hdr ); + jfilter->SetClusterThreshold( 0 ); + jfilter->SetTrackThreshold( 0 ); + + //==event selection + jctask->SelectCollisionCandidates( triggerSelection ); //Apply offline trigger selection by AliPhysicsSelectionTask + + mgr->AddTask((AliAnalysisTask*) jctask); + + //==== Create containers for input/output + AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer(); + AliAODHandler* aodoutHandler = new AliAODHandler(); + aodoutHandler->SetCreateNonStandardAOD(); + mgr->SetOutputEventHandler(aodoutHandler); + +// Connect input/output + mgr->ConnectInput(jctask, 0, cinput); + if( kDoStoreJOD ){ + AliAnalysisDataContainer *runinfoOutput = mgr->CreateContainer("RunInfo", TList::Class(), AliAnalysisManager::kOutputContainer, "jcorran.root"); + AliAnalysisDataContainer *treeOutput = mgr->CreateContainer("JODTree", TTree::Class(), AliAnalysisManager::kOutputContainer, "jcorran.root"); + mgr->ConnectOutput(jctask, 1, treeOutput ); + mgr->ConnectOutput(jctask, 2, runinfoOutput ); + } + + return jctask; +} + diff --git a/PWGCF/Correlations/macros/jcorran/AddTaskJDiHadronCorr.C b/PWGCF/Correlations/macros/jcorran/AddTaskJDiHadronCorr.C new file mode 100755 index 00000000000..adc72f53eec --- /dev/null +++ b/PWGCF/Correlations/macros/jcorran/AddTaskJDiHadronCorr.C @@ -0,0 +1,42 @@ +//_____________________________________________________________________ +AliAnalysisTask *AddTaskJDiHadronCorr(TString cardName, TString jtrigg, TString jassoc, TString inclusFileName=""){ + // Load Custom Configuration and parameters + // override values with parameters + + cout<<"### DEGUG Input is "<< cardName <<"\t"<SetDebugLevel(5); + jdihadtask->SetFilterTaskName("PWGCFJCORRANTask"); + + + // === Create AliJCORRAN ==== + AliJCard *card = new AliJCard(cardName.Data()); + card->PrintOut(); + + AliJCORRAN *fJCORRAN; + fJCORRAN = new AliJCORRAN( kFALSE ); + + fJCORRAN->SetCard( card ); + fJCORRAN->SetTrigger( jtrigg.Data() ); + fJCORRAN->SetAssoc( jassoc.Data() ); + if( inclusFileName ) fJCORRAN->SetInclusiveFile(inclusFileName.Data()); + + jdihadtask->SetJCORRAN( fJCORRAN ); + + mgr->AddTask((AliAnalysisTask*) jdihadtask); + + // Create containers for input/output + AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer(); + + + // Connect input/output + mgr->ConnectInput(jdihadtask, 0, cinput); + AliAnalysisDataContainer *jHist = mgr->CreateContainer("JDiHadronCorr", TDirectory::Class(), AliAnalysisManager::kOutputContainer, Form("%s:JDiHadronCorr",AliAnalysisManager::GetCommonFileName())); + mgr->ConnectOutput(jdihadtask, 1, jHist ); + + return jdihadtask; +} + diff --git a/PWGCF/Correlations/macros/jcorran/cardAlice_pp.input b/PWGCF/Correlations/macros/jcorran/cardAlice_pp.input new file mode 100644 index 00000000000..1c9e27565d8 --- /dev/null +++ b/PWGCF/Correlations/macros/jcorran/cardAlice_pp.input @@ -0,0 +1,72 @@ +TriggerMask 256 # 62 masking on see bottom 0011:1110 -1 no check +Helicity 0 # +1 same, -1 opposite, and 0 no helicity check +EfficiencyMode 1 # 0:NoEff 1:Period 2:RunbyRun 3:Auto + +#events========= +#CentBinBorders 0 10 20 40 60 90 +CentBinBorders 0 100 +CentMultCutHigh 0.63, 99, 2.1 # hyperbola high cent x mult cut +CentMultCutLow 0.71, 75, 1.0 # hyperbola low cent x mult cut + +Jet:PtBins 0, 5, 10, 15, 20, 40, 60, 80, 110 + +zVertBins -10 10 +#maxAbsZVert 8 #(used to be 10) +#maxMixDZ 1.0 # cm, allowed maximum ZVert distance for mix (5 for QM)/ neg -> no test + +#mixing========= +maxDCent 5 # check the mix if cent bin too wide +maxMixDMult 100 # assoc mult so far. Later ITS tracklets +EventPoolDepth 500 # one pool for cent + +#==================== +#==== binning ======= +#==================== +CorrelationType 1 # 0=all x all 1=trig LP 2=trigg Pair +sumTriggerAndAssoc 0 # 0 trigger LP 1 trigger+assoc + +#--- ours --- +TriggPtBorders 3 4 5 6 8 10 12 15 18 25 +#AssocPtBorders 3 4 5 6 8 10 12 15 18 25 +#TriggPtBorders 3 4 5 6 8 10 12 15 18 25 +AssocPtBorders 0.3 1 2 3 4 5 6 8 10 15 +KlongBorders 1 2 3 4 6 8 12 +xEBorders 0.0 0.2 0.4 0.6 1.0 +#KlongBorders 8 12 +#xEBorders 0.6 1.0 + + +#--- JFG --- +#TriggPtBorders 2 3 4 8 15 +#AssocPtBorders 0.5 1 2 3 4 6 8 +#KlongBorders 1 2 + +#--- UE paper --- +#TriggPtBorders 0.5 1.5 2 4 6 10 +#AssocPtBorders 0.5 1 10 +#KlongBorders 1 2 + +PairInvariantMassBins 20 30 +UpperPairPtCut 1.5 15 +EtaRange 0.8 +EtaGapThresholds 0 0.2 0.4 0.6 0.8 1.0 1.2 1.4 1.6 +RGapThresholds 0 0.2 0.4 0.6 0.8 1.0 1.2 1.4 1.6 2.3 +EtaGapSignalBin 2 #signal histos to R<0.6 +EtaBoost -0.465 0 + +DPhiUERegion 0.325 0.475 + +#======= Isolation tracks ============= +IsolationR 0.4 #isolation radius for higher twist +CutOnBkgActivity 0.10 #cut on activity around leading particle sum of assoc pt / LP pt +LowerPtCut 1.0 #for isolation + +#======= ALICE JYFL Track selection ============= +HadronSelectionCut 5 # enum { kJTPCOnly, kJRaa, kJGlobalTightDCA, kJGlobalDCA, kJGlobalSDD , kJHybrid, kJNTrackCuts }; + +TriggerFiducialEtaCut 0.4 # + +#======= From Jiri's EMCAL analysis but still in AliJCORRAN.cxx, around line 300 +eventBC -1 # select only events in BC modulo 4; -1 to disable + +DoResonancePythia 0 -- 2.43.0