PWGUD/DIFFRACTIVE/xsAndTwoProng/AliCDMesonBase.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15 //
  16 // AliDDMesonBase
  17 // for
  18 // AliAnalysisTaskDDMeson
  19 //
  20 //  Author:
  21 //  Xianguo Lu <lu@physi.uni-heidelberg.de>
  22 //  continued by
  23 //  Felix Reidt <Felix.Reidt@cern.ch>
  24
  25 #include "TH2.h"
  26 #include "TH2D.h"
  27 #include "TH1I.h"
  28 #include "TAxis.h"
  29 #include "THnSparse.h"
  30 #include "TString.h"
  31 #include "TList.h"
  32
  33 #include "AliCDMesonBase.h"
  34
  35
  36 //------------------------------------------------------------------------------
  37 //== INVARIANT MASS DISTRIBUTIONS (ThnMother) ================================
  38 //-- event characteristics
  39 // number of charged primary particles - combined => can be w/ soft tracks
  40 const Int_t AliCDMesonBase::fgkNNcombined      = 2; // number of bins
  41 const Double_t AliCDMesonBase::fgkMinNcombined = 2; // lower border
  42 const Double_t AliCDMesonBase::fgkMaxNcombined = 4; // upper border (#bins + lower border)
  43
  44 // unlike sign or like sign charged?
  45 const Int_t AliCDMesonBase::fgkNCombCh      = 2; // kBinPPMM = number of bins
  46 const Double_t AliCDMesonBase::fgkMinCombCh = 1.; // kBinPM = lower border
  47 const Double_t AliCDMesonBase::fgkMaxCombCh = 3.; // kBinPPMM + kBinPM = upper border
  48
  49 // two track PID, take care the enum changed from time to time
  50 const Int_t AliCDMesonBase::fgkNCombPID      = 13; // kBinPIDUnknown = number of bins
  51 const Double_t AliCDMesonBase::fgkMinCombPID = 1.; // kBinPionE = lower border
  52 const Double_t AliCDMesonBase::fgkMaxCombPID = 14.;// ...  = upper border
  53
  54 // gap configuration, used for different detectors
  55 const Int_t AliCDMesonBase::fgkNGapConfig      = 4; // kBinNG = number of bins
  56 const Double_t AliCDMesonBase::fgkMinGapConfig = 1.; // kBinDG = lower border
  57 const Double_t AliCDMesonBase::fgkMaxGapConfig = 5.; // kBinNG + kBinDG = upper border
  58
  59 //-- mother kinematics
  60 // invariant mass of the two-track system
  61 const Int_t AliCDMesonBase::fgkNMass      = 1024; // number of bins
  62 const Double_t AliCDMesonBase::fgkMinMass = 0.; // lower border
  63 const Double_t AliCDMesonBase::fgkMaxMass = 5.12; // upper border
  64
  65 // transverse momentum of the two-track system
  66 const Int_t AliCDMesonBase::fgkNMotherPt      = 128;//10; // number of bins
  67 const Double_t AliCDMesonBase::fgkMinMotherPt = 0.; // lower border
  68 const Double_t AliCDMesonBase::fgkMaxMotherPt = .64; //6.4 //2; // upper border
  69
  70 // cosine theta* (opening angle of the two daugther tracks in the
  71 // centre-of-mass system of the two-track/mother system)
  72 // **no meaning full variable**
  73 const Int_t AliCDMesonBase::fgkNCTS      = 2; // number of bins
  74 const Double_t AliCDMesonBase::fgkMinCTS = -1.; // lower border
  75 const Double_t AliCDMesonBase::fgkMaxCTS = -0.9; // upper border
  76
  77 // opening angle in the lab frame
  78 const Int_t AliCDMesonBase::fgkNOA      = 20; // number of bins
  79 const Double_t AliCDMesonBase::fgkMinOA = -1.; // lower border
  80 const Double_t AliCDMesonBase::fgkMaxOA = 1.; // upper border
  81
  82 //-- daughter kinematics
  83 // transverse momentum of one of the two daughter particles
  84 // (randomly selected)
  85 const Int_t AliCDMesonBase::fgkNDaughterPt      = 128; // number of bins
  86 const Double_t AliCDMesonBase::fgkMinDaughterPt = 0.; // lower border
  87 const Double_t AliCDMesonBase::fgkMaxDaughterPt = 6.4; // upper border
  88
  89 // pseudo rapidity of one of the two daughter particles
  90 // (randomly selected)
  91 //const Int_t AliCDMesonBase::fgkNDaughterEta      = 64; // number of bins
  92 //const Double_t AliCDMesonBase::fgkMinDaughterEta = -1.28; // lower border
  93 //const Double_t AliCDMesonBase::fgkMaxDaughterEta =  1.28; // upper border
  94
  95 //-- Event quality information
  96 // boolean values to reduce output size
  97
  98 // are there tracks in addition to the ones selected using AliCDMesonTracks
  99 // (ITSTPC, ITSsa, ITSpureSA) (0 = no, 1 = yes)
 100 const Int_t AliCDMesonBase::fgkNTrackResiduals      = 2; // number of bins
 101 const Double_t AliCDMesonBase::fgkMinTrackResiduals = 0.; // lower border
 102 const Double_t AliCDMesonBase::fgkMaxTrackResiduals = 2.; // upper border
 103
 104 // vertex with in +/-4cm (0 = no, 1 = yes)
 105 const Int_t AliCDMesonBase::fgkNVertexZinRng      = 2; // number of bins
 106 const Double_t AliCDMesonBase::fgkMinVertexZinRng = 0.; // lower border
 107 const Double_t AliCDMesonBase::fgkMaxVertexZinRng = 2.; // upper border
 108
 109 // are the vertices from SPD and tracks within 0.5cm? (0 = no, 1 = yes)
 110 const Int_t AliCDMesonBase::fgkNVertexCoincidence      = 2; // number of bins
 111 const Double_t AliCDMesonBase::fgkMinVertexCoincidence = 0.; // lower border
 112 const Double_t AliCDMesonBase::fgkMaxVertexCoincidence = 2.; // upper border
 113
 114 // are there SPD tracklets which are not assigned to tracks? (0 = no, 1 = yes)
 115 const Int_t AliCDMesonBase::fgkNTrackletResiduals      = 2; // number of bins
 116 const Double_t AliCDMesonBase::fgkMinTrackletResiduals = 0.; // lower border
 117 const Double_t AliCDMesonBase::fgkMaxTrackletResiduals = 2.; // upper border
 118
 119 //-- MC event information
 120 const Int_t AliCDMesonBase::fgkNProcessType      = 4; // kBinDD = number of bins
 121 const Double_t AliCDMesonBase::fgkMinProcessType = 0.; // kBinND = lower border
 122 const Double_t AliCDMesonBase::fgkMaxProcessType = 4.; // kBinDD = upper border
 123
 124
 125 //== EMPTY EVENT STUDY (ThnEmptyEvents) ======================================
 126 // event type
 127 const Int_t AliCDMesonBase::fgkNEventType      = 5; // kBinEventE = number of bins (5)
 128 const Double_t AliCDMesonBase::fgkMinEventType = 1.; // kBinEventI = lower border (1)
 129 const Double_t AliCDMesonBase::fgkMaxEventType = 6.; // kBinEventE+kBinEventI = u. b.
 130
 131 // multiplicities (reused for different detectors and ways of counting)
 132 const Int_t AliCDMesonBase::fgkNMult      = 32; // number of bins
 133 const Double_t AliCDMesonBase::fgkMinMult = 0.; // lower border
 134 const Double_t AliCDMesonBase::fgkMaxMult = 31.; // upper border
 135
 136 // multplicities - extended range
 137 // (reused for different detectors and ways of counting)
 138 const Int_t AliCDMesonBase::fgkNMultW      = 64; // number of bins
 139 const Double_t AliCDMesonBase::fgkMinMultW = 0; // lower border
 140 const Double_t AliCDMesonBase::fgkMaxMultW = 63; // upper border
 141
 142 //== MULTIPLICITY STUDY (TnnMultiplicity) ====================================
 143 // number of ITSTPC tracks in event
 144 const Int_t AliCDMesonBase::fgkNNch      = 51; // number of bins
 145 const Double_t AliCDMesonBase::fgkMinNch = 0.; // lower border
 146 const Double_t AliCDMesonBase::fgkMaxNch = 51.; // upper border
 147
 148 // number of ITS standalone tracks in event
 149 const Int_t AliCDMesonBase::fgkNNsoft      = 11; // number of bins
 150 const Double_t AliCDMesonBase::fgkMinNsoft = 0.; // lower border
 151 const Double_t AliCDMesonBase::fgkMaxNsoft = 11.; // upper border
 152
 153 // combined multiplicity
 154 const Int_t AliCDMesonBase::fgkNNcomb      = 61; // number of bins
 155 const Double_t AliCDMesonBase::fgkMinNcomb = 0.; // lower border
 156 const Double_t AliCDMesonBase::fgkMaxNcomb = 61.; // upper border
 157
 158 // gap configuration is reused from THnMother
 159
 160 // number of residual tracks
 161 const Int_t AliCDMesonBase::fgkNNresidualTracks      = 11; // number of bins
 162 const Double_t AliCDMesonBase::fgkMinNresidualTracks = 0.; // lower border
 163 const Double_t AliCDMesonBase::fgkMaxNresidualTracks = 11.; // upper border
 164
 165 // number of residual tracklets
 166 const Int_t AliCDMesonBase::fgkNNresidualTracklets      = 21; // number of bins
 167 const Double_t AliCDMesonBase::fgkMinNresidualTracklets = 0.; // lower border
 168 const Double_t AliCDMesonBase::fgkMaxNresidualTracklets = 21.; // upper border
 169
 170 // vertex z-position
 171 const Int_t AliCDMesonBase::fgkNVertexZ      = 20; // number of bins
 172 const Double_t AliCDMesonBase::fgkMinVertexZ = -10.; // lower border
 173 const Double_t AliCDMesonBase::fgkMaxVertexZ = 10.; // upper border
 174
 175 // SPD and track vertex distance
 176 const Int_t AliCDMesonBase::fgkNVerticesDistance      = 10; // number of bins
 177 const Double_t AliCDMesonBase::fgkMinVerticesDistance = 0.; // lower border
 178 const Double_t AliCDMesonBase::fgkMaxVerticesDistance = 5.; // upper border
 179
 180
 181 //------------------------------------------------------------------------------
 182 Int_t AliCDMesonBase::GetGapBin(TString tag, Int_t gapcg,
 183                                 Bool_t checkCentralActivity /* = kTRUE */)
 184 {
 185         //
 186         // retrieve gap topology for a given string
 187         //
 188
 189         tag.ToUpper();
 190
 191         Bool_t ka = kFALSE, kc = kFALSE;
 192
 193         if(tag.Contains("V0")){
 194                 ka = ka || (gapcg & kBitV0A);
 195                 kc = kc || (gapcg & kBitV0C);
 196         }
 197         if(tag.Contains("FMD")){
 198                 ka = ka || (gapcg & kBitFMDA);
 199                 kc = kc || (gapcg & kBitFMDC);
 200         }
 201         if(tag.Contains("SPD")){
 202                 ka = ka || (gapcg & kBitSPDA);
 203                 kc = kc || (gapcg & kBitSPDC);
 204         }
 205         if(tag.Contains("TPC")){
 206                 ka = ka || (gapcg & kBitTPCA);
 207                 kc = kc || (gapcg & kBitTPCC);
 208         }
 209         if(tag.Contains("ZDC")){
 210                 ka = ka || (gapcg & kBitZDCA);
 211                 kc = kc || (gapcg & kBitZDCC);
 212         }
 213
 214         if(ka && kc)
 215                 return kBinNG;
 216         else{
 217                 if(!ka && !kc)
 218                         if (((gapcg & kBitCentAct) && checkCentralActivity) ||
 219                             !checkCentralActivity) {
 220                                 return kBinDG; // central activity seen (or not required)
 221                         }
 222                         else {
 223                                 return kBinNG; // no central activity
 224                         }
 225                 else if(!kc)
 226                         return kBinGC;
 227                 else
 228                         return kBinGA;
 229         }
 230 }
 231
 232
 233 //------------------------------------------------------------------------------
 234 void AliCDMesonBase::CheckRange(Double_t &var, Double_t min,
 235                                 Double_t max)
 236 {
 237         //
 238         // check whether the value is with in the range specified with min and max
 239         //
 240
 241         const Double_t eps = 1e-3;
 242         if( var >= max ) var = max - eps;
 243         if( var <= min ) var = min + eps;
 244 }
 245
 246
 247 //------------------------------------------------------------------------------
 248 Int_t AliCDMesonBase::GetAxis(TString thntit, TString name)
 249 {
 250         //
 251         // get the number of an axis, derived from the ThnSparse title (list of axes)
 252         //
 253
 254         thntit.ToUpper();
 255         thntit.ReplaceAll(" ","");
 256         const Int_t nmax = 20;
 257         TString tits[nmax];
 258         Int_t counter = 0;
 259         while(thntit.Contains(",")){
 260                 const Int_t pos = thntit.First(",");
 261                 tits[counter] = thntit(0, pos);
 262                 thntit = thntit(pos+1, thntit.Length()-pos);
 263                 counter++;
 264                 if(counter>=nmax-1){
 265                         printf("AliCDMesonBase AliCDMesonBase::GetAxis too small nmax! %d %d\n",
 266                                counter, nmax);
 267                         return -1; //exit(1); // TODO
 268                 }
 269         }
 270         tits[counter++] = thntit;
 271
 272         //----------------
 273
 274         name.ToUpper();
 275
 276         for(Int_t ii=0; ii<counter; ii++){
 277           if( tits[ii] == name )
 278                   return ii;
 279         }
 280         printf("AliCDMesonBase AliCDMesonBase::GetAxis !%s! %s not found!\n",
 281                name.Data(), thntit.Data());
 282         for(Int_t ii=0; ii<counter; ii++){
 283                 printf("*************** AliCDMesonBase::GetAxis *****************\n");
 284                 printf("AliCDMesonBase AliCDMesonBase::GetAxis %d !%s!\n", ii,
 285                        tits[ii].Data());
 286                 printf("\n");
 287         }
 288         return -1; //exit(1); // TODO
 289 }
 290
 291
 292 //------------------------------------------------------------------------------
 293 TString AliCDMesonBase::GetTitleMother()
 294 {
 295         //
 296         // get the title of ThnMother (= list of axes)
 297         //
 298
 299         TString title = "Ncombined, CombCh, CombPID, V0, FMD, SPD, TPC,";
 300         title += " Mass, Pt, CTS, OA, DaughterPt, TrackResiduals, VertexZinRng,";
 301         title += " ProcessType, VertexCoincidence, TrackletResiduals";
 302         return title;
 303 }
 304
 305
 306 //------------------------------------------------------------------------------
 307 THnSparseD * AliCDMesonBase::GetThnMother(TString name /* = "CDMeson_Mother" */)
 308 {
 309         // creates the THnSparse called Mother (used for the generation of invariant
 310         // mass distributions)
 311         //
 312
 313         const Int_t nbin[] = {
 314                 fgkNNcombined, fgkNCombCh, fgkNCombPID, fgkNGapConfig, fgkNGapConfig,
 315                 fgkNGapConfig, fgkNGapConfig, fgkNMass, fgkNMotherPt, fgkNCTS, fgkNOA,
 316                 fgkNDaughterPt, fgkNTrackResiduals, fgkNVertexZinRng, fgkNProcessType,
 317                 fgkNVertexCoincidence, fgkNTrackletResiduals
 318         };
 319         const Double_t binmin[] = {
 320                 fgkMinNcombined, fgkMinCombCh, fgkMinCombPID, fgkMinGapConfig,
 321                 fgkMinGapConfig, fgkMinGapConfig, fgkMinGapConfig, fgkMinMass,
 322                 fgkMinMotherPt, fgkMinCTS, fgkMinOA, fgkMinDaughterPt,
 323                 fgkMinTrackResiduals, fgkMinVertexZinRng, fgkMinProcessType,
 324                 fgkMinVertexCoincidence, fgkMinTrackletResiduals
 325         };
 326         const Double_t binmax[] = {
 327                 fgkMaxNcombined, fgkMaxCombCh, fgkMaxCombPID, fgkMaxGapConfig,
 328                 fgkMaxGapConfig, fgkMaxGapConfig, fgkMaxGapConfig, fgkMaxMass,
 329                 fgkMaxMotherPt, fgkMaxCTS, fgkMaxOA, fgkMaxDaughterPt,
 330                 fgkMaxTrackResiduals, fgkMaxVertexZinRng, fgkMaxProcessType,
 331                 fgkMaxVertexCoincidence, fgkMaxTrackletResiduals
 332         };
 333
 334         const Int_t npar = sizeof(nbin)/sizeof(Int_t);
 335
 336         return new THnSparseD(name.Data(), GetTitleMother(), npar, nbin, binmin,
 337                               binmax);
 338 }
 339
 340
 341 //------------------------------------------------------------------------------
 342 void AliCDMesonBase::FillThnMother(THnSparseD *thn, Double_t vNch,
 343                                    Double_t vCombCh,
 344                                    Double_t vCombPID, Double_t vV0,
 345                                    Double_t vFMD, Double_t vSPD,
 346                                    Double_t vTPC, Double_t vMass,
 347                                    Double_t vPt,  Double_t vOA,
 348                                    Double_t vCTS,
 349                                    Double_t vDaughterPt,
 350                                    Double_t vTrackResiduals,
 351                                    Double_t vVertexZ,
 352                                    Double_t vProcessType,
 353                                    Double_t vVertexCoincidence,
 354                                    Double_t vTrkltResiduals)
 355 {
 356         //
 357         // fill ThnMother
 358         //
 359
 360         Double_t var[]={
 361                 vNch, vCombCh, vCombPID, vV0, vFMD, vSPD, vTPC, vMass, vPt, vOA, vCTS,
 362                 vDaughterPt, vTrackResiduals, vVertexZ, vProcessType, vVertexCoincidence,
 363                 vTrkltResiduals
 364         };
 365         const Int_t nv = sizeof(var)/sizeof(Double_t);
 366         if(nv!=thn->GetNdimensions()){
 367                 printf("AliCDMesonBase::FillThnMother nv error!! %d %d\n", nv,
 368                        thn->GetNdimensions());
 369                 return; //exit(1);
 370         }
 371
 372         CheckRange(var[7], fgkMinMass, fgkMaxMass);
 373         CheckRange(var[8], fgkMinMotherPt, fgkMaxMotherPt);
 374         CheckRange(var[11], fgkMinDaughterPt, fgkMaxDaughterPt);
 375
 376         thn->Fill(var);
 377 }
 378
 379
 380 //------------------------------------------------------------------------------
 381 Int_t AliCDMesonBase::GetAxisMother(TString name)
 382 {
 383         //
 384         // return axis number corresponding to the name
 385         //
 386
 387         return GetAxis(GetTitleMother(), name);
 388 }
 389
 390
 391 //------------------------------------------------------------------------------
 392 TString AliCDMesonBase::GetTitleEmptyEvents()
 393 {
 394         //
 395         // title / list of axes of the empty event study THnSparse
 396         //
 397
 398         TString title = "EventType, FMD-A, FMD-C, SPD-I-A, SPD-I-C, SPD-O-A, SPD-O-C";
 399         title += ", SPDtrkltA, SPDtrkltC";
 400         title += ", fmdSum1I, fmdSum2I, fmdSum2O, fmdSum3I, fmdSum3O";
 401         //title += ", TPC_all, TPC_diffVertex";
 402         return title;
 403 }
 404
 405
 406 //------------------------------------------------------------------------------
 407 THnSparseD* AliCDMesonBase::GetThnEmptyEvents()
 408 {
 409         // creates the THnSparse called Empty Events
 410         // EventType, FMD-A, FMD-C, SPD-I-A, SPD-I-C, SPD-O-A, SPD-O-C, FMD1I..FMD3O
 411         // TPC_all, TPC_diffVertex (not used so far)
 412
 413         const Int_t nbin[] = {
 414                 fgkNEventType, fgkNMultW, fgkNMultW, fgkNMult, fgkNMult, fgkNMult, fgkNMult,
 415                 fgkNMult, fgkNMult, fgkNMult, fgkNMult, fgkNMult, fgkNMult, fgkNMult
 416                 //, fgkNMult, fgkNMult
 417         };
 418         const Double_t binmin[] = {
 419                 fgkMinEventType, fgkMinMultW, fgkMinMultW, fgkMinMult, fgkMinMult,
 420                 fgkMinMult, fgkMinMult, fgkMinMult, fgkMinMult, fgkMinMult, fgkMinMult,
 421                 fgkMinMult, fgkMinMult, fgkMinMult //, fgkMinMult, fgkMinMult
 422         };
 423         const Double_t binmax[] = {
 424                 fgkMaxEventType, fgkMaxMultW, fgkMaxMultW, fgkMaxMult, fgkMaxMult,
 425                 fgkMaxMult, fgkMaxMult, fgkMaxMult, fgkMaxMult, fgkMaxMult, fgkMaxMult,
 426                 fgkMaxMult, fgkMaxMult, fgkMaxMult //, fgkMaxMult, fgkMaxMult
 427         };
 428
 429         const Int_t npar = sizeof(nbin)/sizeof(Int_t);
 430
 431         return new THnSparseD("CDMeson_EmptyEvents", GetTitleEmptyEvents(), npar,
 432                               nbin, binmin, binmax);
 433 }
 434
 435
 436 //------------------------------------------------------------------------------
 437 void AliCDMesonBase::FillThnEmptyEvents(THnSparseD * thn, Int_t eventType,
 438                                         Int_t multFMDA,
 439                                         Int_t multFMDC,
 440                                         Int_t multSPDIA,
 441                                         Int_t multSPDIC,
 442                                         Int_t multSPDOA,
 443                                         Int_t multSPDOC,
 444                                         Int_t multSPDtrkltA,
 445                                         Int_t multSPDtrkltC,
 446                                         Int_t fmdSum1I,
 447                                         Int_t fmdSum2I,
 448                                         Int_t fmdSum2O,
 449                                         Int_t fmdSum3I,
 450                                         Int_t fmdSum3O/*,
 451                                         Int_t multTPC,
 452                                         Int_t multTPCdiffVertex */)
 453 {
 454         //
 455         // Fill ThnEmptyEvents
 456         //
 457
 458         Double_t var[]={
 459           static_cast<Double_t>(eventType), static_cast<Double_t>(multFMDA), static_cast<Double_t>(multFMDC), static_cast<Double_t>(multSPDIA), static_cast<Double_t>(multSPDIC), static_cast<Double_t>(multSPDOA),
 460           static_cast<Double_t>(multSPDOC), static_cast<Double_t>(multSPDtrkltA), static_cast<Double_t>(multSPDtrkltC), static_cast<Double_t>(fmdSum1I), static_cast<Double_t>(fmdSum2I), static_cast<Double_t>(fmdSum2O),
 461           static_cast<Double_t>(fmdSum3I), static_cast<Double_t>(fmdSum3O)//, multTPC, multTPCdiffVertex
 462         };
 463         const Int_t nv = sizeof(var)/sizeof(Double_t);
 464         if(nv!=thn->GetNdimensions()){
 465                 printf("AliCDMesonBase::FillThnEmptyEvents nv error!! %d %d\n", nv,
 466                        thn->GetNdimensions());
 467                 return; //exit(1); // TODO
 468         }
 469
 470         thn->Fill(var);
 471 }
 472
 473
 474 //------------------------------------------------------------------------------
 475 Int_t AliCDMesonBase::GetAxisEmptyEvents(TString name)
 476 {
 477         //
 478         // return axis number corresponding to the name
 479         //
 480
 481         return GetAxis(GetTitleEmptyEvents(), name);
 482 }
 483
 484
 485 //------------------------------------------------------------------------------
 486 TString AliCDMesonBase::GetTitleMultiplicity()
 487 {
 488         //
 489         // get title of the multiplicity study ThnSparse
 490         //
 491
 492         TString title = "Nch, Nsoft, Ncombined, V0, FMD, SPD, TPC, NresidualTracks";
 493         title += ", NresidualTracklets, VertexZ, VerticesDistance, ProcessType";
 494         return title;
 495 }
 496
 497
 498 //------------------------------------------------------------------------------
 499 THnSparseD* AliCDMesonBase::GetThnMultiplicity()
 500 {
 501         //
 502         // creates the THnSparse called Multiplicity
 503         //
 504
 505         const Int_t nbin[] = {
 506                 fgkNNch, fgkNNsoft, fgkNNcomb,fgkNGapConfig, fgkNGapConfig,
 507                 fgkNGapConfig, fgkNGapConfig, fgkNNresidualTracks, fgkNNresidualTracklets,
 508                 fgkNVertexZ, fgkNVerticesDistance, fgkNProcessType
 509         };
 510         const Double_t binmin[] = {
 511                 fgkMinNch, fgkMinNsoft, fgkMinNcomb, fgkMinGapConfig, fgkMinGapConfig,
 512                 fgkMinGapConfig, fgkMinGapConfig, fgkMinNresidualTracks,
 513                 fgkMinNresidualTracklets, fgkMinVertexZ, fgkMinVerticesDistance,
 514                 fgkMinProcessType
 515         };
 516         const Double_t binmax[] = {
 517                 fgkMaxNch, fgkMaxNsoft, fgkMaxNcomb, fgkMaxGapConfig, fgkMaxGapConfig,
 518                 fgkMaxGapConfig, fgkMaxGapConfig, fgkMaxNresidualTracks,
 519                 fgkMaxNresidualTracklets, fgkMaxVertexZ, fgkMaxVerticesDistance,
 520                 fgkMaxProcessType
 521         };
 522
 523         const Int_t npar = sizeof(nbin)/sizeof(Int_t);
 524
 525         return new THnSparseD("CDMeson_Multiplicity", GetTitleMultiplicity(), npar,
 526                               nbin, binmin, binmax);
 527 }
 528
 529
 530 //------------------------------------------------------------------------------
 531 void AliCDMesonBase::FillThnMultiplicity(THnSparseD *thn, Double_t vNch,
 532                                          Double_t vNsoft,
 533                                          Double_t vNcombined,
 534                                          Double_t vV0,
 535                                          Double_t vFMD,
 536                                          Double_t vSPD,
 537                                          Double_t vTPC,
 538                                          Double_t vNresidualTracks,
 539                                          Double_t vNresidualTracklets,
 540                                          Double_t vVertexZ,
 541                                          Double_t vVerticesDistance,
 542                                          Double_t vProcessType)
 543 {
 544         // fill ThnMultiplicity
 545         // input list copied from GetTitle
 546         // var[] copied from GetTitle
 547
 548         Double_t var[]={
 549                 vNch, vNsoft, vNcombined, vV0, vFMD, vSPD, vTPC, vNresidualTracks,
 550                 vNresidualTracklets, vVertexZ, vVerticesDistance, vProcessType
 551         };
 552         const Int_t nv = sizeof(var)/sizeof(Double_t);
 553         if(nv!=thn->GetNdimensions()){
 554                 printf("AliCDMesonBase::FillThnMultiplicity nv error!! %d %d\n", nv,
 555                        thn->GetNdimensions());
 556                 return; //exit(1);
 557         }
 558
 559         thn->Fill(var);
 560 }
 561
 562
 563 //------------------------------------------------------------------------------
 564 Int_t AliCDMesonBase::GetAxisMultiplicity(TString name)
 565 {
 566         //
 567         // return axis number corresponding to the name
 568         //
 569
 570         return GetAxis(GetTitleMultiplicity(), name);
 571 }
 572
 573
 574 //------------------------------------------------------------------------------
 575 TH1F* AliCDMesonBase::GetHistStatsFlow()
 576 {
 577         //
 578         // setup the stats flow histogram
 579         //
 580
 581         TH1F *hist = new TH1F("c00_statsFlow", "", AliCDMesonBase::kBinLastValue,
 582                         0, AliCDMesonBase::kBinLastValue);
 583         TAxis* axis = hist->GetXaxis();
 584         axis->SetBinLabel(AliCDMesonBase::kBinTotalInput+1, "total Input");
 585         axis->SetBinLabel(AliCDMesonBase::kBinGoodInput+1, "good ESDs");
 586         axis->SetBinLabel(AliCDMesonBase::kBinV0OR+1, "V0-OR");
 587         axis->SetBinLabel(AliCDMesonBase::kBinV0AND+1, "V0-AND");
 588         axis->SetBinLabel(AliCDMesonBase::kBinEventsAfterCuts+1, "after cuts");
 589         axis->SetBinLabel(AliCDMesonBase::kBinEventsWithOutPileUp+1, "w/o pile up");
 590         axis->SetBinLabel(AliCDMesonBase::kBinv0Gap+1, "with V0 DG gap");
 591         axis->SetBinLabel(AliCDMesonBase::kBinv0fmdGap+1, "with V0-FMD DG gap");
 592         axis->SetBinLabel(AliCDMesonBase::kBinv0fmdspdGap+1,
 593                           "with V0-FMD-SPD DG gap");
 594         axis->SetBinLabel(AliCDMesonBase::kBinv0fmdspdtpcGap+1,
 595                           "with V0-FMD-SPD-TPC DG gap");
 596         axis->SetBinLabel(AliCDMesonBase::kBinv0fmdspdtpczdcGap+1,
 597                           "with V0-FMD-SPD-TPC-ZDC DG gap");
 598         axis->SetBinLabel(AliCDMesonBase::kBinfmdGap+1, "with FMD DG gap");
 599         axis->SetBinLabel(AliCDMesonBase::kBinspdGap+1, "with SPD DG gap");
 600         axis->SetBinLabel(AliCDMesonBase::kBintpcGap+1, "with TPC DG gap");
 601         axis->SetBinLabel(AliCDMesonBase::kBintpcspdGap+1, "width TPC-SPD DG gap");
 602         axis->SetBinLabel(AliCDMesonBase::kBintpcspdfmdGap+1,
 603                           "width TPC-SPD-FMD DG gap");
 604         axis->SetBinLabel(AliCDMesonBase::kBintpcspdfmdv0Gap+1,
 605                           "width TPC-SPD-FMD-V0 DG gap");
 606         axis->SetBinLabel(AliCDMesonBase::kBinspdfmdGap+1, "with SPD FMD gap");
 607         axis->SetBinLabel(AliCDMesonBase::kBinspdfmdv0Gap+1, "with SPD FMD V0 gap");
 608         axis->SetBinLabel(AliCDMesonBase::kBinTwoTrackEvents+1, "with two tracks");
 609         axis->SetBinLabel(AliCDMesonBase::kBinThreeTrackEvents+1,
 610                           "with three tracks");
 611         axis->SetBinLabel(AliCDMesonBase::kBinPionEvents+1, "with two pions");
 612         axis->SetBinLabel(AliCDMesonBase::kBinKaonEvents+1, "with two kaons");
 613         axis->SetBinLabel(AliCDMesonBase::kBinProtonEvents+1, "with two proton");
 614         axis->SetBinLabel(AliCDMesonBase::kBinElectronEvents+1, "with two electron");
 615         axis->SetBinLabel(AliCDMesonBase::kBinUnknownPIDEvents+1, "with unknown PID");
 616         axis->SetBinLabel(AliCDMesonBase::kBinResidualTracks+1,
 617                           "without residual tracks");
 618         axis->SetBinLabel(AliCDMesonBase::kBinResidualTracklets+1,
 619                           "without residual tracklets");
 620         axis->SetBinLabel(AliCDMesonBase::kBinCDonlyEvents+1, "CD only events");
 621         return hist;
 622 }
 623
 624
 625 //------------------------------------------------------------------------------
 626 TH2F* AliCDMesonBase::GetHistPIDStudies(TString name)
 627 {
 628         //
 629         // setup the PID studies histogram
 630         //
 631
 632         TH2F *hist = new TH2F(name.Data(), ";particle 1;particle 2",
 633                               AliCDMesonBase::kBinPIDUnknown,
 634                               AliCDMesonBase::kBinPionE,
 635                               AliCDMesonBase::kBinPIDUnknown+1,
 636                               AliCDMesonBase::kBinPIDUnknown,
 637                               AliCDMesonBase::kBinPionE,
 638                               AliCDMesonBase::kBinPIDUnknown+1);
 639         TAxis* x = hist->GetXaxis();
 640         TAxis* y = hist->GetYaxis();
 641         x->SetBinLabel(AliCDMesonBase::kBinPionE, "#pi (ex)");
 642         x->SetBinLabel(AliCDMesonBase::kBinPion, "#pi");
 643         x->SetBinLabel(AliCDMesonBase::kBinSinglePion, "-");
 644         x->SetBinLabel(AliCDMesonBase::kBinKaonE, "K (ex)");
 645         x->SetBinLabel(AliCDMesonBase::kBinKaon, "K");
 646         x->SetBinLabel(AliCDMesonBase::kBinSingleKaon, ",");
 647         x->SetBinLabel(AliCDMesonBase::kBinProtonE, "p (ex)");
 648         x->SetBinLabel(AliCDMesonBase::kBinProton, "p");
 649         x->SetBinLabel(AliCDMesonBase::kBinSingleProton, "_");
 650         x->SetBinLabel(AliCDMesonBase::kBinElectronE, "e (ex)");
 651         x->SetBinLabel(AliCDMesonBase::kBinElectron, "e");
 652         x->SetBinLabel(AliCDMesonBase::kBinSingleElectron, ".");
 653         x->SetBinLabel(AliCDMesonBase::kBinPIDUnknown, "X");
 654         y->SetBinLabel(AliCDMesonBase::kBinPionE, "#pi (ex)");
 655         y->SetBinLabel(AliCDMesonBase::kBinPion, "#pi");
 656         y->SetBinLabel(AliCDMesonBase::kBinSinglePion, "-");
 657         y->SetBinLabel(AliCDMesonBase::kBinKaonE, "K (ex)");
 658         y->SetBinLabel(AliCDMesonBase::kBinKaon, "K");
 659         y->SetBinLabel(AliCDMesonBase::kBinSingleKaon, ",");
 660         y->SetBinLabel(AliCDMesonBase::kBinProtonE, "p (ex)");
 661         y->SetBinLabel(AliCDMesonBase::kBinProton, "p");
 662         y->SetBinLabel(AliCDMesonBase::kBinSingleProton, "_");
 663         y->SetBinLabel(AliCDMesonBase::kBinElectronE, "e (ex)");
 664         y->SetBinLabel(AliCDMesonBase::kBinElectron, "e");
 665         y->SetBinLabel(AliCDMesonBase::kBinSingleElectron, ".");
 666         y->SetBinLabel(AliCDMesonBase::kBinPIDUnknown, "X");
 667         return hist;
 668 }
 669
 670
 671 //------------------------------------------------------------------------------
 672 TObjArray* AliCDMesonBase::GetHistVZEROStudies(TList* l)
 673 {
 674         //
 675         // Create Histograms for the VZERO trigger studies
 676         //
 677
 678         TObjArray* arr = new TObjArray(130);
 679
 680         TObject* o = 0x0;
 681         for (Int_t iPMT = 0; iPMT < 64; ++iPMT) {
 682                 o = (TObject*)new TH2F(Form("h00_%02d_ADC_TriggerThr", iPMT),
 683                                        ";ADC Counts;Trigger Threshold (ADC Counts)",
 684                                        400, 0., 4000., 48, 2., 50.);
 685                 arr->Add(o);
 686                 l->Add(o);
 687         }
 688         for (Int_t iPMT = 0; iPMT < 64; ++iPMT) {
 689                 o = (TObject*)new TH2F(Form("h01_%02d_ADC_Multiplicity", iPMT),
 690                                        ";ADC Counts;Multiplicity",
 691                                        400, 0., 4000., 250, 0., 250.);
 692                 arr->Add(o);
 693                 l->Add(o);
 694         }
 695         /*
 696           // not of use for pp data in 2010
 697         o = (TObject*)new TH2F("h02_TriggerChargeA_Trigger",
 698                                ";Trigger Charge A;Trigger Decision A",
 699                                250, 0., 5000., 2, 0., 2.);
 700         arr->Add(o);
 701         l->Add(o);
 702         o = (TObject*)new TH2F("h03__TriggerChargeC_Trigger",
 703                                ";Trigger Charge C;Trigger Decision C",
 704                                250, 0., 5000., 2, 0., 2.);
 705         arr->Add(o);
 706         l->Add(o);
 707         */
 708
 709         return arr;
 710 }
 711
 712
 713 //------------------------------------------------------------------------------
 714 void AliCDMesonBase::GetGapTriggers(THnSparseI* gaprun, Int_t gapCondition,
 715                                     Int_t run, Double_t& triggers,
 716                                     Double_t& total)
 717 {
 718         // determine the number of certain triggers with a gap in the detectors
 719         // specified by gapCondition in run and the total number of events
 720         // surviving all cuts (including pile-up rejection)
 721
 722         triggers = 0;
 723         total = 0;
 724         Int_t nTuple[] = { gaprun->GetAxis(0)->FindBin(run), 0 };
 725         for (Int_t i = 0; i< kBitGapMax; ++i) {
 726                 nTuple[1] = i;
 727                 Double_t temp = gaprun->GetBinContent(nTuple);
 728                 if (!(i & gapCondition)) {
 729                         triggers += temp;
 730                 }
 731                 total += temp;
 732         }
 733 }
 734
 735
 736 //------------------------------------------------------------------------------
 737 void AliCDMesonBase::GetNoGapTriggers(THnSparseI* gaprun, Int_t gapCondition,
 738                                       Int_t run, Double_t& triggers,
 739                                       Double_t& total)
 740 {
 741         // determine the number of certain triggers with a NO gap in the detectors
 742         // specified by the gapCondition in run and the total number of events
 743         // surviving all cuts (including pile-up rejection)
 744
 745         triggers = 0;
 746         total = 0;
 747         Int_t nTuple[] = { gaprun->GetAxis(0)->FindBin(run), 0 };
 748         for (Int_t i = 0; i< kBitGapMax; ++i) {
 749                 nTuple[1] = i;
 750                 Double_t temp = gaprun->GetBinContent(nTuple);
 751                 if (i & gapCondition) {
 752                         triggers += temp;
 753                 }
 754                 total += temp;
 755         }
 756 }