PWGCF/EBYE/LRC/AliAnalysisTaskLRC.h

   1 #ifndef AliAnalysisTaskLRC_H
   2 #define AliAnalysisTaskLRC_H
   3
   4 // Analysis task for Long Range Correlation (LRC) analysis using TPC data
   5 // This includes a TList of AliLRCProcess objects that are processing LRC analysis
   6 // for a given eta-phi windows
   7
   8 // Author : Andrey Ivanov, Igor Altsybeev, St.Peterburg State University
   9 // Email: Igor.Altsybeev.ch
  10
  11
  12 #include <AliPIDResponse.h>
  13 #include <AliPIDCombined.h>
  14 #include <AliAnalysisTaskSE.h>
  15
  16 //#define kNumberOfParentParticleClassesInMC 8
  17
  18 //class AliLRCProcess;
  19 class AliLRCBase;
  20 class AliESDtrackCuts;
  21 class TH1D;
  22 class TH2D;
  23 class TH1I;
  24 class TRandom3;
  25 class TParticle;
  26 //class AliSimpleEvent;
  27 class TTree;
  28
  29 class TStopwatch;
  30 //enum en_AnalysisType
  31 //{
  32 //    en_AnalysisType_ESD = 0,
  33 //    en_AnalysisType_AOD
  34
  35 //};
  36
  37 class AliAnalysisTaskLRC : public AliAnalysisTaskSE {
  38
  39 public:
  40     //Constructors
  41     AliAnalysisTaskLRC( const char *name = "AliAnalysisTaskLRC", Bool_t runKine = kFALSE );
  42     virtual ~AliAnalysisTaskLRC() {}
  43
  44     //AliAnalysisTaskSE overloading
  45
  46     virtual void   UserCreateOutputObjects();
  47     virtual void   UserExec(Option_t *option);
  48     //    virtual void   UserExecLoop( Double_t phiAdditional = 0 );//Option_t *option);
  49     virtual void   Terminate(Option_t *);
  50     //----------------------------------
  51
  52     void AddLRCProcess(AliLRCBase *newProc); //Adds new AliLRCProcess to analysis task
  53
  54     // Setters
  55     void SetMinNumberOfSPDtracklets( Int_t MinSPDtracklets );   //Sets  min number of SPD tracklets
  56     void SetMaxPtLimit(Double_t MaxPtLimit);   //Sets  Max Pt filter
  57     void SetMinPtLimit(Double_t MinPtLimit);   //Sets  Min Pt filter
  58     void SetKineLowPtCut(Double_t MinKineParticlePtLimit);   //Sets  Min Pt filter for kine particles
  59     void SetCheckForkVtx(Bool_t CheckForkVtx){fCheckForkVtx=CheckForkVtx;} // Accept only events with veretex
  60     void SetCheckForVtxPosition(Bool_t CheckForVtxPosition ){fCheckForVtxPosition=CheckForVtxPosition;} //Accept only events with veretex in slected range
  61     void SetTrackCuts(AliESDtrackCuts* const cuts)  { fEsdTrackCuts = cuts; }
  62     void SetAODtrackCutBit(UInt_t bit){ fAODtrackCutBit = bit;  } //AOD track cut bit
  63     void SetShowEventStats(Bool_t ShowEventStats)  {fShowEventStats= ShowEventStats;}
  64     void SetShowPerTrackStats(Bool_t ShowPerTrackStats) {fShowPerTrackStats=ShowPerTrackStats;}
  65     void SetVtxDiamond(Double_t Vx, Double_t Vy, Double_t Vz) {fVxMax = Vx;fVyMax =Vy;fVzMax = Vz;}
  66     void SetNchCuts(Int_t minNch, Int_t maxNch){fMinAcceptedTracksCut=minNch; fMaxAcceptedTracksCut=maxNch;}
  67
  68     void SetNumberOfPhiSectors(Int_t nSectors){ fNumberOfPhiSectors = nSectors; }//fNeedToRotateSector = kTRUE; }
  69     void SetCentralityClass(Float_t minCentralityClass, Float_t maxCentralityClass ){ fMinCentralityClass = minCentralityClass; fMaxCentralityClass = maxCentralityClass; }
  70
  71     void SetIonsAnalysis(Bool_t isIonsFlag ){ fIsIonsAnalysis = isIonsFlag; }
  72     void SetEtAnalysis(Bool_t isEtAnalysisFlag ){ fEtInsteadOfPt = isEtAnalysisFlag; }
  73     void SetUsePhiShufflingByHand(Bool_t usePhiShufflingByHand ){ fUsePhiShufflingByHand = usePhiShufflingByHand; }
  74     void SetUseToyEvents(Bool_t useToyEvents ){ fUseToyEvents = useToyEvents; }
  75     void SetNumberOfToyEvents(Int_t nEvents ){ fNumberOfToyEvents = nEvents; }
  76     void SetArtificialInefficiencyCoeff( Double_t artificialInefficiencyCoeff ) { fArtificialInefficiency = artificialInefficiencyCoeff; }   //Sets coeff for artificial inefficiency
  77
  78     //void SetNumberOfPhiSectorsByHand( Int_t numberOfPhiSectorsByHand ) { fNumberOfPhiSectorsByHand = numberOfPhiSectorsByHand; }
  79
  80     // Getters
  81     TList* GetListOfProcessors() { return &fLRCproc;} // Returns list of included
  82     AliESDtrackCuts* GetTrackCuts() const                         { return fEsdTrackCuts; }
  83     AliLRCBase * Proc(Int_t index);// Get Processor i
  84
  85     void SetParticleTypeForTask( TString strF, TString strB );  //( char* strF, char* strB );
  86     //    void SetMCparticleClassForFillingLRC( TString strParticleType ) { fStrMCparticleClassForFillingLRC = strParticleType; }
  87     //    void SetEtaCutsForSpecMCanalysis( double etaMin, double etaMax  ) { fEtaMCanalysisCutMin = etaMin; fEtaMCanalysisCutMax = etaMax; }
  88
  89     void SetV0ACMultThreshold( int minMult ) { fThresholdOnV0mult = minMult; }
  90
  91     //    void SetIncludeEventTreeInOutput( Bool_t flag ) { fSetIncludeEventTreeInOutput = flag; }
  92     //    Bool_t GetIncludeEventTreeInOutput() { return fSetIncludeEventTreeInOutput; }
  93
  94     //    void SetAnalysisType( en_AnalysisType analysisType ) { fAnalysisType = analysisType; }
  95     //    en_AnalysisType GetAnalysisType() { return fAnalysisType; }
  96
  97     Double_t GetEventPlane(AliVEvent *event);
  98
  99
 100     //track cuts array stuff
 101     void AddTrackCutForBits(AliESDtrackCuts* const cuts, TString cutsName );
 102     void SetUseListCuts( Bool_t const useCutsList )  { fSwitchToListingCuts = useCutsList; }
 103     Int_t GetNumberOfTrackCutForBits() const                         { return fArrTrackCuts.GetEntries();/*fNumberOfCutsToRemember*/; }
 104
 105     void SetAnalysisLevel(const char* analysisLevel) {  fAnalysisLevel = analysisLevel;}
 106     const char* GetAnalysisLevel() { return fAnalysisLevel.Data(); }
 107
 108     void SetMCESD( Bool_t flagMCESD ) { fAnalyseMCESD = flagMCESD; }
 109     Bool_t GetMCESD() const { return fAnalyseMCESD; }
 110
 111     void SetFlagWatchZDC( Bool_t flagWatchZDC) {  fFlagWatchZDC = flagWatchZDC;}
 112     void SetFlagWatchV0 ( Bool_t flagWatchV0 ) {  fFlagWatchV0  = flagWatchV0 ;}
 113     void SetFlagWatchFMD( Bool_t flagWatchFMD) {  fFlagWatchFMD = flagWatchFMD;}
 114     Bool_t GetFlagWatchZDC() {  return fFlagWatchZDC; }
 115     Bool_t GetFlagWatchV0 () {  return fFlagWatchV0 ; }
 116     Bool_t GetFlagWatchFMD() {  return fFlagWatchFMD; }
 117
 118     void FillLRCProcessors( int nTracks, Double_t eventCentrality );
 119     void ProfilePhiByHand( int numberOfAcceptedTracksForLRC );
 120     void UseToyEvents();
 121
 122     void SetEtaRegionForTests( Double_t etaRegionForTests ) {  fEtaRegionForTests = etaRegionForTests; }
 123     Double_t GetEtaRegionForTests() {  return fEtaRegionForTests; }
 124
 125     void SetMultCutInEtaRegion( Double_t multCutInEtaRegion ) {  fMultCutInEtaRegion = multCutInEtaRegion; }
 126     Double_t GetMultCutInEtaRegion() {  return fMultCutInEtaRegion; }
 127
 128     inline void FixAngleInTwoPi( Double_t &lPhi )
 129     {
 130         if ( lPhi > 2 * TMath::Pi() )
 131             lPhi -= 2 * TMath::Pi();
 132         else if ( lPhi < 0 )
 133             lPhi += 2 * TMath::Pi();
 134     }
 135
 136     void SetFlagSuppressAddingSomeHistos( Bool_t flagSuppressAddingSomeHistos ) {  fFlagSuppressAddingSomeHistos = flagSuppressAddingSomeHistos; }
 137
 138     enum enTaskObjectParameters { kMaxParticlesNumber = 15000, kMaxLRCprocArrayPointers = 10000 }; // default TPC & TOF pid (via GetTPCpid & GetTOFpid)
 139
 140 protected:
 141     void SetParticleTypeToProcessors( int windowId, TString strPid );
 142
 143     Int_t fNumberOfPhiSectors; // n of phi rotations
 144     Bool_t fFlagSuppressAddingSomeHistos; //flag to include in output list some histos or not include
 145     //    AliLRCBase *fLRCprocArrayPointers[kMaxLRCprocArrayPointers];
 146
 147     // Track cuts
 148     TString fAnalysisLevel; //ESD, AOD or MC
 149     AliESDtrackCuts *fEsdTrackCuts;               // esd track cuts
 150     UInt_t fAODtrackCutBit;//track cut bit from track selection (only used for AODs)
 151
 152     // Array with different track cuts to remember in simple event Tree
 153     TObjArray fArrTrackCuts;    //AliESDtrackCuts*  [100];     // Arr with different track cuts
 154     TString  fArrCutsNames[100];     // Arr with names of different track cuts
 155     TH1I    *fHistCutsNamesBins;        //!  tracks passed different cut sets in histogram bins
 156     Bool_t fSwitchToListingCuts;      // switch to remember cuts desicions and not to drop track by fTrackCuts
 157
 158
 159     //    en_AnalysisType fAnalysisType; // type of analysis
 160
 161     //SPD tracklets cut
 162     Int_t fMinNumberOfSPDtracklets;   //Minimum number of SPD tracklets in ESD event
 163
 164     // Acceptance cuts
 165     Double_t fMaxPtLimit;  //Max Pt filter
 166     Double_t fMinPtLimit;  // Min Pt filter
 167     Double_t fKineLowPtCut;  // Min Pt for Kine tracks
 168
 169     // Nch cuts
 170     Int_t fMinAcceptedTracksCut;   //Minimum number of accepted tracks in event
 171     Int_t fMaxAcceptedTracksCut;   //Maximum number of accepted tracks in event
 172
 173     // Vtx cuts
 174     Bool_t fCheckForkVtx;               // Check for vertex
 175     Bool_t fCheckForVtxPosition;  // Check if vertex position in range
 176     Double_t fVxMax;    // X vrtx max
 177     Double_t fVyMax;    // Y vrtx max
 178     Double_t fVzMax;    // Z vrtx max
 179
 180
 181     TList fLRCproc;       //  AliLRCProcess objects list
 182     TList* fOutList;      //! Task Output data container
 183
 184     Bool_t fRunKine;      // ESD/AOD  - KINE switch
 185     Bool_t fAnalyseMCESD;     // MCESD switch
 186     Bool_t fShowEventStats; //  Allows per event debug output (trigger Nch, cuts etc)
 187     Bool_t fShowPerTrackStats; // Allows per track debug output
 188
 189
 190     Double_t fEtaRegionForTests; //eta region to tests
 191     Double_t fMultCutInEtaRegion;       // cut on mult in eta region
 192
 193     // QA histos
 194
 195     TH1I *fHistEventCutStats;  //! Event cut statistics
 196     TH1I *fHistTrackCutStats;  //! Track cut statistics
 197     TH1I *fHistAODTrackStats;  //! AOD track bits statistics
 198
 199
 200     TH1D *fHistVx;  //! Vx hist
 201     TH1D *fHistVy;  //! Vy hist
 202     TH1D *fHistVz;  //! Vz hist
 203
 204     TH1D *fHistVxMCrecoDiff;  //! Vx hist MC-reco diff
 205     TH1D *fHistVyMCrecoDiff;  //! Vy hist MC-reco diff
 206     TH1D *fHistVzMCrecoDiff;  //! Vz hist MC-reco diff
 207
 208     TH1I *fHistVertexNconributors;  //! vertex contributors number
 209     TH1I *fHistNumberOfPileupVerticesTracks;  //! number of pileup verteces in event (ESD or AOD) by tracks
 210     TH1I *fHistNumberOfPileupVerticesSPD;  //! number of pileup verteces in event (ESD or AOD) by SPD
 211
 212     TH2F *fHistEventPlane; //event plane distribution
 213
 214
 215     TH1F *fHistPt; //! Overal Pt spectrum
 216     TH1F *fHistEta; //! Overal Eta spectrum
 217     TH1F *fHistEtaAODpure; //! Overal Eta spectrum aod pure before cuts
 218     TH1F *fHistPhi; //! Overal Phi spectrum
 219     TH2D *fHistEtaPhi;       //! 2D plot for checking acceptance
 220     TH1F *fHistPhiLRCrotationsCheck; //! Overal Phi spectrum for LRC rotations
 221     TH1F *fHistPhiArtificialProfilingCheck; //! hist for the check of profiled phi
 222     TH1F *fHistPhiArtificialProfilingCheckWrtEvPlane; //! hist for the check of profiled phi wrt event plane
 223     TH1F *fHistPhiArtificialEvPlane; //! hist artificial event plane
 224
 225     TH2D *fHistEtaVsZvCoverage; //! Statistics on tracks Zv and Eta for all tracks
 226     TH2D *fHistEtaVsZvCoverageAccepted; //!  Statistics on tracks Zv and Eta for accepted tracks
 227
 228     TH1D *fHistMultBeforeCuts;   //! Histo: Number of tracks before applying cuts
 229     TH1D *fHistAcceptedMult;   //! Number of accepted tracks histo
 230     TH1D *fHistAcceptedTracks;   //! Number of tracks accepted for filling LRC processors, histo
 231     TH1D *fHistMultiplicityInEtaRegion; //! Number of tracks in |eta| region
 232     TH1D *fHistMultiplicityInEtaRegionAfterPtCuts; //! Number of tracks in |eta| region after Pt Cuts
 233     TH2D *fHist2DMultiplicityMCESDInEtaRegion; //! Number of tracks in |eta| region (MC vs ESD)
 234     TH1D *fHistAcceptedTracksAfterPtCuts;   //! Number of tracks accepted for filling LRC processors, histo
 235     TH1D *fHistAcceptedTPCtracks;   //! Number of accepted tracks with TPC inner param
 236     TH1D *fHistClustersTPC;   //! Number of TPC clusters distribution
 237     TH1D *fHistClustersTPCafterCuts;   //! Number of TPC clusters distribution after cuts
 238     TH1D *fHistCrossedRowsTPC;   //! Number of TPC crossed rows
 239     TH1D *fHistCrossedRowsTPCafterCuts;   //! Number of TPC crossed rows after cuts
 240
 241
 242     TH1D *fHistClustersITS;   //! Number of ITS clusters distribution
 243     TH1D *fHistTrackletsITS;   //! Number of ITS tracklets distribution
 244     TH2D *fHist2DClustersTPCvsPt;   //! Number of TPC clusters vs Pt distribution (to see the dependence!)
 245     TH2D *fHist2DClustersTPCvsEta;   //! Number of TPC clusters vs Eta distribution (to see the dependence!)
 246
 247     TH2D *fHist2DAcceptedTracksPtvsEta;   //! rejected tracks pt vs eta
 248
 249     TH1D *fHistMClabels;   //! MC labels
 250     TH1D *fHistRejectedTracksCharge;   //! Charge of rejected tracks
 251     TH1D *fHistTracksCharge;   //! Charge of accepted tracks (zero is filled only for MC truth)
 252
 253     //netcharge study
 254     TH1D *fHistPtPlus;   //! pt distr for +
 255     TH1D *fHistPtMinus;   //! pt distr for -
 256     TH1D *fHistNetChargeVsPt;   //! Net charge vs pt of accepted tracks
 257     TH1D *fHistChargePlusVsPtTmp;    //! Net charge vs pt of accepted tracks +
 258     TH1D *fHistChargeMinusVsPtTmp;   //! Net charge vs pt of accepted tracks -
 259     TH2D *fHist2DNetChargeVsPt;      //! Net charge vs pt of accepted tracks 2D
 260     TH2D *fHist2DNetChargeVsPtCorrectedOnEventMean;              //! Net charge vs pt of accepted tracks 2D shifted by mean
 261     TH2D *fHist2DNetChargeVsPtCorrectedOnEventMeanNormOnNch;     //! Net charge vs pt of accepted tracks 2D norm on nCh
 262
 263     AliAnalysisTaskLRC(const AliAnalysisTaskLRC&); // not implemented
 264     AliAnalysisTaskLRC& operator=(const AliAnalysisTaskLRC&); // not implemented
 265
 266     TH1D *fHistProbabilitiesPID;  //!hist of esd pid prob-s
 267     //Double_t *fProbabilitiesPID;      //! array of esd pid prob-s
 268     TH1D *fHistESDtrackMass;  //!hist of esd particle masses
 269     TH1D *fHistProbabilityPion;  //!hist of pion probability
 270     TH1D *fHistProbabilityKaon;  //!hist of kaon probability
 271     TH1D *fHistProbabilityProton;  //!hist of proton probability
 272     TH1D *fHistParticlesDistr;  //!hist of particles distr
 273     TH1D *fHistParticlesDistrBeforeCuts;  //!hist of particles distr
 274
 275
 276
 277     TH1D *fHistCentralityPercentile;        //! centrality class
 278     TH1D *fHistCentralityClass10;           //! centrality class by 10
 279     TH1D *fHistCentralityClass5;            //! centrality class by 5
 280
 281
 282     //ZDC stuff
 283     TH1D *fHistZDCenergy[5];     //! ZDC energy for diff mult conditions
 284     TH1D *fHistZDCparticipants;             //! ZDC participants
 285
 286     //V0 stuff
 287     TH1D *fHistV0multiplicity;     //! V0 mult
 288     TH1D *fHistV0Amultiplicity;     //! V0 A mult
 289     TH1D *fHistV0Cmultiplicity;     //! V0 C mult
 290     TH2D *fHist2DV0ACmultiplicity;     //! V0 A-C mult
 291     //TH1D *fHistV0spectra;     //! V0 particle masses
 292     TH2D *fHist2DTracksAcceptedVsV0multiplicity;     //! V0 mult Vs N tracks Accepted
 293
 294     TH1D *fHistV0AmultiplicityRing[4];     //! V0 A mult in rings
 295     TH1D *fHistV0CmultiplicityRing[4];     //! V0 C mult in rings
 296     TH2D *fHist2DV0ACmultiplicityRing[4];     //! V0 A-C mult in rings
 297     TH2D *fHist2DTracksAcceptedVsV0AmultiplicityRing[4];     //! V0A mult Rings Vs N tracks Accepted
 298     TH2D *fHist2DTracksAcceptedVsV0CmultiplicityRing[4];     //! V0C mult Rings Vs N tracks Accepted
 299
 300     TH1D *fHistV0cells         ;     //! V0 cells
 301     TH1D *fHistV0Acells        ;     //! V0 A cells
 302     TH1D *fHistV0Ccells        ;     //! V0 C cells
 303     TH2D *fHist2DV0ACcells     ;     //! V0 A-C cells
 304
 305     Int_t fThresholdOnV0mult; //min V0AC mult to analyse this event (default is 0)
 306
 307
 308     //centrality class
 309     Float_t fMinCentralityClass;    // min bound on centrality percentile
 310     Float_t fMaxCentralityClass;    // max bound on centrality percentile
 311
 312
 313     Bool_t fIsIonsAnalysis; //Ions analysis flag
 314     Bool_t fEtInsteadOfPt; //pass the Et instead of Pt to LRC processors
 315
 316     Bool_t fUsePhiShufflingByHand; //flag for manual suffling of tracks phi
 317     Bool_t fUseToyEvents; //flag for manual suffling of tracks phi
 318     Int_t fNumberOfToyEvents; //number of toy events
 319
 320     Int_t fTmpCounter; //! TMP
 321
 322     const AliPIDResponse *fPIDResponse;     //! PID response object
 323     AliPIDCombined       *fPIDCombined;     //! combined PID object
 324     TH1F *fPriors[AliPID::kSPECIES];           //! priors
 325     TH2D *fPriorsUsed[AliPID::kSPECIES];       //! priors used
 326     TH2D *fProbTPCTOF[AliPID::kSPECIES];       //! combined probabilities vs mom TPC-TOF
 327     TH2D *fProbAllDets[AliPID::kSPECIES];       //! combined probabilities ALL dets vs mom
 328
 329     TH1D *fHistPidMaxProbability;  //!hist of max probabilities for arrays PID species
 330     TH1D *fHistPidPureMaxProbability;  //!hist of max probabilities for arrays PID species (when detId is TPC+TOF)
 331
 332     TString fStrPIDforFwd;              //PID name for FWD win
 333     TString fStrPIDforBwd;              //PID name for BWD win
 334     Bool_t fPIDsensingFlag;             //flag that we sense PID in processors
 335
 336
 337     int fMultForZDCstudy[5]; //! threshold multiplicities for ZDC study
 338
 339     //artificial inefficiency (27.09.12)
 340     Double_t fArtificialInefficiency;   // inefficiency by hand in [0,1], default is 0
 341     TH2D *fHistNumberOfDroppedByHandTracks;   //! Number of tracks which were dropped by hand vs N of accepted tracks
 342     TRandom3 *fRand; //random generator for some uses
 343
 344     //phi artificial gaps
 345     Double_t fPhiArtificialGapBegin;    // inefficiency in phi - gap position edge begins
 346     Double_t fPhiArtificialGapEnd;      // inefficiency in phi - gap position edge ends
 347
 348     //flags for inclusion of detectors info:
 349     Bool_t fFlagWatchZDC;   //study ZDC issues
 350     Bool_t fFlagWatchV0;    //study V0 issues
 351     Bool_t fFlagWatchFMD;   //study FMD issues
 352
 353
 354     TStopwatch *fAnalysisTimer;
 355
 356
 357     //arrays with data for LRC processors
 358     Double_t fArrayTracksPt[kMaxParticlesNumber];
 359     Double_t fArrayTracksEta[kMaxParticlesNumber];
 360     Double_t fArrayTracksPhi[kMaxParticlesNumber];
 361     Short_t fArrayTracksCharge[kMaxParticlesNumber];
 362     Int_t fArrayTracksPID[kMaxParticlesNumber];
 363
 364
 365     //test MC particles
 366     //    TH1D *fHistMCvertexRdeltaFromParent;  //!MC R hist
 367     //    TH1F *fHistMCparentsStat;  //! MC parent ratios for different partile classes
 368     //    TH1F *fHistMCparentsEta[kNumberOfParentParticleClassesInMC];  //! MC parents eta distributions for different particle classes
 369     //    TH1F *fHistMCchildsEta[kNumberOfParentParticleClassesInMC];  //! MC childs eta distributions for different partile classes
 370     //    TH1F *fHistMCdeltaEtaChildParent[kNumberOfParentParticleClassesInMC];  //! MC delta eta b/n parent and child
 371     //    TH1F *fHistMCdeltaPhiChildParent[kNumberOfParentParticleClassesInMC];  //! MC delta phi b/n parent and child
 372     //    TH2D *fHist2DMCchildrenPhiChildParent[kNumberOfParentParticleClassesInMC];  //! MC delta b/n parent and child in eta-phi
 373
 374     //    TH1F *fHistMCNumberOfChildren[kNumberOfParentParticleClassesInMC]; //! Number of children for fathers in MC (for different father classes)
 375     //    TH1D *fHistMCchildrenEtaDeviationsFromAverage[kNumberOfParentParticleClassesInMC];  //! MC delta b/n av. eta and each child's eta for each father (for different father classes)
 376     //    TH1D *fHistMCchildrenPhiDeviationsFromAverage[kNumberOfParentParticleClassesInMC];  //! MC delta b/n av. phi and each child's phi for each father (for different father classes)
 377     //    TH2D *fHist2DMCchildrenPhiDeviationsFromAverage[kNumberOfParentParticleClassesInMC];  //! MC delta b/n av. eta-phi and each child's eta and phi for each father (for different father classes)
 378
 379     //    TString fStrMCparticleClassForFillingLRC; // name of particle class for LRC filling (default is All)
 380     //    Double_t fEtaMCanalysisCutMin; // spec MC analysis: cut on eta
 381     //    Double_t fEtaMCanalysisCutMax; // spec MC analysis: cut on eta
 382
 383     //    TH1F *fHistMCparentDeepness;  //! MC deepness of parent tree from "physical primary" children
 384     //    TH1F *fHistMCparentsInitialStat;  //! MC initial papa particle class distr
 385
 386     //    TH1F *fHistMCEtaInitialQuark;  //! MC eta distr of "initial" quarks
 387     //    TH1F *fHistMCEtaInitialGluon;  //! MC eta distr of "initial" gluons
 388     //    TH1F *fHistMCEtaInitialProton;  //! MC eta distr of "initial" protons
 389
 390     //    TH1F *fHistMCnumberInitialQuarksInEvent;  //! MC initial quarks number distr
 391     //    TH1F *fHistMCnumberInitialGluonsInEvent;  //! MC initial gluons number distr
 392     //    TH1F *fHistMCnumberInitialProtonInEvent;  //! MC initial proton number distr (check that there are 2)
 393
 394     //    TH1F *fHistMCnumberChildrenFromInitialQuarksInEvent;  //! MC children number from initial quarks distr
 395     //    TH1F *fHistMCnumberChildrenFromInitialGluonsInEvent;  //! MC children number from initial gluons distr
 396     //    TH1F *fHistMCnumberChildrenFromInitialProtonInEvent;  //! MC children number from initial proton distr (check that there are 2)
 397
 398
 399     // 4.01.2012: MyTree stuff
 400     //    AliSimpleEvent *fSimpleEvent;   // instance of simple event to be filled in analysis loop
 401     //    Int_t fNsimpleEvents;
 402     //    TTree *fEventTree;              //! event tree to write into output file
 403     //    Bool_t fSetIncludeEventTreeInOutput;    // flag to use event tree or not
 404
 405     ClassDef(AliAnalysisTaskLRC, 11 );
 406 };
 407
 408 #endif