AliPhysics  09a22ae (09a22ae)
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 
116  // Helper histograms checking the mask status of cells and FastORs
117  fHistosQA->CreateTH1("hMaskedFastors", "Index of masked FastOR; FastOR index; Counts", 3001, -0.5, 3000.5);
118  fHistosQA->CreateTH1("hMaskedCells", "Index of masked cell; Cell index; Counts", 20001, -0.5, 20000.5);
119  fHistosQA->CreateTH1("hCellEnergyCount", "Counts of non-0 cell entries; Cell index; Counts", 20001, -0.5, 20000.5);
120 
121  // THnSparse for fastor-by-fastor energy decalibration
122  TAxis fastorIDAxis(4992, -0.5, 4991.5), offlineaxis(200, 0., 20.), onlineaxis(200, 0., 20.), cellmaskaxis(5, -0.5, 4.5);
123  const TAxis *sparseaxis[4] = {&fastorIDAxis, &offlineaxis, &onlineaxis, &cellmaskaxis};
124  fastorIDAxis.SetNameTitle("fastorAbsID", "FastOR abs. ID");
125  offlineaxis.SetNameTitle("offlinenergy", "E_{2x2 cells} (GeV)");
126  onlineaxis.SetNameTitle("onlineenergy", "E_{FastOR} (GeV)");
127  cellmaskaxis.SetNameTitle("maskedcells", "Number of masked cells");
128  fHistosQA->CreateTHnSparse("hFastOrEnergyOfflineOnline", "FastOr Offline vs Online energy", 4, sparseaxis);
129 
130  for(auto h : *(fHistosQA->GetListOfHistograms())) fOutput->Add(h);
131  PostData(1, fOutput);
132 }
133 
135  int nrow = fGeom->GetTriggerMappingVersion() == 2 ? 104 : 64;
136  fCellData.Allocate(48, nrow);
137 
138  if(fNameMaskedCellOADB.Length()){
139  fMaskedCellOADB = new AliOADBContainer("AliEMCALBadChannels");
140  fMaskedCellOADB->InitFromFile(fNameMaskedCellOADB, "AliEMCALBadChannels");
141  }
142 
143  if(fNameMaskedFastorOADB.Length()){
144  fMaskedFastorOADB = new AliOADBContainer("AliEmcalMaskedFastors");
145  fMaskedFastorOADB->InitFromFile(fNameMaskedFastorOADB, "AliEmcalMaskedFastors");
146  }
147 }
148 
150  // Load masked FastOR data
151  if(fMaskedFastorOADB){
152  AliInfoStream() << "Loading masked cells for run " << newrun << std::endl;
153  fMaskedFastors.clear();
154  TObjArray *maskedfastors = static_cast<TObjArray *>(fMaskedFastorOADB->GetObject(newrun));
155  if(maskedfastors && maskedfastors->GetEntries()){
156  for(auto masked : *maskedfastors){
157  TParameter<int> *fastOrAbsID = static_cast<TParameter<int> *>(masked);
158  fMaskedFastors.push_back(fastOrAbsID->GetVal());
159  fHistosQA->FillTH1("hMaskedFastors", fastOrAbsID->GetVal());
160  }
161  std::sort(fMaskedFastors.begin(), fMaskedFastors.end(), std::less<int>());
162  }
163  }
164 
165  // Load masked cell data
166  if(fMaskedCellOADB){
167  AliInfoStream() << "Loading masked cells for run " << newrun << std::endl;
168  fMaskedCells.clear();
169  TObjArray *maskhistos = static_cast<TObjArray *>(fMaskedCellOADB->GetObject(newrun));
170  if(maskhistos && maskhistos->GetEntries()){
171  for(auto mod : *maskhistos){
172  TH2 *modhist = static_cast<TH2 *>(mod);
173  TString modname = modhist->GetName();
174  AliDebugStream(1) << "Reading bad channels from histogram " << modname << std::endl;
175  modname.ReplaceAll("EMCALBadChannelMap_Mod", "");
176  Int_t modid = modname.Atoi();
177  for(int icol = 0; icol < 48; icol++){
178  for(int irow = 0; irow < 24; irow++){
179  if(modhist->GetBinContent(icol, irow) > 0.){
180  int cellindex = fGeom->GetAbsCellIdFromCellIndexes(modid, irow, icol);
181  fMaskedCells.push_back(cellindex);
182  fHistosQA->FillTH1("hMaskedCells", cellindex);
183  }
184  }
185  }
186  }
187  std::sort(fMaskedCells.begin(), fMaskedCells.end(), std::less<int>());
188  }
189  }
190 }
191 
193  // Check trigger
194  if(!(fInputHandler->IsEventSelected() & fRequestTrigger)) return false;
195  if(fTriggerPattern.Length()){
196  if(!TString(InputEvent()->GetFiredTriggerClasses()).Contains(fTriggerPattern)) return false;
197  }
198  return true;
199 }
200 
203  fHistosQA->FillTH1("hEvents", 1);
204  AliVCaloTrigger *triggerdata = InputEvent()->GetCaloTrigger("EMCAL");
205  triggerdata->Reset();
206  Int_t nl0times, l1timesum, fastOrID, globCol, globRow;
207  Float_t amp;
208  while(triggerdata->Next()){
209  triggerdata->GetAmplitude(amp);
210  triggerdata->GetNL0Times(nl0times);
211  triggerdata->GetL1TimeSum(l1timesum);
212  triggerdata->GetPosition(globCol, globRow);
213  fGeom->GetTriggerMapping()->GetAbsFastORIndexFromPositionInEMCAL(globCol, globRow, fastOrID);
214  if(amp > 1e-5){
215  fHistosQA->FillTH2("hFastOrColRowFrequencyL0", globCol, globRow);
216  fHistosQA->FillTH1("hFastOrFrequencyL0", fastOrID);
217  }
218  if(l1timesum){
219  fHistosQA->FillTH2("hFastOrColRowFrequencyL1", globCol, globRow);
220  fHistosQA->FillTH1("hFastOrFrequencyL1", fastOrID);
221  }
222  if(std::find(fMaskedFastors.begin(), fMaskedFastors.end(), fastOrID) == fMaskedFastors.end()){
223  fHistosQA->FillTH2("hFastOrAmplitude", fastOrID, amp);
224  fHistosQA->FillTH2("hFastOrTimeSum", fastOrID, l1timesum);
225  fHistosQA->FillTH2("hFastOrNL0Times", fastOrID, nl0times);
226  fHistosQA->FillTH2("hFastOrTransverseTimeSum", fastOrID, GetTransverseTimeSum(fastOrID, l1timesum, fVertex));
227  fHistosQA->FillTH2("hEnergyFastorCell", fCellData(globCol, globRow), l1timesum * EMCALTrigger::kEMCL1ADCtoGeV);
228  int ncellmasked = 0;
229  int fastorCells[4];
230  fGeom->GetTriggerMapping()->GetCellIndexFromFastORIndex(fastOrID, fastorCells);
231  for(int icell = 0; icell < 4; icell++){
232  if(std::find(fMaskedCells.begin(), fMaskedCells.end(), fastorCells[icell]) != fMaskedCells.end()) ncellmasked++;
233  }
234  double energydata[4] = {
235  static_cast<double>(fastOrID),
236  fCellData(globCol, globRow),
237  l1timesum * EMCALTrigger::kEMCL1ADCtoGeV,
238  static_cast<double>(ncellmasked)
239  };
240  fHistosQA->FillTHnSparse("hFastOrEnergyOfflineOnline", energydata);
241  }
242  }
243  return true;
244 }
245 
247  fCellData.Reset();
248  AliVCaloCells *emccells = InputEvent()->GetEMCALCells();
249  for(int icell = 0; icell < emccells->GetNumberOfCells(); icell++){
250  int position = emccells->GetCellNumber(icell);
251  double amplitude = emccells->GetAmplitude(icell);
252  if(amplitude > 0){
253  fHistosQA->FillTH1("hCellEnergyCount", position);
254  if(std::find(fMaskedCells.begin(), fMaskedCells.end(), position) != fMaskedCells.end()){
255  AliErrorStream() << "Non-0 cell energy " << amplitude << " found for masked cell " << position << std::endl;
256  }
257  int absFastor, col, row;
258  fGeom->GetTriggerMapping()->GetFastORIndexFromCellIndex(position, absFastor);
259  fGeom->GetPositionInEMCALFromAbsFastORIndex(absFastor, col, row);
260  fCellData(col, row) += amplitude;
261  }
262  }
263 }
264 
266  Int_t cellIDs[4];
267  fGeom->GetTriggerMapping()->GetCellIndexFromFastORIndex(fastorAbsID, cellIDs);
268  std::vector<double> eta, phi;
269  for(int i = 0l; i < 4; i++){
270  double etatmp, phitmp;
271  fGeom->EtaPhiFromIndex(cellIDs[i], etatmp, phitmp);
272  eta.push_back(etatmp);
273  phi.push_back(phitmp);
274  }
275 
276  // Calculate FastOR position: for the approximation take mean eta and phi
277  // Radius is taken from the geometry
278  TVector3 fastorPos, vertexPos(vertex[0], vertex[1], vertex[2]);
279  fastorPos.SetPtEtaPhi(fGeom->GetIPDistance(), TMath::Mean(eta.begin(), eta.end()), TMath::Mean(phi.begin(), phi.end()));
280  fastorPos -= vertexPos;
281 
282  TLorentzVector evec(fastorPos, adc);
283  return evec.Et();
284 }
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.