ATLAS Offline Software
TileMuId2DBAlg.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2022 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"
27 #include "CaloIdentifier/CaloGain.h"
28 #include "StoreGate/ReadCondHandle.h"
29 
30 #include <fstream>
31 
32 using namespace std;
33 
34 
35 TileMuId2DBAlg::TileMuId2DBAlg(const std::string& name, ISvcLocator* pSvcLocator) :
36  AthAlgorithm(name,pSvcLocator),
37  m_calo_id(nullptr)
38 {
39 }
40 
41 
42 
43 TileMuId2DBAlg::~TileMuId2DBAlg()
44 {
45 }
46 
47 
48 
49 StatusCode TileMuId2DBAlg::initialize()
50 {
51  const CaloIdManager* caloIdMgr = nullptr;
52  ATH_CHECK( detStore()->retrieve( caloIdMgr ) );
53  m_calo_id = caloIdMgr->getCaloCell_ID();
54 
55  ATH_CHECK( m_totalNoiseKey.initialize() );
56  return StatusCode::SUCCESS;
57 }
58 
59 
60 
61 StatusCode TileMuId2DBAlg::execute()
62 {
63  // Open ASCII file
64  string TileMuIdFile = "TileMuId_thresholds.dat";
65  fstream *fl = new fstream(TileMuIdFile.c_str(), fstream::app| fstream::out);
66  if (fl->is_open())
67  ATH_MSG_INFO ( " TileMuId file open" );
68  else
69  ATH_MSG_INFO ( " TileMuId file didn't open succesfully" );
70 
71  float noise[4][64][24]; memset(noise,0,sizeof(noise));
72  int DSP[4][64][40]; memset(DSP,0,sizeof(DSP));
73  int Thr[4][64][40]; memset(Thr,0,sizeof(Thr));
74 
75  // A1, BC1, D0, A2, BC2, A3, BC3, D1, A4, BC4, A5, BC5, D2, A6, BC6, A7, BC7, D3, A8, BC8, A9, BC9, A10
76  int Thr_barrel[23] = {
77  1350, 2550, 1590, 960, 1980, 870, 1770, 1110, 750, 1890, 840, 1860, 1050, 840, 1800, 930, 1890, 1050, 840, 1860, 960, 1110, 900
78  };
79 
80  // B11, D5, A12, B12, A13, B13, D6, A14, B14, A15, B15, A16
81  int Thr_extbarrel[12] = {
82  1050, 2100, 210, 1380, 1140, 1440, 2370, 1230, 1500, 1380, 1680, 1680
83  };
84 
85  IdentifierHash caloCellMin=0;
86  IdentifierHash caloCellMax=0;
87  m_calo_id->calo_cell_hash_range(3, caloCellMin, caloCellMax);
88 
89  ATH_MSG_INFO ( "caloCellMin: " << caloCellMin );
90  ATH_MSG_INFO ( "caloCellMax: " << caloCellMax );
91  ATH_MSG_INFO ( "Start loop over TileCal cells " << caloCellMax-caloCellMin );
92 
93  SG::ReadCondHandle<CaloNoise> totalNoise (m_totalNoiseKey);
94 
95  for (unsigned int i=caloCellMin;i<caloCellMax;i++) {
96 
97  IdentifierHash idHash = i;
98  Identifier id = m_calo_id->cell_id(idHash);
99  int subCalo;
100  IdentifierHash idSubHash = m_calo_id->subcalo_cell_hash (idHash, subCalo);
101 
102  int module = m_calo_id->module(id);
103 
104  CaloGain::CaloGain gain=CaloGain::TILEHIGHHIGH;
105 
106  float cell_noise = totalNoise->getNoise(id,gain);
107 
108  if( m_calo_id->is_tile_barrel(id) && m_calo_id->is_tile_negative(id) ) noise[1][module][idSubHash-22*module] = 3*cell_noise;
109 
110  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;
111 
112  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;
113 
114  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;
115 
116  }
117 
118  // Barrel C-side
119 
120  int i=0;
121  for(int j=0;j<64;j++) {
122  for(int k=0;k<20;k++) {
123  DSP[i][j][k] = (int)round(2*noise[i][j][k]);
124  }
125  }
126 
127  // Barrel A-side (include D0 cell)
128 
129  i=1;
130  for(int j=0;j<64;j++) {
131  for(int k=0;k<2;k++) {
132  DSP[i][j][k] = (int)round(2*noise[i][j][k]);
133  }
134  int k=2;
135  DSP[i][j][k] = (int)round(2*noise[0][j][k]);
136  for(int k=2;k<19;k++) {
137  DSP[i][j][k+1] = (int)round(2*noise[i][j][k]);
138  }
139  }
140 
141  // Ext Barrels
142  for(int i=2;i<4;i++) {
143  for(int j=0;j<64;j++) {
144  for(int k=0;k<11;k++) {
145  DSP[i][j][k] = (int)round(2*noise[i][j][k]);
146  }
147  }
148  }
149 
150  for(int i=0;i<2;i++) {
151 
152  for(int j=0;j<64;j++) {
153 
154  int k=0;
155 
156  // D cells
157 
158  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++;
159  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++;
160 
161  // BC cells
162 
163  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++;
164  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++;
165  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++;
166  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++;
167 
168  // A cells
169 
170  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++;
171  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++;
172  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++;
173  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++;
174 
175  }
176 
177  }
178 
179  for(int i=2;i<4;i++) {
180 
181  for(int j=0;j<64;j++) {
182 
183  int k=0;
184 
185  // D cells
186 
187  Thr[i][j][k]=DSP[i][j][1];k++; Thr[i][j][k]=DSP[i][j][6];k++;
188  Thr[i][j][k]=2*Thr_extbarrel[1];k++; Thr[i][j][k]=2*Thr_extbarrel[6];k++;
189 
190  // BC cells
191 
192  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++;
193  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++;
194 
195  // A cells
196 
197  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++;
198  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++;
199 
200  }
201 
202  }
203 
204  for(int i=0;i<4;i++) {
205 
206  for(int j=0;j<64;j++) {
207 
208  msg(MSG::INFO)
209  << "TileMuId 0x" << std::hex << (i+1)*0x100+j << std::dec << " 0";
210  *fl << "TileMuId 0x" << std::hex << (i+1)*0x100+j << std::dec << " 0";
211 
212  for(int k=0;k<40;k++) {
213 
214  msg(MSG::INFO)
215  << " " << Thr[i][j][k];
216  *fl << " " << Thr[i][j][k];
217 
218  }
219 
220  msg(MSG::INFO) << endmsg;
221  *fl << endl;
222 
223  }
224 
225  }
226 
227  // Close ASCII file
228  fl->close();
229 
230  return StatusCode::SUCCESS;
231 }
232 
233 
234 
235 StatusCode TileMuId2DBAlg::finalize()
236 {
237  ATH_MSG_INFO ( "in finalize()" );
238  return StatusCode::SUCCESS;
239 }
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
TileMuId2DBAlg::finalize
virtual StatusCode finalize() override
Definition: TileMuId2DBAlg.cxx:235
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:44
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
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:134
TileMuId2DBAlg::initialize
virtual StatusCode initialize() override
Definition: TileMuId2DBAlg.cxx:49
CaloIdManager
This class initializes the Calo (LAr and Tile) offline identifiers.
Definition: CaloIdManager.h:45
TileMuId2DBAlg::~TileMuId2DBAlg
virtual ~TileMuId2DBAlg()
Definition: TileMuId2DBAlg.cxx:43
lumiFormat.i
int i
Definition: lumiFormat.py:92
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:195
TileMuId2DBAlg::execute
virtual StatusCode execute() override
Definition: TileMuId2DBAlg.cxx:61
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:47
TileMuId2DBAlg.h
CaloGain.h
TileMuId2DBAlg::TileMuId2DBAlg
TileMuId2DBAlg(const std::string &name, ISvcLocator *pSvcLocator)
Definition: TileMuId2DBAlg.cxx:35
WriteCellNoiseToCool.noise
noise
Definition: WriteCellNoiseToCool.py:380
fitman.k
k
Definition: fitman.py:528
Generated on Tue Jul 2 2024 21:29:04 for ATLAS Offline Software by   doxygen 1.8.18