AliPhysics  75b74d3 (75b74d3)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
AliEmcalTriggerMakerKernel.cxx
Go to the documentation of this file.
1 /**************************************************************************
2  * Copyright(c) 1998-2015, 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 #include <iostream>
16 #include <vector>
17 #include <cstring>
18 #include <fstream>
19 
20 #include <TArrayI.h>
21 #include <TObjArray.h>
22 
23 #include "AliAODCaloTrigger.h"
24 #include "AliEMCALGeometry.h"
25 #include "AliEMCALTriggerConstants.h"
26 #include "AliEMCALTriggerDataGrid.h"
27 #include "AliEMCALTriggerPatchInfo.h"
28 #include "AliEMCALTriggerPatchFinder.h"
29 #include "AliEMCALTriggerAlgorithm.h"
30 #include "AliEMCALTriggerRawPatch.h"
33 #include "AliLog.h"
34 #include "AliVCaloCells.h"
35 #include "AliVCaloTrigger.h"
36 #include "AliVEvent.h"
37 #include "AliVVZERO.h"
38 
42 
44  TObject(),
45  fBadChannels(),
46  fOfflineBadChannels(),
47  fFastORPedestal(5000),
48  fTriggerBitConfig(NULL),
49  fGeometry(NULL),
50  fPatchAmplitudes(NULL),
51  fPatchADCSimple(NULL),
52  fPatchADC(NULL),
53  fLevel0TimeMap(NULL),
54  fTriggerBitMap(NULL),
55  fPatchFinder(NULL),
56  fLevel0PatchFinder(NULL),
57  fL0MinTime(7),
58  fL0MaxTime(10),
59  fADCtoGeV(1.),
60  fMinCellAmp(0),
61  fMinL0FastORAmp(0),
62  fMinL1FastORAmp(0),
63  fJetPatchsize(16),
64  fBkgThreshold(-1),
65  fL0Threshold(0),
66  fIsMC(kFALSE),
67  fDebugLevel(0)
68 {
69  memset(fThresholdConstants, 0, sizeof(Int_t) * 12);
70  memset(fL1ThresholdsOffline, 0, sizeof(ULong64_t) * 4);
71 }
72 
74  delete fPatchAmplitudes;
75  delete fPatchADCSimple;
76  delete fPatchADC;
77  delete fLevel0TimeMap;
78  delete fTriggerBitMap;
79  delete fPatchFinder;
80  delete fLevel0PatchFinder;
82 }
83 
90 
91  // Allocate containers for the ADC values
92  int nrows = fGeometry->GetNTotalTRU() * 2;
93  std::cout << "Allocating channel grid with 48 columns in eta and " << nrows << " rows in phi" << std::endl;
94  std::cout << "Using jet patch size " << fJetPatchsize << std::endl;
95  fPatchAmplitudes->Allocate(48, nrows);
96  fPatchADC->Allocate(48, nrows);
97  fPatchADCSimple->Allocate(48, nrows);
98  fLevel0TimeMap->Allocate(48, nrows);
99  fTriggerBitMap->Allocate(48, nrows);
100 
101  // Initialize patch finder
103  fPatchFinder->AddTriggerAlgorithm(CreateGammaTriggerAlgorithm(0, 63));
105  fPatchFinder->AddTriggerAlgorithm(jettrigger);
106  if(fJetPatchsize == 8){
107  //jettrigger->SetBitMask(jettrigger->GetBitMask() | 1 << fTriggerBitConfig->GetBkgBit());
108  jettrigger->SetBitMask(1 << fTriggerBitConfig->GetJetHighBit() | 1 << fTriggerBitConfig->GetJetLowBit() | 1 << fTriggerBitConfig->GetBkgBit());
109  } else {
110  fPatchFinder->AddTriggerAlgorithm(CreateBkgTriggerAlgorithm(0, 63));
111  }
112  if(nrows > 64){
113  // Add trigger algorithms for DCAL
114  fPatchFinder->AddTriggerAlgorithm(CreateGammaTriggerAlgorithm(64, nrows));
115  jettrigger = CreateJetTriggerAlgorithm(64, nrows);
116  fPatchFinder->AddTriggerAlgorithm(jettrigger);
117  if(fJetPatchsize == 8) {
118  //jettrigger->SetBitMask(jettrigger->GetBitMask() | 1 << fTriggerBitConfig->GetBkgBit());
119  jettrigger->SetBitMask(1 << fTriggerBitConfig->GetJetHighBit() | 1 << fTriggerBitConfig->GetJetLowBit() | 1 << fTriggerBitConfig->GetBkgBit());
120  } else {
121  fPatchFinder->AddTriggerAlgorithm(CreateBkgTriggerAlgorithm(64, nrows));
122  }
123  }
124 
126  fLevel0PatchFinder->SetPatchSize(2);
127  fLevel0PatchFinder->SetSubregionSize(2);
128 }
129 
131 {
132  Short_t absId = 0;
133 
134  while (stream.good()) {
135  stream >> absId;
136  AddOfflineBadChannel(absId);
137  }
138 }
139 
141 {
142  std::ifstream file(fname);
144 }
145 
147 {
148  Short_t absId = -1;
149 
150  while (stream.good()) {
151  stream >> absId;
152  AddFastORBadChannel(absId);
153  }
154 }
155 
157 {
158  std::ifstream file(fname);
160 }
161 
162 void AliEmcalTriggerMakerKernel::SetFastORPedestal(Short_t absId, Float_t ped)
163 {
164  if (absId < 0 || absId >= fFastORPedestal.GetSize()) {
165  AliWarning(Form("Abs. ID %d out of range (0,5000)", absId));
166  return;
167  }
168  fFastORPedestal[absId] = ped;
169 }
170 
172 {
173  Short_t absId = 0;
174  Float_t ped = 0;
175  while (stream.good()) {
176  stream >> ped;
177  SetFastORPedestal(absId, ped);
178  absId++;
179  }
180 }
181 
183 {
184  std::ifstream file(fname);
186 }
187 
189  fPatchAmplitudes->Reset();
190  fPatchADC->Reset();
191  fPatchADCSimple->Reset();
192  fLevel0TimeMap->Reset();
193  fTriggerBitMap->Reset();
194  memset(fL1ThresholdsOffline, 0, sizeof(ULong64_t) * 4);
195 }
196 
197 void AliEmcalTriggerMakerKernel::ReadTriggerData(AliVCaloTrigger *trigger){
198  trigger->Reset();
199  Int_t globCol=-1, globRow=-1;
200  Int_t adcAmp=-1, bitmap = 0;
201  while(trigger->Next()){
202  // get position in global 2x2 tower coordinates
203  // A0 left bottom (0,0)
204  trigger->GetPosition(globCol, globRow);
205  Int_t absId = -1;
206  fGeometry->GetAbsFastORIndexFromPositionInEMCAL(globCol, globRow, absId);
207  // exclude channel completely if it is masked as hot channel
208  if (fBadChannels.find(absId) != fBadChannels.end()) continue;
209  // for some strange reason some ADC amps are initialized in reconstruction
210  // as -1, neglect those
211  trigger->GetL1TimeSum(adcAmp);
212  if (adcAmp < 0) adcAmp = 0;
213 
214  if (adcAmp >= fMinL1FastORAmp) {
215  (*fPatchADC)(globCol,globRow) = adcAmp;
216  trigger->GetTriggerBits(bitmap);
217  (*fTriggerBitMap)(globCol, globRow) = bitmap;
218  }
219 
220  // Handling for L0 triggers
221  // For the ADC value we use fCaloTriggers->GetAmplitude()
222  // In data, all patches which have 4 TRUs with proper level0 times are
223  // valid trigger patches. Therefore we need to check all neighbors for
224  // the level0 times, not only the bottom left. In order to obtain this
225  // information, a lookup table with the L0 times for each TRU is created
226  Float_t amplitude(0);
227  trigger->GetAmplitude(amplitude);
228  amplitude *= 4; // values are shifted by 2 bits to fit in a 10 bit word (on the hardware side)
229  amplitude -= fFastORPedestal[absId];
230  if(amplitude < 0) amplitude = 0;
231  if (amplitude >= fMinL0FastORAmp) {
232  (*fPatchAmplitudes)(globCol,globRow) = amplitude;
233  Int_t nl0times(0);
234  trigger->GetNL0Times(nl0times);
235  if(nl0times){
236  TArrayI l0times(nl0times);
237  trigger->GetL0Times(l0times.GetArray());
238  for(int itime = 0; itime < nl0times; itime++){
239  (*fLevel0TimeMap)(globCol,globRow) = static_cast<Char_t>(l0times[itime]);
240  break;
241  }
242  }
243  }
244  }
245 }
246 
247 void AliEmcalTriggerMakerKernel::ReadCellData(AliVCaloCells *cells){
248  // fill the patch ADCs from cells
249  Int_t nCell = cells->GetNumberOfCells();
250  for(Int_t iCell = 0; iCell < nCell; ++iCell) {
251  // get the cell info, based in index in array
252  Short_t cellId = cells->GetCellNumber(iCell);
253 
254  // Check bad channel map
255  if (fOfflineBadChannels.find(cellId) != fOfflineBadChannels.end()) {
256  AliDebug(10, Form("%hd is a bad channel, skipped.", cellId));
257  continue;
258  }
259 
260  Double_t amp = cells->GetAmplitude(iCell);
261  // get position
262  Int_t absId=-1;
263  fGeometry->GetFastORIndexFromCellIndex(cellId, absId);
264  Int_t globCol=-1, globRow=-1;
265  fGeometry->GetPositionInEMCALFromAbsFastORIndex(absId, globCol, globRow);
266  // add
267  amp /= fADCtoGeV;
268  if (amp >= fMinCellAmp) (*fPatchADCSimple)(globCol,globRow) += amp;
269  }
270 }
271 
273  // get the V0 value and compute and set the offline thresholds
274  // get V0, compute thresholds and save them as global parameters
275  ULong64_t v0S = vzerodata->GetTriggerChargeA() + vzerodata->GetTriggerChargeC();
276  for (Int_t i = 0; i < 4; ++i) {
277  // A*V0^2/2^32+B*V0/2^16+C
278  fL1ThresholdsOffline[i]= ( ((ULong64_t)fThresholdConstants[i][0]) * v0S * v0S ) >> 32;
279  fL1ThresholdsOffline[i] += ( ((ULong64_t)fThresholdConstants[i][1]) * v0S ) >> 16;
280  fL1ThresholdsOffline[i] += ((ULong64_t)fThresholdConstants[i][2]);
281  }
282 }
283 
284 TObjArray *AliEmcalTriggerMakerKernel::CreateTriggerPatches(const AliVEvent *inputevent, Bool_t useL0amp){
285  //std::cout << "Finding trigger patches" << std::endl;
286  //AliEMCALTriggerPatchInfo *trigger, *triggerMainJet, *triggerMainGamma, *triggerMainLevel0;
287  //AliEMCALTriggerPatchInfo *triggerMainJetSimple, *triggerMainGammaSimple;
288 
289  if (useL0amp) {
291  }
292  else {
293  fADCtoGeV = EMCALTrigger::kEMCL1ADCtoGeV;
294  }
295 
296  Double_t vertexpos[3];
297  inputevent->GetPrimaryVertex()->GetXYZ(vertexpos);
298  TVector3 vertexvec(vertexpos);
299 
300  Int_t isMC = fIsMC ? 1 : 0;
301  Int_t offset = (1 - isMC) * fTriggerBitConfig->GetTriggerTypesEnd();
302 
303  // Create trigger bit masks. They are needed later to remove
304  // trigger bits from the trigger bit mask for non-matching patch types
305  Int_t jetPatchMask = 1 << fTriggerBitConfig->GetJetHighBit()
306  | 1 << fTriggerBitConfig->GetJetLowBit()
307  | 1 << (fTriggerBitConfig->GetJetHighBit() + fTriggerBitConfig->GetTriggerTypesEnd())
308  | 1 << (fTriggerBitConfig->GetJetLowBit() + fTriggerBitConfig->GetTriggerTypesEnd()),
309  gammaPatchMask = 1 << fTriggerBitConfig->GetGammaHighBit()
310  | 1 << fTriggerBitConfig->GetGammaLowBit()
311  | 1 << (fTriggerBitConfig->GetGammaHighBit() + fTriggerBitConfig->GetTriggerTypesEnd())
312  | 1 << (fTriggerBitConfig->GetGammaLowBit() + fTriggerBitConfig->GetTriggerTypesEnd()),
313  bkgPatchMask = 1 << fTriggerBitConfig->GetBkgBit(),
314  l0PatchMask = 1 << fTriggerBitConfig->GetLevel0Bit();
315 
316  std::vector<AliEMCALTriggerRawPatch> patches;
317  if (useL0amp) {
318  patches = fPatchFinder->FindPatches(*fPatchAmplitudes, *fPatchADCSimple);
319  }
320  else {
321  patches = fPatchFinder->FindPatches(*fPatchADC, *fPatchADCSimple);
322  }
323  TObjArray *result = new TObjArray(1000);
324  result->SetOwner(kTRUE);
325  for(std::vector<AliEMCALTriggerRawPatch>::iterator patchit = patches.begin(); patchit != patches.end(); ++patchit){
326  // Apply offline and recalc selection
327  // Remove unwanted bits from the online bits (gamma bits from jet patches and vice versa)
328  Int_t offlinebits = 0, onlinebits = (*fTriggerBitMap)(patchit->GetColStart(), patchit->GetRowStart());
329  if(IsGammaPatch(*patchit)){
330  if(patchit->GetADC() > fL1ThresholdsOffline[1]) SETBIT(offlinebits, AliEMCALTriggerPatchInfo::kRecalcOffset + fTriggerBitConfig->GetGammaHighBit());
331  if(patchit->GetOfflineADC() > fL1ThresholdsOffline[1]) SETBIT(offlinebits, AliEMCALTriggerPatchInfo::kOfflineOffset + fTriggerBitConfig->GetGammaHighBit());
332  if(patchit->GetADC() > fL1ThresholdsOffline[3]) SETBIT(offlinebits, AliEMCALTriggerPatchInfo::kRecalcOffset + fTriggerBitConfig->GetGammaLowBit());
333  if(patchit->GetOfflineADC() > fL1ThresholdsOffline[3]) SETBIT(offlinebits, AliEMCALTriggerPatchInfo::kOfflineOffset + fTriggerBitConfig->GetGammaLowBit());
334  onlinebits &= gammaPatchMask;
335  }
336  if (IsJetPatch(*patchit)){
337  if(patchit->GetADC() > fL1ThresholdsOffline[0]) SETBIT(offlinebits, AliEMCALTriggerPatchInfo::kRecalcOffset + fTriggerBitConfig->GetJetHighBit());
338  if(patchit->GetOfflineADC() > fL1ThresholdsOffline[0]) SETBIT(offlinebits, AliEMCALTriggerPatchInfo::kOfflineOffset + fTriggerBitConfig->GetJetHighBit());
339  if(patchit->GetADC() > fL1ThresholdsOffline[2]) SETBIT(offlinebits, AliEMCALTriggerPatchInfo::kRecalcOffset + fTriggerBitConfig->GetJetLowBit());
340  if(patchit->GetOfflineADC() > fL1ThresholdsOffline[2]) SETBIT(offlinebits, AliEMCALTriggerPatchInfo::kOfflineOffset + fTriggerBitConfig->GetJetLowBit());
341  onlinebits &= jetPatchMask;
342  }
343  if (IsBkgPatch(*patchit)){
344  if(patchit->GetADC() > fBkgThreshold) SETBIT(offlinebits, AliEMCALTriggerPatchInfo::kRecalcOffset + fTriggerBitConfig->GetBkgBit());
345  if(patchit->GetOfflineADC() > fBkgThreshold) SETBIT(offlinebits, AliEMCALTriggerPatchInfo::kOfflineOffset + fTriggerBitConfig->GetBkgBit());
346  onlinebits &= bkgPatchMask;
347  }
348  // convert
349  AliEMCALTriggerPatchInfo *fullpatch = AliEMCALTriggerPatchInfo::CreateAndInitialize(patchit->GetColStart(), patchit->GetRowStart(),
350  patchit->GetPatchSize(), patchit->GetADC(), patchit->GetOfflineADC(), patchit->GetOfflineADC() * fADCtoGeV,
351  onlinebits | offlinebits, vertexvec, fGeometry);
352  fullpatch->SetTriggerBitConfig(fTriggerBitConfig);
353  fullpatch->SetOffSet(offset);
354  result->Add(fullpatch);
355  }
356 
357  // Find Level0 patches
358  std::vector<AliEMCALTriggerRawPatch> l0patches = fLevel0PatchFinder->FindPatches(*fPatchAmplitudes, *fPatchADCSimple);
359  for(std::vector<AliEMCALTriggerRawPatch>::iterator patchit = l0patches.begin(); patchit != l0patches.end(); ++patchit){
360  Int_t offlinebits = 0, onlinebits = 0;
361  ELevel0TriggerStatus_t L0status = CheckForL0(patchit->GetColStart(), patchit->GetRowStart());
362  if (L0status == kNotLevel0) continue;
363  if (L0status == kLevel0Fired) SETBIT(onlinebits, fTriggerBitConfig->GetLevel0Bit());
364  if (patchit->GetADC() > fL0Threshold) SETBIT(offlinebits, AliEMCALTriggerPatchInfo::kRecalcOffset + fTriggerBitConfig->GetLevel0Bit());
365  if (patchit->GetOfflineADC() > fL0Threshold) SETBIT(offlinebits, AliEMCALTriggerPatchInfo::kOfflineOffset + fTriggerBitConfig->GetLevel0Bit());
366 
367  AliEMCALTriggerPatchInfo *fullpatch = AliEMCALTriggerPatchInfo::CreateAndInitialize(patchit->GetColStart(), patchit->GetRowStart(),
368  patchit->GetPatchSize(), patchit->GetADC(), patchit->GetOfflineADC(), patchit->GetOfflineADC() * fADCtoGeV,
369  onlinebits | offlinebits, vertexvec, fGeometry);
370  fullpatch->SetTriggerBitConfig(fTriggerBitConfig);
371  result->Add(fullpatch);
372  }
373  // std::cout << "Finished finding trigger patches" << std::endl;
374  return result;
375 }
376 
379 
380  if(col < 0 || row < 0){
381  AliError(Form("Patch outside range [col %d, row %d]", col, row));
382  return kNotLevel0;
383  }
384  Int_t truref(-1), trumod(-1), absFastor(-1), adc(-1);
385  fGeometry->GetAbsFastORIndexFromPositionInEMCAL(col, row, absFastor);
386  fGeometry->GetTRUFromAbsFastORIndex(absFastor, truref, adc);
387  int nvalid(0);
388  const int kNRowsPhi = fGeometry->GetNTotalTRU() * 2;
389  for(int ipos = 0; ipos < 2; ipos++){
390  if(row + ipos >= kNRowsPhi) continue; // boundary check
391  for(int jpos = 0; jpos < 2; jpos++){
392  if(col + jpos >= kColsEta) continue; // boundary check
393  // Check whether we are in the same TRU
394  trumod = -1;
395  fGeometry->GetAbsFastORIndexFromPositionInEMCAL(col+jpos, row+ipos, absFastor);
396  fGeometry->GetTRUFromAbsFastORIndex(absFastor, trumod, adc);
397  if(trumod != truref) {
398  result = kNotLevel0;
399  return result;
400  }
401  if(col + jpos >= kColsEta) AliError(Form("Boundary error in col [%d, %d + %d]", col + jpos, col, jpos));
402  if(row + ipos >= kNRowsPhi) AliError(Form("Boundary error in row [%d, %d + %d]", row + ipos, row, ipos));
403  Char_t l0times = (*fLevel0TimeMap)(col + jpos,row + ipos);
404  if(l0times > fL0MinTime && l0times < fL0MaxTime) nvalid++;
405  }
406  }
407  if (nvalid == 4) result = kLevel0Fired;
408  return result;
409 }
410 
413  result->SetPatchSize(2);
414  result->SetSubregionSize(1);
415  result->SetBitMask(1<<fTriggerBitConfig->GetGammaHighBit() | 1<<fTriggerBitConfig->GetGammaLowBit());
416  return result;
417 }
418 
421  result->SetPatchSize(fJetPatchsize);
422  result->SetSubregionSize(4);
423  result->SetBitMask(1<<fTriggerBitConfig->GetJetHighBit() | 1<<fTriggerBitConfig->GetJetLowBit());
424  return result;
425 }
426 
429  result->SetPatchSize(8);
430  result->SetSubregionSize(4);
431  result->SetBitMask(1<<fTriggerBitConfig->GetBkgBit());
432  return result;
433 }
434 
435 Bool_t AliEmcalTriggerMakerKernel::IsGammaPatch(const AliEMCALTriggerRawPatch &patch) const {
436  ULong_t bitmask = patch.GetBitmask(), testmask = 1 << fTriggerBitConfig->GetGammaHighBit() | 1 << fTriggerBitConfig->GetGammaLowBit();
437  return bitmask & testmask;
438 }
439 
440 Bool_t AliEmcalTriggerMakerKernel::IsJetPatch(const AliEMCALTriggerRawPatch &patch) const {
441  ULong_t bitmask = patch.GetBitmask(), testmask = 1 << fTriggerBitConfig->GetJetHighBit() | 1 << fTriggerBitConfig->GetJetLowBit();
442  return bitmask & testmask;
443 }
444 
445 Bool_t AliEmcalTriggerMakerKernel::IsBkgPatch(const AliEMCALTriggerRawPatch &patch) const {
446  ULong_t bitmask = patch.GetBitmask(), testmask = 1 << fTriggerBitConfig->GetBkgBit();
447  return bitmask & testmask;
448 }
Int_t fBkgThreshold
threshold for the background patches (8x8)
ClassImp(AliAnalysisTaskTriggerRates) AliAnalysisTaskTriggerRates
ELevel0TriggerStatus_t CheckForL0(Int_t col, Int_t row) const
Bool_t IsGammaPatch(const AliEMCALTriggerRawPatch &patch) const
Bool_t IsBkgPatch(const AliEMCALTriggerRawPatch &patch) const
TObjArray * CreateTriggerPatches(const AliVEvent *inputevent, Bool_t useL0amp=kFALSE)
AliEMCALTriggerDataGrid< int > * fTriggerBitMap
! Map of trigger bits
void ReadFastORBadChannelFromStream(std::istream &stream)
TArrayF fFastORPedestal
FastOR pedestal.
Int_t fMinCellAmp
Minimum offline amplitude of the cells used to generate the patches.
void ReadFastORBadChannelFromFile(const char *fname)
void ReadTriggerData(AliVCaloTrigger *trigger)
Int_t fMinL1FastORAmp
Minimum L1 amplitude of the FastORs used to generate the patches.
const AliEMCALTriggerBitConfig * fTriggerBitConfig
Trigger bit configuration, aliroot-dependent.
const AliEMCALGeometry * fGeometry
! Underlying EMCAL geometry
ULong64_t fL1ThresholdsOffline[4]
container for V0-dependent offline thresholds
void ReadOfflineBadChannelFromFile(const char *fname)
Int_t fThresholdConstants[4][3]
simple offline trigger thresholds constants
AliEMCALTriggerAlgorithm< double > * CreateGammaTriggerAlgorithm(Int_t rowmin, Int_t rowmax) const
Double_t fADCtoGeV
! Conversion factor from ADC to GeV
void ReadOfflineBadChannelFromStream(std::istream &stream)
void SetFastORPedestal(Short_t absId, Float_t ped)
std::set< Short_t > fBadChannels
Container of bad channels.
Int_t fDebugLevel
Int_t fL0Threshold
threshold for the L0 patches (2x2)
AliEMCALTriggerDataGrid< double > * fPatchAmplitudes
! TRU Amplitudes (for L0)
Manager for constants used in the trigger maker.
void BuildL1ThresholdsOffline(const AliVVZERO *vzdata)
AliEMCALTriggerDataGrid< double > * fPatchADC
! ADC values map
Bool_t isMC
Int_t fMinL0FastORAmp
Minimum L0 amplitude of the FastORs used to generate the patches.
AliEMCALTriggerAlgorithm< double > * CreateBkgTriggerAlgorithm(Int_t rowmin, Int_t rowmax) const
std::set< Short_t > fOfflineBadChannels
Abd ID of offline bad channels.
AliEMCALTriggerPatchFinder< double > * fPatchFinder
! The actual patch finder
TFile * file
AliEMCALTriggerDataGrid< double > * fPatchADCSimple
! patch map for simple offline trigger
Kernel of the EMCAL trigger patch makerThe trigger maker kernel contains the core functionality of th...
void ReadFastORPedestalFromFile(const char *fname)
AliEMCALTriggerDataGrid< char > * fLevel0TimeMap
! Map needed to store the level0 times
AliEMCALTriggerAlgorithm< double > * fLevel0PatchFinder
! Patch finder for Level0 patches
Bool_t IsJetPatch(const AliEMCALTriggerRawPatch &patch) const
Int_t fJetPatchsize
Size of a jet patch.
void ReadFastORPedestalFromStream(std::istream &stream)
void ReadCellData(AliVCaloCells *cells)
AliEMCALTriggerAlgorithm< double > * CreateJetTriggerAlgorithm(Int_t rowmin, Int_t rowmax) const
const Double_t kEMCL0ADCtoGeV_AP