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