STEER/AliESDCaloTrigger.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 /*
  17
  18
  19
  20
  21 Author: R. GUERNANE LPSC Grenoble CNRS/IN2P3
  22 */
  23
  24 #include "AliESDCaloTrigger.h"
  25 #include "AliLog.h"
  26
  27 #include "TArrayI.h"
  28 #include "Riostream.h"
  29 #include <cstdlib>
  30
  31 ClassImp(AliESDCaloTrigger)
  32
  33 //_______________
  34 AliESDCaloTrigger::AliESDCaloTrigger() : TNamed(),
  35 fNEntries(0),
  36 fCurrent(-1),
  37 fColumn(0x0),
  38 fRow(0x0),
  39 fAmplitude(0x0),
  40 fTime(0x0),
  41 fNL0Times(0x0),
  42 fL0Times(new TArrayI()),
  43 fL1TimeSum(0x0)
  44 {
  45         //
  46         for (Int_t i = 0; i < 48; i++) for (Int_t j = 0; j < 64; j++) fTriggerBits[i][j] = 0;
  47 }
  48
  49 //_______________
  50 AliESDCaloTrigger::AliESDCaloTrigger(const AliESDCaloTrigger& src) : TNamed(src),
  51 fNEntries(0),
  52 fCurrent(-1),
  53 fColumn(0x0),
  54 fRow(0x0),
  55 fAmplitude(0x0),
  56 fTime(0x0),
  57 fNL0Times(0x0),
  58 fL0Times(new TArrayI()),
  59 fL1TimeSum(0x0)
  60 {
  61         //
  62         src.Copy(*this);
  63 }
  64
  65 //_______________
  66 AliESDCaloTrigger::~AliESDCaloTrigger()
  67 {
  68         //
  69         if (fNEntries) DeAllocate();
  70
  71         delete fL0Times; fL0Times = 0x0;
  72 }
  73
  74 //_______________
  75 void AliESDCaloTrigger::DeAllocate()
  76 {
  77         //
  78         delete [] fColumn;    fColumn    = 0x0;
  79         delete [] fRow;       fRow       = 0x0;
  80         delete [] fAmplitude; fAmplitude = 0x0;
  81         delete [] fTime;      fTime      = 0x0;
  82         delete [] fNL0Times;  fNL0Times  = 0x0;
  83         delete [] fL1TimeSum; fL1TimeSum = 0x0;
  84 //      delete [] fL0Times;   fL0Times   = 0x0;
  85
  86         fNEntries =  0;
  87         fCurrent  = -1;
  88
  89         for (Int_t i = 0; i < 48; i++) for (Int_t j = 0; j < 64; j++) fTriggerBits[i][j] = 0;
  90
  91         fL0Times->Reset();
  92 }
  93
  94 //_______________
  95 AliESDCaloTrigger& AliESDCaloTrigger::operator=(const AliESDCaloTrigger& src)
  96 {
  97         //
  98         if (this != &src) src.Copy(*this);
  99
 100         return *this;
 101 }
 102
 103 //_______________
 104 void AliESDCaloTrigger::Copy(TObject &obj) const
 105 {
 106         //
 107         TNamed::Copy(obj);
 108
 109         AliESDCaloTrigger& dest = static_cast<AliESDCaloTrigger&>(obj);
 110
 111         if (dest.fNEntries) dest.DeAllocate();
 112
 113         dest.Allocate(fNEntries);
 114
 115         for (Int_t i = 0; i < fNEntries; i++)
 116         {
 117                 Int_t times[10];
 118                 for (Int_t j = 0; j < 10; j++) times[j] = fL0Times->At(10 * i + j);
 119
 120                 dest.Add(fColumn[i], fRow[i], fAmplitude[i], fTime[i], times, fNL0Times[i], fL1TimeSum[i]);
 121         }
 122
 123         for (Int_t i = 0; i < 48; i++) for (Int_t j = 0; j < 64; j++) dest.fTriggerBits[i][j] = fTriggerBits[i][j];
 124 }
 125
 126 //_______________
 127 void AliESDCaloTrigger::Allocate(Int_t size)
 128 {
 129         //
 130         if (!size) return;
 131
 132         fNEntries = size;
 133
 134         fColumn      = new   Int_t[fNEntries];
 135         fRow         = new   Int_t[fNEntries];
 136         fAmplitude   = new Float_t[fNEntries];
 137         fTime        = new Float_t[fNEntries];
 138         fNL0Times    = new   Int_t[fNEntries];
 139 //      fL0Times     = new   Int_t[fNEntries * 10];
 140         fL1TimeSum   = new   Int_t[fNEntries];
 141
 142         for (Int_t i = 0; i < fNEntries; i++)
 143         {
 144           fColumn[i]    = 0;
 145           fRow[i]       = 0;
 146           fAmplitude[i] = 0;
 147           fTime[i]      = 0;
 148           fNL0Times[i]  = 0;
 149           fL1TimeSum[i] = 0;
 150         }
 151
 152         fL0Times->Set(fNEntries * 10);
 153 }
 154
 155 //_______________
 156 Bool_t AliESDCaloTrigger::Add(Int_t col, Int_t row, Float_t amp, Float_t time, Int_t trgtimes[], Int_t ntrgtimes, Int_t trgts)
 157 {
 158         //
 159         fCurrent++;
 160
 161            fColumn[fCurrent] = col;
 162               fRow[fCurrent] = row;
 163         fAmplitude[fCurrent] = amp;
 164              fTime[fCurrent] = time;
 165          fNL0Times[fCurrent] = ntrgtimes;
 166         fL1TimeSum[fCurrent] = trgts;
 167
 168         if (ntrgtimes > 9)
 169         {
 170                 AliError("Should not have more than 10 L0 times");
 171                 return kFALSE;
 172         }
 173
 174         for (Int_t i = 0; i < fNL0Times[fCurrent]; i++) fL0Times->AddAt(trgtimes[i], 10 * fCurrent + i);
 175
 176         return kTRUE;
 177 }
 178
 179 //_______________
 180 void AliESDCaloTrigger::SetTriggerBits(Int_t col, Int_t row, Int_t i, Int_t j)
 181 {
 182         //
 183         if (col < 0 || col > 47 || row < 0 || row > 63)
 184         {
 185                 AliError("Bad position!");
 186                 return;
 187         }
 188
 189         fTriggerBits[col][row] = (fTriggerBits[col][row] | (1 << (i + 3 * j))); // L0 L1g L1j
 190 }
 191
 192 //_______________
 193 Bool_t AliESDCaloTrigger::Next()
 194 {
 195         //
 196         if (fCurrent >= fNEntries - 1 || !fNEntries) return kFALSE;
 197
 198         fCurrent++;
 199
 200         return kTRUE;
 201 }
 202
 203 //_______________
 204 void AliESDCaloTrigger::GetPosition(Int_t& col, Int_t& row) const
 205 {
 206         //
 207         if (fCurrent == -1) return;
 208
 209         col = fColumn[fCurrent];
 210         row =    fRow[fCurrent];
 211 }
 212
 213 //_______________
 214 void AliESDCaloTrigger::GetAmplitude(Float_t& amp) const
 215 {
 216         //
 217         if (fCurrent == -1) return;
 218
 219         amp = fAmplitude[fCurrent];
 220 }
 221
 222 //_______________
 223 void AliESDCaloTrigger::GetTime(Float_t& time) const
 224 {
 225         //
 226         if (fCurrent == -1) return;
 227
 228         time = fTime[fCurrent];
 229 }
 230
 231 //_______________
 232 void AliESDCaloTrigger::GetL1TimeSum(Int_t& amp) const
 233 {
 234         //
 235         if (fCurrent == -1) return;
 236
 237         amp = fL1TimeSum[fCurrent];
 238 }
 239
 240 //_______________
 241 void AliESDCaloTrigger::GetNL0Times(Int_t& ntimes) const
 242 {
 243         //
 244         if (fCurrent == -1) return;
 245
 246         ntimes = fNL0Times[fCurrent];
 247 }
 248
 249 //_______________
 250 void AliESDCaloTrigger::GetTriggerBits(Char_t& bits) const
 251 {
 252         //
 253         if (fCurrent == -1) return;
 254
 255         bits = fTriggerBits[fColumn[fCurrent]][fRow[fCurrent]];
 256 }
 257
 258 //_______________
 259 void AliESDCaloTrigger::GetL0Times(Int_t times[]) const
 260 {
 261         //
 262         if (fCurrent == -1) return;
 263
 264         for (Int_t i = 0; i < fNL0Times[fCurrent]; i++) times[i] = fL0Times->At(10 * fCurrent + i);
 265 }
 266
 267 //_______________
 268 void AliESDCaloTrigger::Print(const Option_t* /*opt*/) const
 269 {
 270         //
 271         if (fCurrent == -1) return;
 272
 273         printf("============\n");
 274         printf("--L0:\n");
 275         printf("\tPOSITION (X: %2d Y: %2d) / FITTED F-ALTRO (AMP: %4f TIME: %3f)\n",
 276                    fColumn[fCurrent], fRow[fCurrent], fAmplitude[fCurrent], fTime[fCurrent]);
 277         printf("\t%d L0 TIMES (", fNL0Times[fCurrent]);
 278         for (Int_t i = 0; i < fNL0Times[fCurrent]; i++) printf("%2d ",fL0Times->At(10 * fCurrent + i));
 279         printf(")\n");
 280         printf("--L1:\n");
 281         printf("\tTIME SUM: %4d\n", fL1TimeSum[fCurrent]);
 282         printf("\tTHRESHOLDS (GAMMA: %4d, JET: %4d)\n", fL1Threshold[0], fL1Threshold[1]);
 283         printf("--TRIGGER BITS: 0x%x\n", fTriggerBits[fColumn[fCurrent]][fRow[fCurrent]]);
 284 }