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 <TGridResult.h>
  34
  35 ClassImp(AliEventPoolOTF)
  36
  37
  38 ////////////////////////////////////////////////////////////////////////
  39
  40 AliEventPoolOTF::AliEventPoolOTF():
  41     AliVEventPool(),
  42     fTagAnalysis(0),
  43     fRunCuts(0),
  44     fLHCCuts(0),
  45     fDetectorCuts(0),
  46     fEventCuts(0),
  47     fGridTags(0),
  48     fTagDirectory(0),
  49     fValueMin(),
  50     fValueMax(),
  51     fValueStep(),
  52     fValue(),
  53     fBinNumber(0),
  54     fNoMore(0)
  55
  56 {
  57   // Default constructor
  58     InitArrays();
  59 }
  60
  61 AliEventPoolOTF::AliEventPoolOTF(const char* name, const char* title):
  62     AliVEventPool(name, title),
  63     fTagAnalysis(new AliTagAnalysis(title)),
  64     fRunCuts(new AliRunTagCuts()),
  65     fLHCCuts(new AliLHCTagCuts()),
  66     fDetectorCuts(new AliDetectorTagCuts()),
  67     fEventCuts(new AliEventTagCuts()),
  68     fGridTags(0),
  69     fTagDirectory("."),
  70     fValueMin(),
  71     fValueMax(),
  72     fValueStep(),
  73     fValue(),
  74     fBinNumber(0),
  75     fNoMore(0)
  76
  77 {
  78   // Constructor
  79     InitArrays();
  80 }
  81
  82
  83 AliEventPoolOTF::AliEventPoolOTF(const AliEventPoolOTF& obj):
  84     AliVEventPool(obj),
  85     fTagAnalysis(0),
  86     fRunCuts(0),
  87     fLHCCuts(0),
  88     fDetectorCuts(0),
  89     fEventCuts(0),
  90     fTagDirectory(0),
  91     fValueMin(),
  92     fValueMax(),
  93     fValueStep(),
  94     fValue(),
  95     fBinNumber(0),
  96     fNoMore(0)
  97 {
  98     // Copy constructor
  99     InitArrays();
 100 }
 101
 102 AliEventPoolOTF& AliEventPoolOTF::operator=(const AliEventPoolOTF& other)
 103 {
 104 // Assignment operator
 105     AliVEventPool::operator=(other);
 106     return *this;
 107 }
 108
 109
 110 void AliEventPoolOTF::Init()
 111 {
 112     //
 113     if (!fGridTags) {
 114         fTagAnalysis->ChainLocalTags(fTagDirectory);
 115     } else {
 116         fTagAnalysis->ChainGridTags(fGridTags);
 117     }
 118
 119
 120     for (Int_t i = 0; i < 4; i++) fValue[i] = fValueMin[i];
 121 }
 122
 123 TChain* AliEventPoolOTF::GetNextChain()
 124 {
 125     //
 126     TChain* chain = 0;
 127     fBinNumber++;
 128     if (fNoMore) {
 129         return 0;
 130     } else {
 131         printf("Current bin (lower) %13.3f %13.3f %13.3f \n", fValue[kMultiplicity], fValue[kZVertex], fValue[kEventPlane]);
 132         printf("Current bin (upper) %13.3f %13.3f %13.3f \n", fValue[kMultiplicity] + fValueStep[kMultiplicity],
 133                                                               fValue[kZVertex]      + fValueStep[kZVertex],
 134                                                               fValue[kEventPlane]   + fValueStep[kEventPlane]);
 135
 136         fEventCuts->SetMultiplicityRange(Int_t(fValue[kMultiplicity]) , Int_t(fValue[kMultiplicity] + fValueStep[kMultiplicity]));
 137         fEventCuts->SetPrimaryVertexZRange(fValue[kZVertex] , fValue[kZVertex] + fValueStep[kZVertex]);
 138         fEventCuts->SetEventPlaneAngleRange(fValue[kEventPlane] , fValue[kEventPlane] + fValueStep[kEventPlane]);
 139         chain = fTagAnalysis->QueryTags(fRunCuts, fLHCCuts, fDetectorCuts, fEventCuts);
 140 //
 141 //      Next bin
 142 //
 143         for (Int_t i = 2; i >= 0; i--)
 144         {
 145             fValue[i] += fValueStep[i];
 146             if (i > 0  && fValue[i] >= fValueMax[i]) {
 147                 fValue[i] = fValueMin[i];
 148             } else if (i == 0 && fValue[i] >= fValueMax[i]) {
 149                 fNoMore = kTRUE;
 150             } else {
 151                 break;
 152             }
 153         }
 154         return chain;
 155     }
 156 }
 157
 158 void  AliEventPoolOTF::GetCurrentBin(Float_t* /*bin*/)
 159 {
 160     //
 161 }
 162
 163 Int_t AliEventPoolOTF::GetDimension()
 164 {
 165     //
 166     return (3);
 167 }
 168
 169 void AliEventPoolOTF::InitArrays()
 170 {
 171     // Initializes the pool axis
 172
 173     SetMultiplicityBinning(0, 20000, 20000);
 174     SetZVertexBinning(-1000., 1000., 2000.);
 175     SetEventPlaneBinning(-1000., 1000., 2000.);
 176     SetLeadingParticleEtaBinning(-1.0, 1.0, 2.);
 177     for (Int_t i = 0; i < 4; i++) fValue[i] = fValueMin[i];
 178 }
 179
 180