Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
TileMuId2DBAlg.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 //*****************************************************************************
6 // Filename : TileMuId2DBAlg.cxx
7 // Author : Aranzazu Ruiz
8 // Created : May 2009
9 //
10 // DESCRIPTION:
11 //
12 // Individual lower energy thresholds for each cell are computed as three
13 // times the noise RMS value of the cell when the two PMTs are in High Gain
14 //
15 // For DSP usage, thresholds in MeV are multiply by 2 and round off in order
16 // to compare them with reconstructed energies at the DSP which have a 0.5 MeV
17 // precision for High Gain. ASCII file with TileMuId thresholds is created to
18 // be loaded in the DSPs.
19 //
20 // HISTORY:
21 //
22 // BUGS:
23 //
24 //*****************************************************************************
25 
26 #include "TileMuId2DBAlg.h"
32 
33 #include <fstream>
34 
35 using namespace std;
36 
37 
38 TileMuId2DBAlg::TileMuId2DBAlg(const std::string& name, ISvcLocator* pSvcLocator) :
39  AthAlgorithm(name,pSvcLocator),
40  m_calo_id(nullptr)
41 {
42 }
43 
44 
45 
46 
47 
49 {
50  const CaloIdManager* caloIdMgr = nullptr;
51  ATH_CHECK( detStore()->retrieve( caloIdMgr ) );
52  m_calo_id = caloIdMgr->getCaloCell_ID();
53 
55  return StatusCode::SUCCESS;
56 }
57 
58 
59 
61 {
62  // Open ASCII file
63  string TileMuIdFile = "TileMuId_thresholds.dat";
64  fstream *fl = new fstream(TileMuIdFile.c_str(), fstream::app| fstream::out);
65  if (fl->is_open())
66  ATH_MSG_INFO ( " TileMuId file open" );
67  else
68  ATH_MSG_INFO ( " TileMuId file didn't open succesfully" );
69 
70  float noise[4][64][24]; memset(noise,0,sizeof(noise));
71  int DSP[4][64][40]; memset(DSP,0,sizeof(DSP));
72  int Thr[4][64][40]; memset(Thr,0,sizeof(Thr));
73 
74  // A1, BC1, D0, A2, BC2, A3, BC3, D1, A4, BC4, A5, BC5, D2, A6, BC6, A7, BC7, D3, A8, BC8, A9, BC9, A10
75  int Thr_barrel[23] = {
76  1350, 2550, 1590, 960, 1980, 870, 1770, 1110, 750, 1890, 840, 1860, 1050, 840, 1800, 930, 1890, 1050, 840, 1860, 960, 1110, 900
77  };
78 
79  // B11, D5, A12, B12, A13, B13, D6, A14, B14, A15, B15, A16
80  int Thr_extbarrel[12] = {
81  1050, 2100, 210, 1380, 1140, 1440, 2370, 1230, 1500, 1380, 1680, 1680
82  };
83 
84  IdentifierHash caloCellMin=0;
85  IdentifierHash caloCellMax=0;
86  m_calo_id->calo_cell_hash_range(3, caloCellMin, caloCellMax);
87 
88  ATH_MSG_INFO ( "caloCellMin: " << caloCellMin );
89  ATH_MSG_INFO ( "caloCellMax: " << caloCellMax );
90  ATH_MSG_INFO ( "Start loop over TileCal cells " << caloCellMax-caloCellMin );
91 
93 
94  for (unsigned int i=caloCellMin;i<caloCellMax;i++) {
95 
96  IdentifierHash idHash = i;
97  Identifier id = m_calo_id->cell_id(idHash);
98  int subCalo{};
99  IdentifierHash idSubHash = m_calo_id->subcalo_cell_hash (idHash, subCalo);
100 
101  int module = m_calo_id->module(id);
103  ATH_MSG_ERROR("Module invalid in TileMuId2DBAlg::execute");
104  return StatusCode::FAILURE;
105  }
106 
108 
109  float cell_noise = totalNoise->getNoise(id,gain);
110 
111  if( m_calo_id->is_tile_barrel(id) && m_calo_id->is_tile_negative(id) ) noise[1][module][idSubHash-22*module] = 3*cell_noise;
112 
113  if( m_calo_id->is_tile_barrel(id) && m_calo_id->is_tile_positive(id) ) noise[0][module][idSubHash-(23*module+22*64)] = 3*cell_noise;
114 
115  if( m_calo_id->is_tile_extbarrel(id) && m_calo_id->is_tile_negative(id) ) noise[3][module][idSubHash-(12*module+23*64+22*64)] = 3*cell_noise;
116 
117  if( m_calo_id->is_tile_extbarrel(id) && m_calo_id->is_tile_positive(id) ) noise[2][module][idSubHash-(12*module+12*64+23*64+22*64)] = 3*cell_noise;
118 
119  }
120 
121  // Barrel C-side
122 
123  int i=0;
124  for(int j=0;j<64;j++) {
125  for(int k=0;k<20;k++) {
126  DSP[i][j][k] = (int)round(2*noise[i][j][k]);
127  }
128  }
129 
130  // Barrel A-side (include D0 cell)
131 
132  i=1;
133  for(int j=0;j<64;j++) {
134  for(int k=0;k<2;k++) {
135  DSP[i][j][k] = (int)round(2*noise[i][j][k]);
136  }
137  int k=2;
138  DSP[i][j][k] = (int)round(2*noise[0][j][k]);
139  for(int k=2;k<19;k++) {
140  DSP[i][j][k+1] = (int)round(2*noise[i][j][k]);
141  }
142  }
143 
144  // Ext Barrels
145  for(int i=2;i<4;i++) {
146  for(int j=0;j<64;j++) {
147  for(int k=0;k<11;k++) {
148  DSP[i][j][k] = (int)round(2*noise[i][j][k]);
149  }
150  }
151  }
152 
153  for(int i=0;i<2;i++) {
154 
155  for(int j=0;j<64;j++) {
156 
157  int k=0;
158 
159  // D cells
160 
161  Thr[i][j][k]=DSP[i][j][2];k++; Thr[i][j][k]=DSP[i][j][7];k++; Thr[i][j][k]=DSP[i][j][12];k++; Thr[i][j][k]=DSP[i][j][17];k++;
162  Thr[i][j][k]=2*Thr_barrel[2];k++; Thr[i][j][k]=2*Thr_barrel[7];k++; Thr[i][j][k]=2*Thr_barrel[12];k++; Thr[i][j][k]=2*Thr_barrel[17];k++;
163 
164  // BC cells
165 
166  Thr[i][j][k]=DSP[i][j][1];k++; Thr[i][j][k]=DSP[i][j][4];k++; Thr[i][j][k]=DSP[i][j][6];k++; Thr[i][j][k]=DSP[i][j][9];k++;
167  Thr[i][j][k]=DSP[i][j][11];k++; Thr[i][j][k]=DSP[i][j][14];k++; Thr[i][j][k]=DSP[i][j][16];k++; Thr[i][j][k]=DSP[i][j][19];k++;
168  Thr[i][j][k]=2*Thr_barrel[1];k++; Thr[i][j][k]=2*Thr_barrel[4];k++; Thr[i][j][k]=2*Thr_barrel[6];k++; Thr[i][j][k]=2*Thr_barrel[9];k++;
169  Thr[i][j][k]=2*Thr_barrel[11];k++; Thr[i][j][k]=2*Thr_barrel[14];k++; Thr[i][j][k]=2*Thr_barrel[16];k++; Thr[i][j][k]=2*Thr_barrel[19];k++;
170 
171  // A cells
172 
173  Thr[i][j][k]=DSP[i][j][0];k++; Thr[i][j][k]=DSP[i][j][3];k++; Thr[i][j][k]=DSP[i][j][5];k++; Thr[i][j][k]=DSP[i][j][8];k++;
174  Thr[i][j][k]=DSP[i][j][10];k++; Thr[i][j][k]=DSP[i][j][13];k++; Thr[i][j][k]=DSP[i][j][15];k++; Thr[i][j][k]=DSP[i][j][18];k++;
175  Thr[i][j][k]=2*Thr_barrel[0];k++; Thr[i][j][k]=2*Thr_barrel[3];k++; Thr[i][j][k]=2*Thr_barrel[5];k++; Thr[i][j][k]=2*Thr_barrel[8];k++;
176  Thr[i][j][k]=2*Thr_barrel[10];k++; Thr[i][j][k]=2*Thr_barrel[13];k++; Thr[i][j][k]=2*Thr_barrel[15];k++; Thr[i][j][k]=2*Thr_barrel[18];k++;
177 
178  }
179 
180  }
181 
182  for(int i=2;i<4;i++) {
183 
184  for(int j=0;j<64;j++) {
185 
186  int k=0;
187 
188  // D cells
189 
190  Thr[i][j][k]=DSP[i][j][1];k++; Thr[i][j][k]=DSP[i][j][6];k++;
191  Thr[i][j][k]=2*Thr_extbarrel[1];k++; Thr[i][j][k]=2*Thr_extbarrel[6];k++;
192 
193  // BC cells
194 
195  Thr[i][j][k]=DSP[i][j][0];k++; Thr[i][j][k]=DSP[i][j][3];k++; Thr[i][j][k]=DSP[i][j][5];k++; Thr[i][j][k]=DSP[i][j][8];k++; Thr[i][j][k]=DSP[i][j][10];k++;
196  Thr[i][j][k]=2*Thr_extbarrel[0];k++; Thr[i][j][k]=2*Thr_extbarrel[3];k++; Thr[i][j][k]=2*Thr_extbarrel[5];k++; Thr[i][j][k]=2*Thr_extbarrel[8];k++; Thr[i][j][k]=2*Thr_extbarrel[10];k++;
197 
198  // A cells
199 
200  Thr[i][j][k]=DSP[i][j][2];k++; Thr[i][j][k]=DSP[i][j][4];k++; Thr[i][j][k]=DSP[i][j][7];k++; Thr[i][j][k]=DSP[i][j][9];k++;
201  Thr[i][j][k]=2*Thr_extbarrel[2];k++; Thr[i][j][k]=2*Thr_extbarrel[4];k++; Thr[i][j][k]=2*Thr_extbarrel[7];k++; Thr[i][j][k]=2*Thr_extbarrel[9];k++;
202 
203  }
204 
205  }
206 
207  for(int i=0;i<4;i++) {
208 
209  for(int j=0;j<64;j++) {
210 
211  msg(MSG::INFO)
212  << "TileMuId 0x" << std::hex << (i+1)*0x100+j << std::dec << " 0";
213  *fl << "TileMuId 0x" << std::hex << (i+1)*0x100+j << std::dec << " 0";
214 
215  for(int k=0;k<40;k++) {
216 
217  msg(MSG::INFO)
218  << " " << Thr[i][j][k];
219  *fl << " " << Thr[i][j][k];
220 
221  }
222 
223  msg(MSG::INFO) << endmsg;
224  *fl << endl;
225 
226  }
227 
228  }
229 
230  // Close ASCII file
231  fl->close();
232 
233  return StatusCode::SUCCESS;
234 }
235 
236 
237 
239 {
240  ATH_MSG_INFO ( "in finalize()" );
241  return StatusCode::SUCCESS;
242 }
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
TileMuId2DBAlg::finalize
virtual StatusCode finalize() override
Definition: TileMuId2DBAlg.cxx:238
CaloIDHelper::NOT_VALID
@ NOT_VALID
Definition: CaloIDHelper.h:36
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
TileMuId2DBAlg::m_calo_id
const CaloCell_ID * m_calo_id
Definition: TileMuId2DBAlg.h:40
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:110
MuonGM::round
float round(const float toRound, const unsigned int decimals)
Definition: Mdt.cxx:27
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:71
CaloNoise::getNoise
float getNoise(const IdentifierHash h, const int gain) const
Accessor by IdentifierHash and gain.
Definition: CaloNoise.h:34
ReadCondHandle.h
CaloDetDescrManager.h
Definition of CaloDetDescrManager.
CaloCell_ID.h
AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
CaloGain::TILEHIGHHIGH
@ TILEHIGHHIGH
Definition: CaloGain.h:15
python.PyAthena.module
module
Definition: PyAthena.py:131
TileMuId2DBAlg::initialize
virtual StatusCode initialize() override
Definition: TileMuId2DBAlg.cxx:48
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
CaloIdManager
This class initializes the Calo (LAr and Tile) offline identifiers.
Definition: CaloIdManager.h:45
lumiFormat.i
int i
Definition: lumiFormat.py:85
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
AthAlgorithm
Definition: AthAlgorithm.h:47
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
TileMuId2DBAlg::execute
virtual StatusCode execute() override
Definition: TileMuId2DBAlg.cxx:60
CaloIdManager::getCaloCell_ID
const CaloCell_ID * getCaloCell_ID(void) const
Access to IdHelper.
Definition: CaloIdManager.cxx:63
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
CaloGain::CaloGain
CaloGain
Definition: CaloGain.h:11
AthCommonMsg< Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
TileMuId2DBAlg::m_totalNoiseKey
SG::ReadCondHandleKey< CaloNoise > m_totalNoiseKey
Definition: TileMuId2DBAlg.h:43
CaloIdManager.h
TileMuId2DBAlg.h
CaloGain.h
TileMuId2DBAlg::TileMuId2DBAlg
TileMuId2DBAlg(const std::string &name, ISvcLocator *pSvcLocator)
Definition: TileMuId2DBAlg.cxx:38
WriteCellNoiseToCool.noise
noise
Definition: WriteCellNoiseToCool.py:380
fitman.k
k
Definition: fitman.py:528
Identifier
Definition: IdentifierFieldParser.cxx:14