AliPhysics  master (3d17d9d)
AliEmcalFastOrMonitorTask.cxx
Go to the documentation of this file.
1 /**************************************************************************************
2  * Copyright (C) 2017, Copyright Holders of the ALICE Collaboration *
3  * All rights reserved. *
4  * *
5  * Redistribution and use in source and binary forms, with or without *
6  * modification, are permitted provided that the following conditions are met: *
7  * * Redistributions of source code must retain the above copyright *
8  * notice, this list of conditions and the following disclaimer. *
9  * * Redistributions in binary form must reproduce the above copyright *
10  * notice, this list of conditions and the following disclaimer in the *
11  * documentation and/or other materials provided with the distribution. *
12  * * Neither the name of the <organization> nor the *
13  * names of its contributors may be used to endorse or promote products *
14  * derived from this software without specific prior written permission. *
15  * *
16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND *
17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED *
18  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE *
19  * DISCLAIMED. IN NO EVENT SHALL ALICE COLLABORATION BE LIABLE FOR ANY *
20  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES *
21  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; *
22  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND *
23  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT *
24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS *
25  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *
26  **************************************************************************************/
27 #include <algorithm>
28 #include <iostream>
29 #include <vector>
30 #include <THashList.h>
31 #include <TH2.h>
32 #include <THistManager.h>
33 #include <TLorentzVector.h>
34 #include <TMath.h>
35 #include <TObjArray.h>
36 #include <TParameter.h>
37 #include <TVector3.h>
38 
40 #include "AliEMCALGeometry.h"
41 #include "AliEMCALTriggerConstants.h"
42 #include "AliInputEventHandler.h"
43 #include "AliLog.h"
44 #include "AliOADBContainer.h"
45 #include "AliVCaloCells.h"
46 #include "AliVCaloTrigger.h"
47 #include "AliVEvent.h"
48 #include "AliVVertex.h"
49 #include "AliDataFile.h"
50 
54 
55 using namespace PWG::EMCAL;
56 
59  fHistosQA(nullptr),
60  fLocalInitialized(false),
61  fOldRun(-1),
62  fRequestTrigger(AliVEvent::kAny),
63  fTriggerPattern(""),
64  fCellData(),
65  fMaskedFastors(),
66  fMaskedCells(),
67  fNameMaskedFastorOADB(),
68  fNameMaskedCellOADB(AliDataFile::GetFileNameOADB("EMCAL/EMCALBadChannels.root").data()),
69  fMaskedFastorOADB(nullptr),
70  fMaskedCellOADB(nullptr)
71 {
72  SetNeedEmcalGeom(kTRUE);
73 }
74 
75 AliEmcalFastOrMonitorTask::AliEmcalFastOrMonitorTask(const char *name) :
76  AliAnalysisTaskEmcal(name, kTRUE),
77  fHistosQA(nullptr),
78  fLocalInitialized(false),
79  fOldRun(-1),
80  fRequestTrigger(AliVEvent::kAny),
81  fTriggerPattern(""),
82  fMaskedFastors(),
83  fMaskedCells(),
84  fNameMaskedFastorOADB(),
85  fNameMaskedCellOADB(AliDataFile::GetFileNameOADB("EMCAL/EMCALBadChannels.root").data()),
86  fMaskedFastorOADB(nullptr),
87  fMaskedCellOADB(nullptr)
88 {
89  SetNeedEmcalGeom(kTRUE);
90  DefineOutput(1, TList::Class());
91 }
92 
96 }
97 
100 
101  fHistosQA = new THistManager("fastOrHistos");
102 
103  const int kMaxCol = 48, kMaxRow = 104, kMaxFastOr = kMaxRow * kMaxCol;
104 
105  fHistosQA->CreateTH1("hEvents", "Number of events", 1, 0.5, 1.5);
106  fHistosQA->CreateTH1("hFastOrFrequencyL0", "FastOr frequency at Level0", kMaxFastOr, -0.5, kMaxFastOr - 0.5);
107  fHistosQA->CreateTH1("hFastOrFrequencyL1", "FastOr frequency at Level1", kMaxFastOr, -0.5, kMaxFastOr - 0.5);
108  fHistosQA->CreateTH2("hFastOrAmplitude", "FastOr amplitudes; FastOR Abs ID; Amplitude", kMaxFastOr, -0.5, kMaxFastOr - 0.5, 513, -0.5, 512.5);
109  fHistosQA->CreateTH2("hFastOrTimeSum", "FastOr time sum; FastOR Abs ID; L0 time sum", kMaxFastOr, -0.5, kMaxFastOr - 0.5, 2049, -0.5, 2048.5);
110  fHistosQA->CreateTH2("hFastOrTransverseTimeSum", "FastOr transverse time sum; FastOR Abs ID; L0 transverse time sum", kMaxFastOr, -0.5, kMaxFastOr - 0.5, 2049, -0.5, 2048.5);
111  fHistosQA->CreateTH2("hFastOrNL0Times", "FastOr Number of L0 times; FastOR AbsID; Number of L0 times", kMaxFastOr, -0.5, kMaxFastOr - 0.5, 16, -0.5, 15.5);
112  fHistosQA->CreateTH2("hFastOrColRowFrequencyL0", "FastOr Frequency (col-row) at Level0; col; row", kMaxCol, -0.5, kMaxCol - 0.5, kMaxRow, -0.5, kMaxRow - 0.5);
113  fHistosQA->CreateTH2("hFastOrColRowFrequencyL1", "FastOr Frequency (col-row) at Level1; col; row", kMaxCol, -0.5, kMaxCol - 0.5, kMaxRow, -0.5, kMaxRow - 0.5);
114  fHistosQA->CreateTH2("hEnergyFastorCell", "Sum of cell energy vs. fastor Energy", 1000, 0., 20., 1000 , 0., 20.);
115  fHistosQA->CreateTH2("hEnergyFastorCellL0", "Sum of cell energy vs. fastor Energy (L0)", 1000, 0., 20., 1000 , 0., 20.);
116  fHistosQA->CreateTH2("hEnergyFastorCellL0Amp", "Sum of cell energy vs. fastor Amplitude (L0)", 1000, 0., 20., 1000 , 0., 1000.);
117 
118  // Helper histograms checking the mask status of cells and FastORs
119  fHistosQA->CreateTH1("hMaskedFastors", "Index of masked FastOR; FastOR index; Counts", 3001, -0.5, 3000.5);
120  fHistosQA->CreateTH1("hMaskedCells", "Index of masked cell; Cell index; Counts", 20001, -0.5, 20000.5);
121  fHistosQA->CreateTH1("hCellEnergyCount", "Counts of non-0 cell entries; Cell index; Counts", 20001, -0.5, 20000.5);
122 
123  // THnSparse for fastor-by-fastor energy decalibration
124  TAxis fastorIDAxis(4992, -0.5, 4991.5), offlineaxis(200, 0., 20.), onlineaxis(200, 0., 20.), cellmaskaxis(5, -0.5, 4.5);
125  const TAxis *sparseaxis[4] = {&fastorIDAxis, &offlineaxis, &onlineaxis, &cellmaskaxis};
126  fastorIDAxis.SetNameTitle("fastorAbsID", "FastOR abs. ID");
127  offlineaxis.SetNameTitle("offlinenergy", "E_{2x2 cells} (GeV)");
128  onlineaxis.SetNameTitle("onlineenergy", "E_{FastOR} (GeV)");
129  cellmaskaxis.SetNameTitle("maskedcells", "Number of masked cells");
130  fHistosQA->CreateTHnSparse("hFastOrEnergyOfflineOnline", "FastOr Offline vs Online energy", 4, sparseaxis);
131  fHistosQA->CreateTHnSparse("hFastOrEnergyOfflineOnlineL0", "FastOr Offline vs Online energy (L0)", 4, sparseaxis);
132 
133  TAxis adcAxisL0(2101, -0.5, 2100.5), adcAxisL1(2101, -0.5, 2100.5);
134  const TAxis *adcaxes[3] = {&fastorIDAxis, &adcAxisL0, &adcAxisL1};
135  adcAxisL0.SetNameTitle("adcL0", "L0 ADC amplitude");
136  adcAxisL1.SetNameTitle("adcL1", "L1 ADC amplitude");
137  fHistosQA->CreateTHnSparse("hFastOrADCL0L1", "FastOR ADC in L0 and L1", 3, adcaxes);
138 
139 
140  for(auto h : *(fHistosQA->GetListOfHistograms())) fOutput->Add(h);
141  PostData(1, fOutput);
142 }
143 
145  int nrow = fGeom->GetTriggerMappingVersion() == 2 ? 104 : 64;
146  fCellData.Allocate(48, nrow);
147 
148  if(fNameMaskedCellOADB.Length()){
149  fMaskedCellOADB = new AliOADBContainer("AliEMCALBadChannels");
150  fMaskedCellOADB->InitFromFile(fNameMaskedCellOADB, "AliEMCALBadChannels");
151  }
152 
153  if(fNameMaskedFastorOADB.Length()){
154  fMaskedFastorOADB = new AliOADBContainer("AliEmcalMaskedFastors");
155  fMaskedFastorOADB->InitFromFile(fNameMaskedFastorOADB, "AliEmcalMaskedFastors");
156  }
157 }
158 
160  // Load masked FastOR data
161  if(fMaskedFastorOADB){
162  AliInfoStream() << "Loading masked cells for run " << newrun << std::endl;
163  fMaskedFastors.clear();
164  TObjArray *maskedfastors = static_cast<TObjArray *>(fMaskedFastorOADB->GetObject(newrun));
165  if(maskedfastors && maskedfastors->GetEntries()){
166  for(auto masked : *maskedfastors){
167  TParameter<int> *fastOrAbsID = static_cast<TParameter<int> *>(masked);
168  fMaskedFastors.push_back(fastOrAbsID->GetVal());
169  fHistosQA->FillTH1("hMaskedFastors", fastOrAbsID->GetVal());
170  }
171  std::sort(fMaskedFastors.begin(), fMaskedFastors.end(), std::less<int>());
172  }
173  }
174 
175  // Load masked cell data
176  if(fMaskedCellOADB){
177  AliInfoStream() << "Loading masked cells for run " << newrun << std::endl;
178  fMaskedCells.clear();
179  TObjArray *maskhistos = static_cast<TObjArray *>(fMaskedCellOADB->GetObject(newrun));
180  if(maskhistos && maskhistos->GetEntries()){
181  for(auto mod : *maskhistos){
182  TH2 *modhist = static_cast<TH2 *>(mod);
183  TString modname = modhist->GetName();
184  AliDebugStream(1) << "Reading bad channels from histogram " << modname << std::endl;
185  modname.ReplaceAll("EMCALBadChannelMap_Mod", "");
186  Int_t modid = modname.Atoi();
187  for(int icol = 0; icol < 48; icol++){
188  for(int irow = 0; irow < 24; irow++){
189  if(modhist->GetBinContent(icol, irow) > 0.){
190  int cellindex = fGeom->GetAbsCellIdFromCellIndexes(modid, irow, icol);
191  fMaskedCells.push_back(cellindex);
192  fHistosQA->FillTH1("hMaskedCells", cellindex);
193  }
194  }
195  }
196  }
197  std::sort(fMaskedCells.begin(), fMaskedCells.end(), std::less<int>());
198  }
199  }
200 }
201 
203  // Check trigger
204  if(!(fInputHandler->IsEventSelected() & fRequestTrigger)) return false;
205  if(fTriggerPattern.Length()){
206  if(!TString(InputEvent()->GetFiredTriggerClasses()).Contains(fTriggerPattern)) return false;
207  }
208  return true;
209 }
210 
212  const Double_t kEMCL0ADCtoGeV = 0.018970588*4;
214  fHistosQA->FillTH1("hEvents", 1);
215  AliVCaloTrigger *triggerdata = InputEvent()->GetCaloTrigger("EMCAL");
216  triggerdata->Reset();
217  Int_t nl0times, l1timesum, fastOrID, globCol, globRow;
218  Float_t amp;
219  while(triggerdata->Next()){
220  triggerdata->GetAmplitude(amp);
221  triggerdata->GetNL0Times(nl0times);
222  triggerdata->GetL1TimeSum(l1timesum);
223  triggerdata->GetPosition(globCol, globRow);
224  fGeom->GetTriggerMapping()->GetAbsFastORIndexFromPositionInEMCAL(globCol, globRow, fastOrID);
225  if(amp > 1e-5){
226  fHistosQA->FillTH2("hFastOrColRowFrequencyL0", globCol, globRow);
227  fHistosQA->FillTH1("hFastOrFrequencyL0", fastOrID);
228  }
229  if(l1timesum){
230  fHistosQA->FillTH2("hFastOrColRowFrequencyL1", globCol, globRow);
231  fHistosQA->FillTH1("hFastOrFrequencyL1", fastOrID);
232  }
233  if(std::find(fMaskedFastors.begin(), fMaskedFastors.end(), fastOrID) == fMaskedFastors.end()){
234  fHistosQA->FillTH2("hFastOrAmplitude", fastOrID, amp);
235  fHistosQA->FillTH2("hFastOrTimeSum", fastOrID, l1timesum);
236  fHistosQA->FillTH2("hFastOrNL0Times", fastOrID, nl0times);
237  fHistosQA->FillTH2("hFastOrTransverseTimeSum", fastOrID, GetTransverseTimeSum(fastOrID, l1timesum, fVertex));
238  fHistosQA->FillTH2("hEnergyFastorCell", fCellData(globCol, globRow), l1timesum * EMCALTrigger::kEMCL1ADCtoGeV);
239  fHistosQA->FillTH2("hEnergyFastorCellL0", fCellData(globCol, globRow), amp * kEMCL0ADCtoGeV);
240  fHistosQA->FillTH2("hEnergyFastorCellL0Amp", fCellData(globCol, globRow), amp);
241  int ncellmasked = 0;
242  int fastorCells[4];
243  fGeom->GetTriggerMapping()->GetCellIndexFromFastORIndex(fastOrID, fastorCells);
244  for(int icell = 0; icell < 4; icell++){
245  if(std::find(fMaskedCells.begin(), fMaskedCells.end(), fastorCells[icell]) != fMaskedCells.end()) ncellmasked++;
246  }
247  double energydata[4] = {
248  static_cast<double>(fastOrID),
249  fCellData(globCol, globRow),
250  static_cast<double>(l1timesum) * EMCALTrigger::kEMCL1ADCtoGeV,
251  static_cast<double>(ncellmasked)
252  };
253  fHistosQA->FillTHnSparse("hFastOrEnergyOfflineOnline", energydata);
254  energydata[2] = amp * kEMCL0ADCtoGeV;
255  fHistosQA->FillTHnSparse("hFastOrEnergyOfflineOnlineL0", energydata);
256  double adcdata[3] = {
257  static_cast<double>(fastOrID),
258  amp * 4., // correction for the bit shift
259  static_cast<double>(l1timesum)
260  };
261  fHistosQA->FillTHnSparse("hFastOrADCL0L1", adcdata);
262  }
263  }
264  return true;
265 }
266 
268  fCellData.Reset();
269  AliVCaloCells *emccells = InputEvent()->GetEMCALCells();
270  for(int icell = 0; icell < emccells->GetNumberOfCells(); icell++){
271  int position = emccells->GetCellNumber(icell);
272  double amplitude = emccells->GetAmplitude(icell);
273  if(amplitude > 0){
274  fHistosQA->FillTH1("hCellEnergyCount", position);
275  if(std::find(fMaskedCells.begin(), fMaskedCells.end(), position) != fMaskedCells.end()){
276  AliErrorStream() << "Non-0 cell energy " << amplitude << " found for masked cell " << position << std::endl;
277  }
278  int absFastor, col, row;
279  fGeom->GetTriggerMapping()->GetFastORIndexFromCellIndex(position, absFastor);
280  fGeom->GetPositionInEMCALFromAbsFastORIndex(absFastor, col, row);
281  fCellData(col, row) += amplitude;
282  }
283  }
284 }
285 
287  Int_t cellIDs[4];
288  fGeom->GetTriggerMapping()->GetCellIndexFromFastORIndex(fastorAbsID, cellIDs);
289  std::vector<double> eta, phi;
290  for(int i = 0l; i < 4; i++){
291  double etatmp, phitmp;
292  fGeom->EtaPhiFromIndex(cellIDs[i], etatmp, phitmp);
293  eta.push_back(etatmp);
294  phi.push_back(phitmp);
295  }
296 
297  // Calculate FastOR position: for the approximation take mean eta and phi
298  // Radius is taken from the geometry
299  TVector3 fastorPos, vertexPos(vertex[0], vertex[1], vertex[2]);
300  fastorPos.SetPtEtaPhi(fGeom->GetIPDistance(), TMath::Mean(eta.begin(), eta.end()), TMath::Mean(phi.begin(), phi.end()));
301  fastorPos -= vertexPos;
302 
303  TLorentzVector evec(fastorPos, adc);
304  return evec.Et();
305 }
Double_t GetTransverseTimeSum(Int_t fastorAbsID, Double_t adc, const Double_t *vtx) const
Calculate transverse L1 time sum of a FastOR.
double Double_t
Definition: External.C:58
std::vector< int > fMaskedCells
List of masked cells.
virtual void UserExecOnce()
Initialization of the task.
Base task in the EMCAL framework.
TString fNameMaskedFastorOADB
Name of the OADB container with masked fastors.
void FillTH2(const char *hname, double x, double y, double weight=1., Option_t *opt="")
Fill a 2D histogram within the container.
ULong_t fRequestTrigger
Trigger selection bits.
std::vector< int > fMaskedFastors
List of masked fastors.
Namespace for EMCAL framework classes and task.
void FillTHnSparse(const char *name, const double *x, double weight=1., Option_t *opt="")
TH2 * CreateTH2(const char *name, const char *title, int nbinsx, double xmin, double xmax, int nbinsy, double ymin, double ymax, Option_t *opt="")
Create a new TH2 within the container.
int Int_t
Definition: External.C:63
virtual bool IsEventSelected()
Perform event selection.
THashList * GetListOfHistograms() const
Get the list of histograms.
Definition: THistManager.h:671
float Float_t
Definition: External.C:68
AliEMCALGeometry * fGeom
!emcal geometry
TH1 * CreateTH1(const char *name, const char *title, int nbins, double xmin, double xmax, Option_t *opt="")
Create a new TH1 within the container.
AliOADBContainer * fMaskedFastorOADB
! OADB container with masked fastors
AliEMCALTriggerDataGrid< double > fCellData
Grid with summed cell data.
TString fNameMaskedCellOADB
Name of the OADB container with masked cells.
Namespace for PWG framework classes.
void FillTH1(const char *hname, double x, double weight=1., Option_t *opt="")
Fill a 1D histogram within the container.
THistManager * fHistosQA
! Histogram handler
AliEmcalList * fOutput
!output list
virtual void UserCreateOutputObjects()
Creating output objects.
Definition: External.C:220
Double_t fVertex[3]
!event vertex
void SetNeedEmcalGeom(Bool_t n)
Container class for histograms.
Definition: THistManager.h:99
void LoadEventCellData()
Load event-dependent cell data.
void UserCreateOutputObjects()
Main initialization function on the worker.
AliOADBContainer * fMaskedCellOADB
! OADB container with masked cells
virtual void RunChanged(Int_t newrun)
Run-dependent setup of the task.
THnSparse * CreateTHnSparse(const char *name, const char *title, int ndim, const int *nbins, const double *min, const double *max, Option_t *opt="")
Create a new THnSparse within the container.
TString fTriggerPattern
Trigger string pattern used in addition to the trigger selection bits.
Simlple monitoring of EMCAL FastOr quantities.