PWGLF/FORWARD/analysis2/AliBasedNdetaTask.h

   1 //
   2 // Task to analyse the AOD for for dN/deta in the base regions
   3 //
   4 #ifndef ALIBASEDNDETATASK_H
   5 #define ALIBASEDNDETATASK_H
   6 /**
   7  * @file   AliBasedNdetaTask.h
   8  * @author Christian Holm Christensen <cholm@dalsgaard.hehi.nbi.dk>
   9  * @date   Wed Mar 23 13:58:12 2011
  10  *
  11  * @brief
  12  *
  13  * @ingroup pwglf_forward_dndeta
  14  *
  15  */
  16 #include <AliAnalysisTaskSE.h>
  17 class TAxis;
  18 class TList;
  19 class TH2D;
  20 class TH1D;
  21 class TH1I;
  22 class AliAODEvent;
  23 class AliAODForwardMult;
  24 class TObjArray;
  25
  26 /**
  27  * @defgroup pwglf_forward_tasks_dndeta dN/deta tasks
  28  * @ingroup pwglf_forward_tasks
  29  */
  30 /**
  31  * @defgroup pwglf_forward_dndeta dN/deta
  32  *
  33  * @f$ dN/d\eta@f$ code
  34  *
  35  * @ingroup pwglf_forward_topical
  36  */
  37 /**
  38  * Base class for tasks to determine @f$ dN/d\eta@f$
  39  *
  40  * @ingroup pwglf_forward_tasks_dndeta
  41  * @ingroup pwglf_forward_dndeta
  42  */
  43 class AliBasedNdetaTask : public AliAnalysisTaskSE
  44 {
  45 public:
  46   /**
  47    * Bit mask values of the normalisation scheme
  48    */
  49   enum {
  50     /** Only normalize to accepted events */
  51     kNone = 0,
  52     /**
  53      * Do the full normalisation
  54      * @f[
  55      *   N = \frac{1}{\epsilon_X}(N_A-N_A/N_V(N_T-N_V)) =
  56      *       \frac{1}{\epsilon_X}\frac{1}{\epsilon_V}N_A
  57      * @f]
  58      */
  59     kEventLevel = 0x1,
  60     /**
  61      * Do the shape correction
  62      */
  63     kShape = 0x2,
  64     /**
  65      * Correct for background events (A+C-E). Not implemented yet
  66      */
  67     kBackground = 0x4,
  68     /**
  69      * Correct for the trigger efficiency from MC
  70      */
  71     kTriggerEfficiency = 0x8,
  72     /**
  73      * Correct using zero-bin efficiency only
  74      */
  75     kZeroBin = 0x10,
  76     /**
  77      * Do the full correction
  78      */
  79     kFull = kEventLevel | kShape | kBackground | kTriggerEfficiency,
  80   };
  81   /**
  82    * Constructor
  83    *
  84    */
  85   AliBasedNdetaTask();
  86   /**
  87    * Constructor
  88    *
  89    * @param name    Name of task
  90    */
  91   AliBasedNdetaTask(const char* name);
  92   /**
  93    * Destructor
  94    *
  95    */
  96   virtual ~AliBasedNdetaTask();
  97
  98   /**
  99    * @{
 100    * @name Task configuration
 101    */
 102   /**
 103    * Set the vertex range to use
 104    *
 105    * @param min Minimum (in centermeter)
 106    * @param max Maximum (in centermeter)
 107    */
 108   void SetVertexRange(Double_t min, Double_t max) { fVtxMin=min; fVtxMax=max; }
 109   /**
 110    * Set the rebinning factor
 111    *
 112    * @param rebin Rebinning factor
 113    */
 114   void SetRebinning(Int_t rebin) { fRebin = rebin; }
 115   /**
 116    * Set the trigger maskl
 117    *
 118    * @param mask Trigger mask
 119    */
 120   void SetTriggerMask(UShort_t mask);
 121   /**
 122    * Set the trigger mask
 123    *
 124    * @param mask trigger mask
 125    */
 126   void SetTriggerMask(const char* mask);
 127   /**
 128    * Set the centrality bins to use.
 129    *
 130    * @code
 131    *   UShort_t bins[] = { 0, 5, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
 132    *   task->SetCentralityBins(11, bins);
 133    * @endcode
 134    *
 135    * @param n     Number of bins (elements in @a bins minus 1)
 136    * @param bins  Bin limits
 137    */
 138   void SetCentralityAxis(UShort_t n, Short_t* bins);
 139   /**
 140    * Whether to cut edges when merging
 141    *
 142    * @param cut If true, cut edges
 143    */
 144   void SetCutEdges(Bool_t cut) {fCutEdges = cut;}
 145   /**
 146    * Set whether to correct for empty bins when projecting on the X axis.
 147    *
 148    * @param use Whether to correct for empty bins
 149    */
 150   void SetCorrEmpty(Bool_t use) { fCorrEmpty = use; }
 151   /**
 152    * Set whether to use the ROOT TH2::ProjectionX method when
 153    * projecting on the X axis.
 154    *
 155    * @param use Whether to use TH2::ProjectionX
 156    */
 157   void SetUseROOTProjectX(Bool_t use) { fUseROOTProj = use; }
 158   /**
 159    * Trigger efficiency for selected trigger(s)
 160    *
 161    * @param e Trigger efficiency
 162    */
 163   void SetTriggerEff(Double_t e) { fTriggerEff = e; }
 164   /**
 165    * Set the shape correction (a.k.a., track correction) for selected
 166    * trigger(s)
 167    *
 168    * @param h Correction
 169    */
 170   void SetShapeCorrection(const TH1* h);
 171   /**
 172    * Setthe normalisation scheme to use
 173    *
 174    * @param scheme Normalisation scheme
 175    */
 176   void SetNormalizationScheme(UShort_t scheme);
 177   /**
 178    * Space, pipe, or comma separated list of options
 179    *
 180    * @param what List of options
 181    */
 182   void SetNormalizationScheme(const char* what);
 183   /**
 184    * Filename of final MC correction
 185    *
 186    * @param filename filename
 187    */
 188   void SetMCFinalCorrFilename(const char* filename) {
 189     fFinalMCCorrFile.Clear();
 190     fFinalMCCorrFile.Append(filename);
 191   }
 192   /**
 193    * Load the normalization data - done automatically if not set from outside
 194    *
 195    * @param sys system
 196    * @param energy energy
 197    */
 198   void LoadNormalizationData(UShort_t sys, UShort_t energy);
 199   /** @} */
 200   /**
 201    * Print information
 202    *
 203    * @param option Not used
 204    */
 205   void Print(Option_t* option="") const;
 206   /** @{
 207    *  @name Task interface
 208    */
 209   /**
 210    * Initialise on master - does nothing
 211    *
 212    */
 213   virtual void   Init() {}
 214   /**
 215    * Create output objects.
 216    *
 217    * This is called once per slave process
 218    */
 219   virtual void UserCreateOutputObjects();
 220   /**
 221    * Process a single event
 222    *
 223    * @param option Not used
 224    */
 225   virtual void UserExec(Option_t* option);
 226   /**
 227    * Called at end of event processing.
 228    *
 229    * This is called once in the master
 230    *
 231    * @param option Not used
 232    */
 233   virtual void Terminate(Option_t* option);
 234   /* @} */
 235
 236   /**
 237    * @{
 238    * @name Services member functions
 239    */
 240   /**
 241    * Make a copy of the input histogram and rebin that histogram
 242    *
 243    * @param h         Histogram to rebin
 244    * @param rebin     Rebinning factor
 245    * @param cutEdges  Whether to cut edges when rebinning
 246    *
 247    * @return New (rebinned) histogram
 248    */
 249   static TH1D* Rebin(const TH1D* h, Int_t rebin, Bool_t cutEdges=false);
 250   /**
 251    * Make an extension of @a h to make it symmetric about 0
 252    *
 253    * @param h Histogram to symmertrice
 254    *
 255    * @return Symmetric extension of @a h
 256    */
 257   static TH1* Symmetrice(const TH1* h);
 258   /**
 259    * Project onto the X axis
 260    *
 261    * @param h         2D histogram
 262    * @param name      New name
 263    * @param firstbin  First bin to use
 264    * @param lastbin   Last bin to use
 265    * @param useROOT   Use TH2::ProjectionX instead of custom code
 266    * @param corr      Whether to do corrections or not
 267    * @param error     Whether to calculate errors
 268    *
 269    * @return Newly created histogram or null
 270    */
 271   static TH1D* ProjectX(const TH2D* h,
 272                         const char* name,
 273                         Int_t firstbin,
 274                         Int_t lastbin,
 275                         bool  useROOT=false,
 276                         bool  corr=true,
 277                         bool  error=true);
 278   /**
 279    * Scale the copy of the 2D histogram by coverage in supplied 1D histogram
 280    *
 281    * @param copy Data to scale
 282    * @param norm Coverage histogram
 283    */
 284   static void ScaleToCoverage(TH2D* copy, const TH1D* norm);
 285   /**
 286    * Set histogram graphical options, etc.
 287    *
 288    * @param h       Histogram to modify
 289    * @param colour  Marker color
 290    * @param marker  Marker style
 291    * @param title   Title of histogram
 292    * @param ytitle  Title on y-axis.
 293    */
 294   static void SetHistogramAttributes(TH1D* h, Int_t colour, Int_t marker,
 295                                      const char* title,
 296                                      const char* ytitle="#frac{1}{N} #frac{dN_{ch}}{d#eta}");
 297   /** @} */
 298
 299   /**
 300    * Marker styles
 301    */
 302   enum {
 303     kSolid        = 0x000,
 304     kHollow       = 0x001,
 305     kCircle       = 0x002,
 306     kSquare       = 0x004,
 307     kUpTriangle   = 0x006,
 308     kDownTriangle = 0x008,
 309     kDiamond      = 0x00a,
 310     kCross        = 0x00c,
 311     kStar         = 0x00e
 312   };
 313   static Int_t GetMarkerStyle(UShort_t bits);
 314   static UShort_t GetMarkerBits(Int_t style);
 315   static Int_t FlipHollowStyle(Int_t style);
 316 protected:
 317   /**
 318    * Copy contructor
 319    */
 320   AliBasedNdetaTask(const AliBasedNdetaTask&);
 321   /**
 322    * Assignment operator
 323    *
 324    *
 325    * @return
 326    */
 327   AliBasedNdetaTask& operator=(const AliBasedNdetaTask&) { return *this; }
 328   // Forward declaration
 329   class CentralityBin;
 330   /**
 331    * Retrieve the AOD event
 332    *
 333    * @param isESD If true, assume the AOD event is the output
 334    *
 335    * @return Pointer to AOD event or null
 336    */
 337   AliAODEvent* GetAODEvent(Bool_t isESD=false);
 338
 339   /**
 340    * Retrieve the histogram
 341    *
 342    * @param aod AOD event
 343    * @param mc  Whether to get the MC histogram or not
 344    *
 345    * @return Retrieved histogram or null
 346    */
 347   virtual TH2D* GetHistogram(const AliAODEvent* aod, Bool_t mc=false) = 0;
 348   /**
 349    * Get the colour to use for markers (only pp - in PbPb we use a rainbow)
 350    *
 351    * @return Marker colour
 352    */
 353   virtual Int_t GetColor() const { return kBlack; }
 354   /**
 355    * Get the marker style
 356    *
 357    * @return Marker style
 358    */
 359   virtual Int_t GetMarker() const { return GetMarkerStyle(kCircle); }
 360   /**
 361    * Add a centrality bin
 362    *
 363    * @param at   Where in the list to add this bin
 364    * @param low  Low cut
 365    * @param high High cut
 366    */
 367   void AddCentralityBin(UShort_t at, Short_t low, Short_t high);
 368   /**
 369    * Make a centrality bin
 370    *
 371    * @param name  Name used for histograms
 372    * @param low   Low cut in percent
 373    * @param high  High cut in percent
 374    *
 375    * @return A newly created centrality bin
 376    */
 377   virtual CentralityBin* MakeCentralityBin(const char* name, Short_t low,
 378                                            Short_t high) const;
 379
 380   //==================================================================
 381   /**
 382    * Class that holds the sum of the data - possibly split into 0 or
 383    * non-zero bins
 384    *
 385    */
 386   struct Sum : public TNamed
 387   {
 388     TH2D* fSum;     // Sum of non-zero events
 389     TH2D* fSum0;    // Sum of zero events
 390     TH1I* fEvents;  // Distribution of events
 391     /**
 392      * I/O Constructor - do not use
 393      */
 394     Sum() : fSum(0), fSum0(0), fEvents(0) {}
 395     /**
 396      * Constructor
 397      *
 398      * @param name      Name
 399      * @param postfix   Possible post-fix
 400      */
 401     Sum(const char* name, const char* postfix)
 402       : TNamed(name,postfix),
 403         fSum(0),
 404         fSum0(0),
 405         fEvents(0)
 406     {}
 407     /**
 408      * Copy constructor
 409      *
 410      * @param o Object to copy from
 411      */
 412     Sum(const Sum& o)
 413       : TNamed(o),
 414         fSum(o.fSum),
 415         fSum0(o.fSum0),
 416         fEvents(o.fEvents)
 417     {}
 418     /**
 419      * Assignment operator
 420      *
 421      * @param o Object to assign from
 422      *
 423      * @return Reference to this object
 424      */
 425     Sum& operator=(const Sum& o) {
 426       SetName(o.GetName()); fSum = o.fSum; fSum0 = o.fSum0; fEvents=o.fEvents;
 427       return *this;
 428     }
 429     /**
 430      * Destructor
 431      */
 432     ~Sum() {}
 433     /**
 434      * Initialise this object.
 435      *
 436      * @param list  List to add histograms to
 437      * @param data  Format of data to be cloned here
 438      * @param col   Color
 439      */
 440     void Init(TList* list, const TH2D* data, Int_t col);
 441     /**
 442      * Add an event
 443      *
 444      * @param data    Data to add
 445      * @param isZero  If this is zero event
 446      */
 447     void Add(const TH2D* data, Bool_t isZero=false);
 448     /**
 449      * Get the histogram name
 450      *
 451      * @param what Which one
 452      *
 453      * @return Name
 454      */
 455     TString GetHistName(Int_t what=0) const;
 456     /**
 457      * Get the sum
 458      *
 459      * @param l          List to get histograms from
 460      * @param o          Output list
 461      * @param ntotal     On return, the total number of events
 462      * @param zeroEff    Zero-bin efficiency
 463      * @param otherEff   Non-zero-bin efficiency
 464      * @param marker     Marker to use
 465      * @param rootXproj  Whether to use TH2::ProjectionX
 466      * @param corrEmpty  Correct for empty bins
 467      *
 468      * @return The total sum histogram
 469      */
 470     TH2D* GetSum(const TList* l, TList* o, Double_t& ntotal,
 471                  Double_t zeroEff, Double_t otherEff=1, Int_t marker=20,
 472                  Bool_t rootXproj=false, Bool_t corrEmpty=true) const;
 473   };
 474
 475   //==================================================================
 476   /**
 477    * Calculations done per centrality
 478    *
 479    */
 480   class CentralityBin : public TNamed
 481   {
 482   public:
 483     /** dN
 484      * Constructor
 485      */
 486     CentralityBin();
 487     /**
 488      * Constructor
 489      *
 490      * @param name Name used for histograms (e.g., Forward)
 491      * @param low  Lower centrality cut in percent
 492      * @param high Upper centrality cut in percent
 493      */
 494     CentralityBin(const char* name, Short_t low, Short_t high);
 495     /**
 496      * Copy constructor
 497      *
 498      * @param other Object to copy from
 499      */
 500     CentralityBin(const CentralityBin& other);
 501     /**
 502      * Destructor
 503      */
 504     virtual ~CentralityBin();
 505     /**
 506      * Assignment operator
 507      *
 508      * @param other Object to assign from
 509      *
 510      * @return Reference to this
 511      */
 512     CentralityBin& operator=(const CentralityBin& other);
 513     /**
 514      * Check if this is the 'all' bin
 515      *
 516      * @return true if low and high cuts are both zero
 517      */
 518     Bool_t IsAllBin() const { return fLow == 0 && fHigh == 0; }
 519     /**
 520      * Get the list name
 521      *
 522      * @return List Name
 523      */
 524     const char* GetListName() const;
 525     /**
 526      * Create output objects
 527      *
 528      * @param dir   Parent list
 529      */
 530     virtual void CreateOutputObjects(TList* dir);
 531     /**
 532      * Process an event
 533      *
 534      * @param forward     Forward data (for trigger, vertex, & centrality)
 535      * @param triggerMask Trigger mask
 536      * @param isZero      True if this is a zero bin event
 537      * @param vzMin       Minimum IP z coordinate
 538      * @param vzMax       Maximum IP z coordinate
 539      * @param data        Data histogram
 540      * @param mc          MC histogram
 541      */
 542     virtual void ProcessEvent(const AliAODForwardMult* forward,
 543                               Int_t                    triggerMask,
 544                               Bool_t                   isZero,
 545                               Double_t                 vzMin,
 546                               Double_t                 vzMax,
 547                               const TH2D*              data,
 548                               const TH2D*              mc);
 549     /**
 550      * Calculate the Event-Level normalization.
 551      *
 552      * The full event level normalization for trigger @f$X@f$ is given by
 553      * @f{eqnarray*}{
 554      *    N &=& \frac{1}{\epsilon_X}
 555      *          \left(N_A+\frac{N_A}{N_V}(N_{-V}-\beta)\right)\\
 556      *      &=& \frac{1}{\epsilon_X}N_A
 557      *          \left(1+\frac{1}{N_V}(N_T-N_V-\beta)\right)\\
 558      *      &=& \frac{1}{\epsilon_X}N_A
 559      *          \left(1+\frac{N_T}{N_V}-1-\frac{\beta}{N_V}\right)\\
 560      *      &=& \frac{1}{\epsilon_X}N_A
 561      *          \left(\frac{1}{\epsilon_V}-\frac{\beta}{N_V}\right)
 562      * @f}
 563      * where
 564      *
 565      * - @f$\epsilon_X=\frac{N_{T,X}}{N_X}@f$ is the trigger
 566      *   efficiency evaluated in simulation.
 567      * - @f$\epsilon_V=\frac{N_V}{N_T}@f$ is the vertex efficiency
 568      *   evaluated from the data
 569      * - @f$N_X@f$ is the Monte-Carlo truth number of events of type
 570      *   @f$X@f$.
 571      * - @f$N_{T,X}@f$ is the Monte-Carlo truth number of events of type
 572      *   @f$X@f$ which was also triggered as such.
 573      * - @f$N_T@f$ is the number of data events that where triggered
 574      *   as type @f$X@f$ and had a collision trigger (CINT1B)
 575      * - @f$N_V@f$ is the number of data events that where triggered
 576      *   as type @f$X@f$, had a collision trigger (CINT1B), and had
 577      *   a vertex.
 578      * - @f$N_{-V}@f$ is the number of data events that where triggered
 579      *   as type @f$X@f$, had a collision trigger (CINT1B), but no
 580      *   vertex.
 581      * - @f$N_A@f$ is the number of data events that where triggered
 582      *   as type @f$X@f$, had a collision trigger (CINT1B), and had
 583      *   a vertex in the selected range.
 584      * - @f$\beta=N_a+N_c-N_e@f$ is the number of control triggers that
 585      *   were also triggered as type @f$X@f$.
 586      * - @f$N_a@f$ Number of beam-empty events also triggered as type
 587      *   @f$X@f$ events (CINT1-A or CINT1-AC).
 588      * - @f$N_c@f$ Number of empty-beam events also triggered as type
 589      *   @f$X@f$ events (CINT1-C).
 590      * - @f$N_e@f$ Number of empty-empty events also triggered as type
 591      *   @f$X@f$ events (CINT1-E).
 592      *
 593      * Note, that if @f$ \beta \ll N_A@f$ the last term can be ignored, and
 594      * the expression simplyfies to
 595      * @f[
 596      *  N = \frac{1}{\epsilon_X}\frac{1}{\epsilon_V}N_A
 597      * @f]
 598      *
 599      * @param t       Histogram of triggers
 600      * @param scheme  Normalisation scheme
 601      * @param trgEff  Trigger efficiency
 602      * @param ntotal  On return, the total number of events to normalise to.
 603      *
 604      * @return @f$N_A/N@f$ or negative number in case of errors.
 605      */
 606     virtual Double_t Normalization(const TH1I& t,
 607                                    UShort_t    scheme,
 608                                    Double_t    trgEff,
 609                                    Double_t&   ntotal) const;
 610     /**
 611      * Generate the dN/deta result from input
 612      *
 613      * @param sum        Sum of 2D hists
 614      * @param postfix    Post fix on names
 615      * @param rootProj   Whether to use ROOT TH2::ProjectionX
 616      * @param corrEmpty  Correct for empty bins
 617      * @param shapeCorr  Shape correction to use
 618      * @param scaler     Event-level normalization scaler
 619      * @param symmetrice Whether to make symmetric extensions
 620      * @param rebin      Whether to rebin
 621      * @param cutEdges   Whether to cut edges when rebinning
 622      * @param marker     Marker style
 623      * @param color       Color of markers
 624      * @param mclist      List of MC data
 625      * @param truthlist   List of MC truth data
 626      */
 627     virtual void MakeResult(const TH2D* sum,
 628                             const char* postfix,
 629                             bool        rootProj,
 630                             bool        corrEmpty,
 631                             const TH1*  shapeCorr,
 632                             Double_t    scaler,
 633                             bool        symmetrice,
 634                             Int_t       rebin,
 635                             bool        cutEdges,
 636                             Int_t       marker,
 637                             Int_t       color,
 638                             TList*      mclist,
 639                             TList*      truthlist);
 640     /**
 641      * End of processing
 642      *
 643      * @param sums        List of sums
 644      * @param results     Output list of results
 645      * @param scheme      Normalisation scheme options
 646      * @param shapeCorr   Shape correction or nil
 647      * @param trigEff     Trigger efficiency
 648      * @param symmetrice  Whether to symmetrice the results
 649      * @param rebin       Whether to rebin the results
 650      * @param rootProj    If true, use TH2::ProjectionX
 651      * @param corrEmpty   Whether to correct for empty bins
 652      * @param cutEdges    Whether to cut edges when rebinning
 653      * @param triggerMask Trigger mask
 654      * @param marker      Marker style
 655      * @param color       Color of markers
 656      * @param mclist      List of MC data
 657      * @param truthlist   List of MC truth data
 658      */
 659     virtual void End(TList*      sums,
 660                      TList*      results,
 661                      UShort_t    scheme,
 662                      const TH1*  shapeCorr,
 663                      Double_t    trigEff,
 664                      Bool_t      symmetrice,
 665                      Int_t       rebin,
 666                      Bool_t      rootProj,
 667                      Bool_t      corrEmpty,
 668                      Bool_t      cutEdges,
 669                      Int_t       triggerMask,
 670                      Int_t       marker,
 671                      Int_t       color,
 672                      TList*      mclist,
 673                      TList*      truthlist);
 674     /**
 675      * @{
 676      * @name Access histograms
 677      */
 678     /**
 679      * Get sum histogram
 680      *
 681      * @param mc If true, return MC histogram
 682      *
 683      * @return Sum histogram
 684      */
 685     const Sum* GetSum(Bool_t mc=false) const { return mc ? fSumMC : fSum; }
 686     /**
 687      * Get sum histogram
 688      *
 689      * @param mc If true, return MC histogram
 690      *
 691      * @return Sum histogram
 692      */
 693     Sum* GetSum(Bool_t mc=false) { return mc ? fSumMC : fSum; }
 694     /**
 695      * Get trigger histogram
 696      *
 697      * @return Trigger histogram
 698      */
 699     const TH1I* GetTriggers() const { return fTriggers; }
 700     /**
 701      * Get trigger histogram
 702      *
 703      * @return Trigger histogram
 704      */
 705     TH1I* GetTrigggers() { return fTriggers; }
 706     /** @} */
 707
 708     /**
 709      * Get the color of the markers
 710      *
 711      * @return
 712      */
 713     Int_t GetColor(Int_t fallback=kRed+2) const;
 714     /**
 715      * Get list of results
 716      *
 717      *
 718      * @return
 719      */
 720     TList* GetResults() const { return fOutput; }
 721     /**
 722      * Get name of result histogram
 723      *
 724      * @param rebin
 725      * @param sym
 726      * @param postfix
 727      *
 728      * @return
 729      */
 730     const char* GetResultName(Int_t rebin, Bool_t sym,
 731                               const char* postfix="") const;
 732     /**
 733      * Get a result
 734      *
 735      * @param rebin
 736      * @param sym
 737      * @param postfix
 738      *
 739      * @return
 740      */
 741     TH1* GetResult(Int_t rebin, Bool_t sym,
 742                    const char* postfix="") const;
 743
 744   protected:
 745     /**
 746      * Create sum histogram
 747      *
 748      * @param data  Data histogram to clone
 749      * @param mc    (optional) MC histogram to clone
 750      */
 751     virtual void CreateSums(const TH2D* data, const TH2D* mc);
 752     /**
 753      * Check the trigger, vertex, and centrality
 754      *
 755      * @param forward Event input
 756      * @param triggerMask  The used trigger mask
 757      * @param vzMin        Least @f$ v_z@f$
 758      * @param vzMax        Largest @f$ v_z@f$
 759      *
 760      * @return true if the event is to be used
 761      */
 762     virtual Bool_t CheckEvent(const AliAODForwardMult* forward,
 763                               Int_t                    triggerMask,
 764                               Double_t                 vzMin,
 765                               Double_t vzMax);
 766     TList*   fSums;      // Output list
 767     TList*   fOutput;    // Output list
 768     Sum*     fSum;       // Sum histogram
 769     Sum*     fSumMC;     // MC sum histogram
 770     TH1I*    fTriggers;  // Trigger histogram
 771     UShort_t fLow;       // Lower limit (inclusive)
 772     UShort_t fHigh;      // Upper limit (exclusive)
 773     Bool_t   fDoFinalMCCorrection; //Do final MC correction
 774
 775     ClassDef(CentralityBin,1); // A centrality bin
 776   };
 777   TList*          fSums;         // Container of sums
 778   TList*          fOutput;       // Container of outputs
 779   Double_t        fVtxMin;       // Minimum v_z
 780   Double_t        fVtxMax;       // Maximum v_z
 781   Int_t           fTriggerMask;  // Trigger mask
 782   Int_t           fRebin;        // Rebinning factor
 783   Bool_t          fCutEdges;     // Whether to cut edges when rebinning
 784   Bool_t          fSymmetrice;   // Whether to symmetrice data
 785   Bool_t          fCorrEmpty;    // Correct for empty bins
 786   Bool_t          fUseROOTProj;  // Whether to use ROOT's ProjectionX
 787   Double_t        fTriggerEff;   // Trigger efficiency for selected trigger(s)
 788   TH1*            fShapeCorr;    // Shape correction
 789   TObjArray*      fListOfCentralities; // Centrality bins
 790   TNamed*         fSNNString;    // sqrt(s_NN) string
 791   TNamed*         fSysString;    // Collision system string
 792   TH1D*           fCent;         // Centrality distribution
 793   TAxis*          fCentAxis;     // Centrality axis
 794   UShort_t        fNormalizationScheme; // Normalization scheme
 795   TNamed*         fSchemeString;     // Normalization scheme string
 796   TNamed*         fTriggerString;    // Trigger string
 797   TString         fFinalMCCorrFile; //Filename for final MC corr
 798   Bool_t          fIsESD;           // Whether we have ESD input or not
 799
 800   ClassDef(AliBasedNdetaTask,5); // Determine multiplicity in base area
 801 };
 802
 803 #endif
 804 //
 805 // Local Variables:
 806 //  mode: C++
 807 // End:
 808 //