ANALYSIS/AliEventPoolOTF.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 /* $Id$ */
  17
  18
  19 // Realisation of an AliVEventPool via
  20 // on the flight (OTF) generation of the bin using AliTagAnalysis.
  21 // Author Andreas Morsch
  22 // andreas.morsch@cern.ch
  23
  24 #include "AliEventPoolOTF.h"
  25
  26 #include "AliRunTagCuts.h"
  27 #include "AliLHCTagCuts.h"
  28 #include "AliDetectorTagCuts.h"
  29 #include "AliEventTagCuts.h"
  30 #include "AliTagAnalysis.h"
  31
  32 #include <TMath.h>
  33 #include <TChain.h>
  34 #include <TGridResult.h>
  35
  36 ClassImp(AliEventPoolOTF)
  37
  38
  39 ////////////////////////////////////////////////////////////////////////
  40
  41 AliEventPoolOTF::AliEventPoolOTF():
  42     AliVEventPool(),
  43     fTagAnalysis(0),
  44     fRunCuts(0),
  45     fLHCCuts(0),
  46     fDetectorCuts(0),
  47     fEventCuts(0),
  48     fGridTags(0),
  49     fChain(0),
  50     fTagDirectory(0),
  51     fValueMin(),
  52     fValueMax(),
  53     fValueStep(),
  54     fValue(),
  55     fBinNumber(0),
  56     fNoMore(0)
  57
  58 {
  59   // Default constructor
  60     InitArrays();
  61 }
  62
  63 AliEventPoolOTF::AliEventPoolOTF(const char* name, const char* title):
  64     AliVEventPool(name, title),
  65     fTagAnalysis(new AliTagAnalysis(title)),
  66     fRunCuts(new AliRunTagCuts()),
  67     fLHCCuts(new AliLHCTagCuts()),
  68     fDetectorCuts(new AliDetectorTagCuts()),
  69     fEventCuts(new AliEventTagCuts()),
  70     fGridTags(0),
  71     fChain(0),
  72     fTagDirectory("."),
  73     fValueMin(),
  74     fValueMax(),
  75     fValueStep(),
  76     fValue(),
  77     fBinNumber(0),
  78     fNoMore(0)
  79
  80 {
  81   // Constructor
  82     InitArrays();
  83 }
  84
  85
  86 AliEventPoolOTF::AliEventPoolOTF(const AliEventPoolOTF& obj):
  87     AliVEventPool(obj),
  88     fTagAnalysis(0),
  89     fRunCuts(0),
  90     fLHCCuts(0),
  91     fDetectorCuts(0),
  92     fEventCuts(0),
  93     fGridTags(0),
  94     fChain(0),
  95     fTagDirectory(0),
  96     fValueMin(),
  97     fValueMax(),
  98     fValueStep(),
  99     fValue(),
 100     fBinNumber(0),
 101     fNoMore(0)
 102 {
 103     // Copy constructor
 104     InitArrays();
 105 }
 106
 107
 108 AliEventPoolOTF::~AliEventPoolOTF()
 109 {
 110     // Destructor
 111     delete fTagAnalysis;
 112     delete fRunCuts;
 113     delete fEventCuts;
 114     delete fLHCCuts;
 115     delete fDetectorCuts;
 116     delete fChain;
 117 }
 118
 119 AliEventPoolOTF& AliEventPoolOTF::operator=(const AliEventPoolOTF& other)
 120 {
 121 // Assignment operator
 122     AliVEventPool::operator=(other);
 123     return *this;
 124 }
 125
 126
 127 void AliEventPoolOTF::Init()
 128 {
 129     //
 130     if (!fGridTags) {
 131         fTagAnalysis->ChainLocalTags(fTagDirectory);
 132     } else {
 133         fTagAnalysis->ChainGridTags(fGridTags);
 134     }
 135
 136
 137     for (Int_t i = 0; i < 5; i++) fValue[i] = fValueMin[i];
 138 }
 139
 140 TChain* AliEventPoolOTF::GetNextChain()
 141 {
 142     //
 143     if (fChain) {
 144         delete fChain;
 145         fChain = 0;
 146     }
 147
 148     fBinNumber++;
 149     if (fNoMore) {
 150         return 0;
 151     } else {
 152     printf("Current bin (lower) %13.3f %13.3f %13.3f %13.3f %13.3f \n", fValue[kMultiplicity], fValue[kZVertex], fValue[kEventPlane],fValue[kLeadingParticleEta],fValue[kLeadingParticlePhi]);
 153     printf("Current bin (upper) %13.3f %13.3f %13.3f %13.3f %13.3f \n", fValue[kMultiplicity] + fValueStep[kMultiplicity] - 1,
 154            fValue[kZVertex]      + fValueStep[kZVertex],
 155            fValue[kEventPlane]   + fValueStep[kEventPlane],
 156            fValue[kLeadingParticleEta]   + fValueStep[kLeadingParticleEta],
 157            fValue[kLeadingParticlePhi]   + fValueStep[kLeadingParticlePhi]
 158
 159            );
 160
 161         fEventCuts->SetMultiplicityRange(Int_t(fValue[kMultiplicity]) , Int_t(fValue[kMultiplicity] + fValueStep[kMultiplicity] - 1));
 162         fEventCuts->SetPrimaryVertexZRange(fValue[kZVertex] , fValue[kZVertex] + fValueStep[kZVertex]);
 163         fEventCuts->SetEtaLeadingParticleRange(fValue[kLeadingParticleEta] , fValue[kLeadingParticleEta] + fValueStep[kLeadingParticleEta]);
 164         fEventCuts->SetPhiLeadingParticleRange(fValue[kLeadingParticlePhi] , fValue[kLeadingParticlePhi] + fValueStep[kLeadingParticlePhi]);
 165         fEventCuts->SetEventPlaneAngleRange(fValue[kEventPlane] , fValue[kEventPlane] + fValueStep[kEventPlane]);
 166
 167         fChain = fTagAnalysis->QueryTags(fRunCuts, fLHCCuts, fDetectorCuts, fEventCuts);
 168 //
 169 //      Next bin
 170 //
 171         for (Int_t i = 5; i >= 0; i--)
 172         {
 173             fValue[i] += fValueStep[i];
 174             if (i > 0  && fValue[i] >= fValueMax[i]) {
 175                 fValue[i] = fValueMin[i];
 176             } else if (i == 0 && fValue[i] >= fValueMax[i]) {
 177                 fNoMore = kTRUE;
 178             } else {
 179                 break;
 180             }
 181         }
 182         return fChain;
 183     }
 184 }
 185
 186 void  AliEventPoolOTF::GetCurrentBin(Float_t* /*bin*/)
 187 {
 188     //
 189 }
 190
 191 Int_t AliEventPoolOTF::GetDimension()
 192 {
 193     //
 194     return (5);
 195 }
 196
 197 void AliEventPoolOTF::InitArrays()
 198 {
 199     // Initializes the pool axis
 200
 201     SetMultiplicityBinning(0, 20000, 20000);
 202     SetZVertexBinning(-1000., 1000., 2000.);
 203     SetEventPlaneBinning(-1000., 1000., 2000.);
 204     SetLeadingParticleEtaBinning(-13.0, 13.0, 27.);
 205     SetLeadingParticlePhiBinning(0., 2*(TMath::Pi()),2*(TMath::Pi()));
 206     for (Int_t i = 0; i < 5; i++) fValue[i] = fValueMin[i];
 207 }
 208
 209