AliPhysics  d565ceb (d565ceb)
AliEmcalCorrectionCellEmulateCrosstalk.cxx
Go to the documentation of this file.
1 // AliEmcalCorrectionCellEmulateCrosstalk
2 //
3 
4 #include <map>
5 #include <vector>
6 #include <string>
7 
8 #include <TObjArray.h>
9 #include <TFile.h>
10 
11 #include <AliEMCALGeometry.h>
12 #include <AliEMCALRecoUtils.h>
13 #include <AliAODEvent.h>
14 
16 
20 
21 // Actually registers the class with the base class
23 
28  AliEmcalCorrectionComponent("AliEmcalCorrectionCellEmulateCrosstalk"),
29  fCellEnergyDistBefore(0),
30  fCellEnergyDistAfter(0),
31  fTCardCorrClusEnerConserv(kFALSE),
32  fRandom(0),
33  fRandomizeTCard(kTRUE),
34  fTCardCorrMinAmp(0.01),
35  fTCardCorrMaxInduced(100),
36  fPrintOnce(kFALSE)
37 {
38  for(Int_t i = 0; i < fgkNsm; i++)
39  {
43 
44  for(Int_t j = 0; j < 4 ; j++)
45  {
46  fTCardCorrInduceEner [j][i] = 0 ;
47  fTCardCorrInduceEnerFrac [j][i] = 0 ;
48  fTCardCorrInduceEnerFracP1 [j][i] = 0 ;
50  }
51  }
52 
53  ResetArrays();
54 
55 }
56 
61 {
62 }
63 
68 {
69  // Initialization
71 
72  AliWarning("Init EMCAL crosstalk emulation");
73 
74  GetProperty("conservEnergy", fTCardCorrClusEnerConserv);
75  GetProperty("randomizeTCardInducedEnergy", fRandomizeTCard);
76  GetProperty("inducedTCardMinimumCellEnergy", fTCardCorrMinAmp);
77  GetProperty("inducedTCardMaximum", fTCardCorrMaxInduced);
78 
79  // Handle array initialization
80  // For the format of these values, see the "default" yaml configuration file
81  const std::map <std::string, Float_t (*)[fgkNsm]> properties2D = {
82  {"inducedEnergyLossConstant", fTCardCorrInduceEner},
83  {"inducedEnergyLossFraction", fTCardCorrInduceEnerFrac},
84  {"inducedEnergyLossFractionP1", fTCardCorrInduceEnerFracP1},
85  {"inducedEnergyLossFractionWidth", fTCardCorrInduceEnerFracWidth}
86  };
87  const std::map <std::string, Float_t *> properties1D = {
88  {"inducedEnergyLossMinimumFraction", fTCardCorrInduceEnerFracMin},
89  {"inducedEnergyLossMaximumFraction", fTCardCorrInduceEnerFracMax},
90  {"inducedEnergyLossProbability", fTCardCorrInduceEnerProb}
91  };
92  RetrieveAndSetProperties(properties2D);
93  RetrieveAndSetProperties(properties1D);
94 
95  if (!fRecoUtils) {
96  fRecoUtils = new AliEMCALRecoUtils;
97  }
98 
99  GetProperty("printConfiguration", fPrintOnce);
100  if (fPrintOnce) {
101  PrintTCardParam();
102  }
103 
104  return kTRUE;
105 }
106 
115 void AliEmcalCorrectionCellEmulateCrosstalk::SetProperty(Float_t val[][fgkNsm], std::vector<double> & property, unsigned int iSM, const std::string & name)
116 {
117  for (unsigned int iProperty = 0; iProperty < property.size(); iProperty++) {
118  val[iProperty][iSM] = property.at(iProperty);
119  }
120 }
121 
130 void AliEmcalCorrectionCellEmulateCrosstalk::SetProperty(Float_t val[fgkNsm], std::vector<double> & property, unsigned int iSM, const std::string & name)
131 {
132  if (property.size() != 1) {
133  AliErrorStream() << "Trying to set single value for property " << name << ", but given " << property.size() << " values. Please check your configuration!\n";
134  }
135  else {
136  val[iSM] = property.at(0);
137  }
138 }
139 
144 {
146 
147  if (fCreateHisto){
148  fCellEnergyDistBefore = new TH1F("hCellEnergyDistBefore","hCellEnergyDistBefore;E_{cell} (GeV)",1000,0,10);
150  fCellEnergyDistAfter = new TH1F("hCellEnergyDistAfter","hCellEnergyDistAfter;E_{cell} (GeV)",1000,0,10);
152  }
153 }
154 
159 {
161 
162  if (!fEventManager.InputEvent()) {
163  AliError("Event ptr = 0, returning");
164  return kFALSE;
165  }
166 
167  // START PROCESSING ---------------------------------------------------------
168  // Test if cells present
169  if (fCaloCells->GetNumberOfCells()<=0)
170  {
171  AliDebug(2, Form("Number of EMCAL cells = %d, returning", fCaloCells->GetNumberOfCells()));
172  return kFALSE;
173  }
174 
175  if(fCreateHisto)
176  FillCellQA(fCellEnergyDistBefore); // "before" QA
177 
178  // CELL CROSSTALK EMULATION -------------------------------------------------------
179 
180  // Compute the induced cell energies by T-Card correlation emulation, ONLY MC
182 
183  // Add to existing cells the found induced energies in MakeCellTCardCorrelation() if new signal is larger than 10 MeV.
185 
186  // Add new cells with found induced energies in MakeCellTCardCorrelation() if new signal is larger than 10 MeV.
188 
189  // -------------------------------------------------------
190 
191  if(fCreateHisto)
192  FillCellQA(fCellEnergyDistAfter); // "after" QA
193 
194  ResetArrays();
195 
196  return kTRUE;
197 }
198 
204 {
205  Int_t id = -1;
206  Float_t amp = -1;
207 
208  // Loop on all cells with signal
209  for (Int_t icell = 0; icell < fCaloCells->GetNumberOfCells(); icell++)
210  {
211  id = fCaloCells->GetCellNumber(icell);
212  amp = fCaloCells->GetAmplitude (icell); // fCaloCells->GetCellAmplitude(id);
213 
214  if ( amp <= fTCardCorrMinAmp ) continue ;
215 
216  //
217  // First get the SM, col-row of this tower
218  Int_t imod = -1, iphi =-1, ieta=-1,iTower = -1, iIphi = -1, iIeta = -1;
219  fGeom->GetCellIndex(id,imod,iTower,iIphi,iIeta);
220  fGeom->GetCellPhiEtaIndexInSModule(imod,iTower,iIphi, iIeta,iphi,ieta);
221 
222  //
223  // Determine randomly if we want to create a correlation for this cell,
224  // depending the SM number of the cell
225  Float_t rand = fRandom.Uniform(0, 1);
226 
227  if ( rand > fTCardCorrInduceEnerProb[imod] ) continue;
228 
229  AliDebug(1,Form("Reference cell absId %d, iEta %d, iPhi %d, amp %2.3f",id,ieta,iphi,amp));
230 
231  //
232  // Get the absId of the cells in the cross and same T-Card
233  Int_t absIDup = -1;
234  Int_t absIDdo = -1;
235  Int_t absIDlr = -1;
236  Int_t absIDuplr = -1;
237  Int_t absIDdolr = -1;
238 
239  Int_t absIDup2 = -1;
240  Int_t absIDup2lr = -1;
241  Int_t absIDdo2 = -1;
242  Int_t absIDdo2lr = -1;
243 
244  // Only 2 columns in the T-Card, +1 for even and -1 for odd with respect reference cell
245  Int_t colShift = 0;
246  if ( (ieta%2) && ieta <= AliEMCALGeoParams::fgkEMCALCols-1 ) colShift = -1;
247  if ( !(ieta%2) && ieta >= 0 ) colShift = +1;
248 
249  absIDlr = fGeom->GetAbsCellIdFromCellIndexes(imod, iphi, ieta+colShift);
250 
251  // Check up / down cells from reference cell not out of SM and in same T-Card
252  if ( iphi < AliEMCALGeoParams::fgkEMCALRows-1 )
253  {
254  absIDup = fGeom->GetAbsCellIdFromCellIndexes(imod, iphi+1, ieta);
255  absIDuplr = fGeom->GetAbsCellIdFromCellIndexes(imod, iphi+1, ieta+colShift);
256  }
257 
258  if ( iphi > 0 )
259  {
260  absIDdo = fGeom->GetAbsCellIdFromCellIndexes(imod, iphi-1, ieta);
261  absIDdolr = fGeom->GetAbsCellIdFromCellIndexes(imod, iphi-1, ieta+colShift);
262  }
263 
264  // Check 2 up / 2 down cells from reference cell not out of SM
265  if ( iphi < AliEMCALGeoParams::fgkEMCALRows-2 )
266  {
267  absIDup2 = fGeom->GetAbsCellIdFromCellIndexes(imod, iphi+2, ieta);
268  absIDup2lr = fGeom->GetAbsCellIdFromCellIndexes(imod, iphi+2, ieta+colShift);
269  }
270 
271  if ( iphi > 1 )
272  {
273  absIDdo2 = fGeom->GetAbsCellIdFromCellIndexes(imod, iphi-2, ieta);
274  absIDdo2lr = fGeom->GetAbsCellIdFromCellIndexes(imod, iphi-2, ieta+colShift);
275  }
276 
277  // In same T-Card?
278  if ( TMath::FloorNint(iphi/8) != TMath::FloorNint((iphi+1)/8) ) { absIDup = -1 ; absIDuplr = -1 ; }
279  if ( TMath::FloorNint(iphi/8) != TMath::FloorNint((iphi-1)/8) ) { absIDdo = -1 ; absIDdolr = -1 ; }
280  if ( TMath::FloorNint(iphi/8) != TMath::FloorNint((iphi+2)/8) ) { absIDup2 = -1 ; absIDup2lr = -1 ; }
281  if ( TMath::FloorNint(iphi/8) != TMath::FloorNint((iphi-2)/8) ) { absIDdo2 = -1 ; absIDdo2lr = -1 ; }
282 
283  //
284  // Check if they are not declared bad or exist
285  Bool_t okup = AcceptCell(absIDup );
286  Bool_t okdo = AcceptCell(absIDdo );
287  Bool_t oklr = AcceptCell(absIDlr );
288  Bool_t okuplr = AcceptCell(absIDuplr );
289  Bool_t okdolr = AcceptCell(absIDdolr );
290  Bool_t okup2 = AcceptCell(absIDup2 );
291  Bool_t okdo2 = AcceptCell(absIDdo2 );
292  Bool_t okup2lr= AcceptCell(absIDup2lr);
293  Bool_t okdo2lr= AcceptCell(absIDdo2lr);
294 
295  AliDebug(1,Form("Same T-Card cells:\n \t up %d (%d), down %d (%d), left-right %d (%d), up-lr %d (%d), down-lr %d (%d)\n"
296  "\t up2 %d (%d), down2 %d (%d), up2-lr %d (%d), down2-lr %d (%d)",
297  absIDup ,okup ,absIDdo ,okdo ,absIDlr,oklr,absIDuplr ,okuplr ,absIDdolr ,okdolr ,
298  absIDup2,okup2,absIDdo2,okdo2, absIDup2lr,okup2lr,absIDdo2lr,okdo2lr));
299 
300  //
301  // Generate some energy for the nearby cells in same TCard , depending on this cell energy
302  // Check if originally the tower had no or little energy, in which case tag it as new
303  Float_t fracupdown = fTCardCorrInduceEnerFrac[0][imod]+amp*fTCardCorrInduceEnerFracP1[0][imod];
304  Float_t fracupdownleri = fTCardCorrInduceEnerFrac[1][imod]+amp*fTCardCorrInduceEnerFracP1[1][imod];
305  Float_t fracleri = fTCardCorrInduceEnerFrac[2][imod]+amp*fTCardCorrInduceEnerFracP1[2][imod];
306  Float_t frac2nd = fTCardCorrInduceEnerFrac[3][imod]+amp*fTCardCorrInduceEnerFracP1[3][imod];
307 
308  AliDebug(1,Form("Fraction for SM %d (min %2.3f, max %2.3f):\n"
309  "\t up-down : c %2.3e, p1 %2.3e, p2 %2.4e, sig %2.3e, fraction %2.3f\n"
310  "\t up-down-lr: c %2.3e, p1 %2.3e, p2 %2.4e, sig %2.3e, fraction %2.3f\n"
311  "\t left-right: c %2.3e, p1 %2.3e, p2 %2.4e, sig %2.3e, fraction %2.3f\n"
312  "\t 2nd row : c %2.3e, p1 %2.3e, p2 %2.4e, sig %2.3e, fraction %2.3f",
314  fTCardCorrInduceEner[0][imod],fTCardCorrInduceEnerFrac[0][imod],fTCardCorrInduceEnerFracP1[0][imod],fTCardCorrInduceEnerFracWidth[0][imod],fracupdown,
315  fTCardCorrInduceEner[1][imod],fTCardCorrInduceEnerFrac[1][imod],fTCardCorrInduceEnerFracP1[1][imod],fTCardCorrInduceEnerFracWidth[1][imod],fracupdownleri,
316  fTCardCorrInduceEner[2][imod],fTCardCorrInduceEnerFrac[2][imod],fTCardCorrInduceEnerFracP1[2][imod],fTCardCorrInduceEnerFracWidth[2][imod],fracleri,
317  fTCardCorrInduceEner[3][imod],fTCardCorrInduceEnerFrac[3][imod],fTCardCorrInduceEnerFracP1[3][imod],fTCardCorrInduceEnerFracWidth[3][imod],frac2nd));
318 
319  if( fracupdown < fTCardCorrInduceEnerFracMin[imod] ) fracupdown = fTCardCorrInduceEnerFracMin[imod];
320  if( fracupdown > fTCardCorrInduceEnerFracMax[imod] ) fracupdown = fTCardCorrInduceEnerFracMax[imod];
321  if( fracupdownleri < fTCardCorrInduceEnerFracMin[imod] ) fracupdownleri = fTCardCorrInduceEnerFracMin[imod];
322  if( fracupdownleri > fTCardCorrInduceEnerFracMax[imod] ) fracupdownleri = fTCardCorrInduceEnerFracMax[imod];
323  if( fracleri < fTCardCorrInduceEnerFracMin[imod] ) fracleri = fTCardCorrInduceEnerFracMin[imod];
324  if( fracleri > fTCardCorrInduceEnerFracMax[imod] ) fracleri = fTCardCorrInduceEnerFracMax[imod];
325  if( frac2nd < fTCardCorrInduceEnerFracMin[imod] ) frac2nd = fTCardCorrInduceEnerFracMin[imod];
326  if( frac2nd > fTCardCorrInduceEnerFracMax[imod] ) frac2nd = fTCardCorrInduceEnerFracMax[imod];
327 
328  // Randomize the induced fraction, if requested
329  if(fRandomizeTCard)
330  {
331  fracupdown = fRandom.Gaus(fracupdown ,fTCardCorrInduceEnerFracWidth[0][imod]);
332  fracupdownleri = fRandom.Gaus(fracupdownleri,fTCardCorrInduceEnerFracWidth[1][imod]);
333  fracleri = fRandom.Gaus(fracleri ,fTCardCorrInduceEnerFracWidth[2][imod]);
334  frac2nd = fRandom.Gaus(frac2nd ,fTCardCorrInduceEnerFracWidth[3][imod]);
335 
336  AliDebug(1,Form("Randomized fraction: up-down %2.3f; up-down-left-right %2.3f; left-right %2.3f; 2nd row %2.3f",
337  fracupdown,fracupdownleri,fracleri,frac2nd));
338  }
339 
340  // Calculate induced energy
341  Float_t indEupdown = fTCardCorrInduceEner[0][imod]+amp*fracupdown;
342  Float_t indEupdownleri = fTCardCorrInduceEner[1][imod]+amp*fracupdownleri;
343  Float_t indEleri = fTCardCorrInduceEner[2][imod]+amp*fracleri;
344  Float_t indE2nd = fTCardCorrInduceEner[3][imod]+amp*frac2nd;
345 
346  AliDebug(1,Form("Induced energy: up-down %2.3f; up-down-left-right %2.3f; left-right %2.3f; 2nd row %2.3f",
347  indEupdown,indEupdownleri,indEleri,indE2nd));
348 
349  // Check if we induce too much energy, in such case use a constant value
350  if ( fTCardCorrMaxInduced < indE2nd ) indE2nd = fTCardCorrMaxInduced;
351  if ( fTCardCorrMaxInduced < indEupdownleri ) indEupdownleri = fTCardCorrMaxInduced;
352  if ( fTCardCorrMaxInduced < indEupdown ) indEupdown = fTCardCorrMaxInduced;
353  if ( fTCardCorrMaxInduced < indEleri ) indEleri = fTCardCorrMaxInduced;
354 
355  AliDebug(1,Form("Induced energy, saturated?: up-down %2.3f; up-down-left-right %2.3f; left-right %2.3f; 2nd row %2.3f",
356  indEupdown,indEupdownleri,indEleri,indE2nd));
357 
358  //
359  // Add the induced energy, check if cell existed
360  if ( okup )
361  {
362  fTCardCorrCellsEner[absIDup] += indEupdown;
363 
364  if ( fCaloCells->GetCellAmplitude(absIDup) < 0.01 ) fTCardCorrCellsNew[absIDup] = kTRUE;
365  }
366 
367  if ( okdo )
368  {
369  fTCardCorrCellsEner[absIDdo] += indEupdown;
370 
371  if ( fCaloCells->GetCellAmplitude(absIDdo) < 0.01 ) fTCardCorrCellsNew[absIDdo] = kTRUE;
372  }
373 
374  if ( oklr )
375  {
376  fTCardCorrCellsEner[absIDlr] += indEleri;
377 
378  if ( fCaloCells->GetCellAmplitude(absIDlr) < 0.01 ) fTCardCorrCellsNew[absIDlr] = kTRUE;
379  }
380 
381  if ( okuplr )
382  {
383  fTCardCorrCellsEner[absIDuplr] += indEupdownleri;
384 
385  if ( fCaloCells->GetCellAmplitude(absIDuplr ) < 0.01 ) fTCardCorrCellsNew[absIDuplr] = kTRUE;
386  }
387 
388  if ( okdolr )
389  {
390  fTCardCorrCellsEner[absIDdolr] += indEupdownleri;
391 
392  if ( fCaloCells->GetCellAmplitude(absIDdolr ) < 0.01 ) fTCardCorrCellsNew[absIDdolr] = kTRUE;
393  }
394 
395  if ( okup2 )
396  {
397  fTCardCorrCellsEner[absIDup2] += indE2nd;
398 
399  if ( fCaloCells->GetCellAmplitude(absIDup2) < 0.01 ) fTCardCorrCellsNew[absIDup2] = kTRUE;
400  }
401 
402  if ( okup2lr )
403  {
404  fTCardCorrCellsEner[absIDup2lr] += indE2nd;
405 
406  if ( fCaloCells->GetCellAmplitude(absIDup2lr) < 0.01 ) fTCardCorrCellsNew[absIDup2lr] = kTRUE;
407  }
408 
409  if ( okdo2 )
410  {
411  fTCardCorrCellsEner[absIDdo2] += indE2nd;
412 
413  if ( fCaloCells->GetCellAmplitude(absIDdo2) < 0.01 ) fTCardCorrCellsNew[absIDdo2] = kTRUE;
414  }
415 
416  if ( okdo2lr )
417  {
418  fTCardCorrCellsEner[absIDdo2lr] += indE2nd;
419 
420  if ( fCaloCells->GetCellAmplitude(absIDdo2lr) < 0.01 ) fTCardCorrCellsNew[absIDdo2lr] = kTRUE;
421  }
422 
423  //
424  // Subtract the added energy to main cell, if energy conservation is requested
426  {
427  if ( oklr ) fTCardCorrCellsEner[id] -= indEleri;
428  if ( okuplr ) fTCardCorrCellsEner[id] -= indEupdownleri;
429  if ( okdolr ) fTCardCorrCellsEner[id] -= indEupdownleri;
430  if ( okup ) fTCardCorrCellsEner[id] -= indEupdown;
431  if ( okdo ) fTCardCorrCellsEner[id] -= indEupdown;
432  if ( okup2 ) fTCardCorrCellsEner[id] -= indE2nd;
433  if ( okup2lr ) fTCardCorrCellsEner[id] -= indE2nd;
434  if ( okdo2 ) fTCardCorrCellsEner[id] -= indE2nd;
435  if ( okdo2lr ) fTCardCorrCellsEner[id] -= indE2nd;
436  } // conserve energy
437 
438  } // cell loop
439 
440 }
441 
446 {
447  Short_t absId = -1;
448  Double_t amp = -1;
449  Double_t time = -1;
450  Int_t mclabel = -1;
451  Double_t efrac = 0.;
452 
453  for (Int_t icell = 0; icell < fCaloCells->GetNumberOfCells(); icell++)
454  {
455 
456  // Get cell
457  fCaloCells->GetCell(icell, absId, amp, time, mclabel, efrac);
458 
459  if(amp <= 0.01) continue ; // accept if > 10 MeV
460 
461  amp+=fTCardCorrCellsEner[absId];
462 
463  //if(fTCardCorrCellsEner[absId] > 0.05) printf("\t absId %d amp %2.2f\n",absId,fTCardCorrCellsEner[absId]);
464 
465  // Set new amplitude
466  fCaloCells->SetCell(icell, absId, amp, time, mclabel, efrac);
467  }
468 
469 }
470 
475 {
476  Int_t nCells = fCaloCells->GetNumberOfCells();
477 
478  for(Int_t j = 0; j < fgkNEMCalCells; j++)
479  {
480  // Newly created?
481  if ( !fTCardCorrCellsNew[j] ) continue;
482 
483  // Accept only if at least 10 MeV
484  if ( fTCardCorrCellsEner[j] < 0.01 ) continue;
485 
486  // Add new cell
487  Int_t cellNumber = nCells;
488  Short_t absId = j;
489  Float_t amp = fTCardCorrCellsEner[j];
490  Double_t time = 615.*1e-9;
491  Int_t mclabel = -1;
492  Double_t efrac = 0.;
493  fCaloCells->SetCell(cellNumber, absId, amp, time, mclabel, efrac);
494 
495  nCells++;
496  }
497 
498 }
499 
504 {
505  for(Int_t j = 0; j < fgkNEMCalCells; j++)
506  {
507  fTCardCorrCellsEner[j] = 0.;
508  fTCardCorrCellsNew [j] = kFALSE;
509  }
510 }
511 
521 {
522  if ( absID < 0 || absID >= 24*48*fGeom->GetNumberOfSuperModules() )
523  return kFALSE;
524 
525  Int_t imod = -1,iTower = -1, iIphi = -1, iIeta = -1;
526  if (!fGeom->GetCellIndex(absID,imod,iTower,iIphi,iIeta))
527  return kFALSE;
528 
529  return kTRUE;
530 }
531 
536 {
537  printf("T-Card emulation activated, energy conservation <%d>, randomize E <%d>, induced energy parameters:\n",
539  printf("T-Card emulation super-modules fraction: Min cell E %2.2f Max induced E %2.2f\n",
541 
542  for(Int_t ism = 0; ism < fgkNsm; ism++)
543  {
544  printf("\t sm %d, fraction %2.3f, E frac abs min %2.3e max %2.3e \n",
546 
547  for(Int_t icell = 0; icell < 4; icell++)
548  {
549  printf("\t \t cell type %d, c %2.4e, p0 %2.4e, p1 %2.4e, sigma %2.4e \n",
550  icell,fTCardCorrInduceEner[icell][ism],fTCardCorrInduceEnerFrac[icell][ism],
552  }
553  }
554 }
Float_t fTCardCorrInduceEnerFracP1[4][fgkNsm]
Induced energy loss gauss fraction param1 on 0-same row, diff col, 1-up/down cells left/right col 2-l...
Bool_t fTCardCorrCellsNew[fgkNEMCalCells]
Array with induced cell energy in T-Card neighbour cells, that before had no signal.
AliEMCALGeometry * fGeom
! Geometry object
Float_t fTCardCorrMaxInduced
Maximum induced energy signal on adjacent cells.
double Double_t
Definition: External.C:58
static const Int_t fgkNsm
Total number of super-modules.
static const Int_t fgkNEMCalCells
Total number of cells in the calorimeter, 10*48*24 (EMCal) + 4*48*8 (EMCal/DCal 1/3) + 6*32*24 (DCal)...
Correction component to emulate cell-level crosstalk in the EMCal correction framework.
Bool_t fTCardCorrClusEnerConserv
When making correlation, subtract from the reference cell the induced energy on the neighbour cells...
Float_t fTCardCorrInduceEnerProb[fgkNsm]
Probability to induce energy loss per SM.
void SetProperty(Float_t val[][fgkNsm], std::vector< double > &property, unsigned int iSM, const std::string &name)
AliVCaloCells * fCaloCells
! Pointer to CaloCells
AliEMCALRecoUtils * fRecoUtils
Pointer to RecoUtils.
Float_t fTCardCorrInduceEnerFrac[4][fgkNsm]
Induced energy loss gauss fraction param0 on 0-same row, diff col, 1-up/down cells left/right col 2-l...
int Int_t
Definition: External.C:63
Float_t fTCardCorrMinAmp
Minimum cell energy to induce signal on adjacent cells.
Float_t fTCardCorrInduceEnerFracWidth[4][fgkNsm]
Induced energy loss gauss witdth on 0-same row, diff col, 1-up/down cells left/right col 2-left/righ ...
float Float_t
Definition: External.C:68
Base class for correction components in the EMCal correction framework.
Float_t fTCardCorrCellsEner[fgkNEMCalCells]
Array with induced cell energy in T-Card neighbour cells.
Float_t fTCardCorrInduceEnerFracMin[fgkNsm]
In case fTCardCorrInduceEnerFracP1 is non null, restrict the minimum fraction of induced energy per S...
TList * fOutput
! List of output histograms
short Short_t
Definition: External.C:23
Bool_t fCreateHisto
Flag to make some basic histograms.
TH1F * fCellEnergyDistBefore
! cell energy distribution, before energy smearing
TH1F * fCellEnergyDistAfter
! cell energy distribution, after energy smearing
Float_t fTCardCorrInduceEner[4][fgkNsm]
Induced energy loss gauss constant on 0-same row, diff col, 1-up/down cells left/right col 2-left/rig...
static RegisterCorrectionComponent< AliEmcalCorrectionCellEmulateCrosstalk > reg
AliEmcalCorrectionEventManager fEventManager
Minimal task which inherits from AliAnalysisTaskSE and manages access to the event.
Float_t fTCardCorrInduceEnerFracMax[fgkNsm]
In case fTCardCorrInduceEnerFracP1 is non null, restrict the maximum fraction of induced energy per S...
bool Bool_t
Definition: External.C:53
bool GetProperty(std::string propertyName, T &property, bool requiredProperty=true, std::string correctionName="")
Retrieve property.