ATLAS Offline Software
Loading...
Searching...
No Matches
FixLArElecCalib.cxx
Go to the documentation of this file.
1/*
2 Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
3*/
4
80
81
82#include "FixLArElecCalib.h"
83#include "Gaudi/Property.h"
84#include "GaudiKernel/IToolSvc.h"
85
86#include "CaloIdentifier/CaloCell_SuperCell_ID.h"
87#include "CaloIdentifier/LArEM_ID.h"
88#include "LArIdentifier/LArOnlineID.h"
89#include "LArIdentifier/LArOnline_SuperCellID.h"
90#include "StoreGate/StoreGateSvc.h"
91
92#include "LArRawConditions/LArDAC2uAMC.h"
93#include "LArRawConditions/LArShape32MC.h"
94#include "LArRawConditions/LAruA2MeVMC.h"
95#include "LArRawConditions/LArfSamplMC.h"
96#include "LArRawConditions/LArMinBiasMC.h"
97#include "LArRawConditions/LArMinBiasAverageMC.h"
98#include "LArRawConditions/LArNoiseMC.h"
99#include "LArRawConditions/LArRampMC.h"
100#include "LArRawConditions/LArAutoCorrMC.h"
101
102#include "CaloDetDescr/ICaloSuperCellIDTool.h"
103
104
105#include "TTree.h"
106#include "TFile.h"
107
108#include "AthenaPoolUtilities/AthenaAttributeList.h"
109#include "CoralBase/Blob.h"
110
111#include <fstream>
112#include <cstdint>
113
114
115FixLArElecCalib::FixLArElecCalib(const std::string& name, ISvcLocator* pSvcLocator) :
116 AthAlgorithm(name,pSvcLocator),
117 m_em_idhelper(nullptr),
118 m_hec_idhelper(nullptr),
119 m_fcal_idhelper(nullptr),
120 m_online_idhelper(nullptr),
121 m_sem_idhelper(nullptr),
122 m_shec_idhelper(nullptr),
123 m_sonline_idhelper(nullptr),
124 m_scell_idhelper(nullptr)
125{
126
127}
128
129StatusCode FixLArElecCalib::initialize() {
130 ATH_MSG_INFO ( " in initialize " );
131
132 ATH_CHECK( detStore()->retrieve(m_em_idhelper) );
133 ATH_CHECK( detStore()->retrieve(m_hec_idhelper) );
134 ATH_CHECK( detStore()->retrieve(m_fcal_idhelper) );
135 ATH_CHECK( detStore()->retrieve(m_sem_idhelper) );
136 ATH_CHECK( detStore()->retrieve(m_shec_idhelper) );
137 ATH_CHECK( detStore()->retrieve(m_online_idhelper) );
138 ATH_CHECK( detStore()->retrieve(m_sonline_idhelper) );
139 ATH_CHECK( detStore()->retrieve(m_scell_idhelper) );
140
141 ATH_CHECK( m_cablingKey.initialize() );
142 ATH_CHECK( m_CLKey.initialize() );
143
144 return StatusCode::SUCCESS;
145}
146
147StatusCode FixLArElecCalib::execute(const EventContext& ctx) {
148
149 SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKey, ctx};
150 const LArOnOffIdMapping* cabling{*cablingHdl};
151 if(!cabling) {
152 ATH_MSG_WARNING( "Do not have cabling mapping from key " << m_cablingKey.key() );
153 }
154 if(m_fixFlag==13)
155 return fix13(cabling);
156
157 return StatusCode::SUCCESS;
158}
159
160StatusCode FixLArElecCalib::stop ATLAS_NOT_THREAD_SAFE () {
161
162 ATH_MSG_INFO ( " in stop " );
163
164 const EventContext& ctx = Gaudi::Hive::currentContext();
165
166 SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKey, ctx};
167 const LArOnOffIdMapping* cabling{*cablingHdl};
168 if(!cabling) {
169 ATH_MSG_ERROR( "Do not have cabling mapping from key " << m_cablingKey.key() );
170 return StatusCode::FAILURE;
171 }
172 SG::ReadCondHandle<LArCalibLineMapping> clHdl{m_CLKey, ctx};
173 const LArCalibLineMapping *clCont {*clHdl};
174 if(!clCont) {
175 ATH_MSG_ERROR( "Do not have calib line mapping !!!" );
176 return StatusCode::FAILURE;
177 }
178
179
180 if(m_fixFlag==1)
181 return fix1(cabling);
182 if(m_fixFlag==2)
183 return fix2(cabling);
184 if(m_fixFlag==3)
185 return fix3(cabling);
186 if(m_fixFlag==4)
187 return fix4(cabling);
188 if(m_fixFlag==5)
189 return fix5(cabling);
190 if(m_fixFlag==6)
191 return fix6(cabling);
192 if(m_fixFlag==7)
193 return fix7(cabling);
194 if(m_fixFlag==8)
195 return fix8(cabling);
196 if(m_fixFlag==9)
197 return fix9(cabling);
198 if(m_fixFlag==10)
199 return fix10(cabling);
200 if(m_fixFlag==11)
201 return fix11(cabling);
202 if(m_fixFlag==12)
203 return fix12(cabling);
204 if(m_fixFlag==13)
205 return fix13(cabling);
206 if(m_fixFlag==14)
207 return fix14(cabling);
208 if(m_fixFlag==15)
209 return fix15();
210 if(m_fixFlag==16)
211 return fix16();
212 if(m_fixFlag==17)
213 return fix17(cabling);
214 if(m_fixFlag==18)
215 return fix18(clCont);
216
217 return StatusCode::SUCCESS;
218
219}
220
221StatusCode FixLArElecCalib::fix1(const LArOnOffIdMapping *cabling) {
222
223 ATH_MSG_INFO ( " in fix1() " );
224
225 // Fix1 is for updating the EM DAC2uA, assuming symmetry.
226 // Input should be MC Conditions data with DetDescrVersion=ATLAS-DC3-05
227
228 // Pointer to StoreGate
229 const LArEM_ID* em_idhelper = nullptr;
230 ATH_CHECK( detStore()->retrieve(em_idhelper) );
231
232 const LArOnlineID* online_idhelper = nullptr;
233 ATH_CHECK( detStore()->retrieve(online_idhelper) );
234
235 // retrieve DetDescrManager
236 SmartIF<IToolSvc> toolSvc{Gaudi::svcLocator()->service("ToolSvc")};
237 ATH_CHECK(toolSvc.isValid());
238
239 LArDAC2uAMC * dac2ua = nullptr;
240 ATH_CHECK( detStore()->retrieve(dac2ua) );
241
242 // read in the file
243
244 std::ifstream infile("barrel_dac2ua_oct06.txt") ;
245 if(! infile.good() )
246 {
247 ATH_MSG_ERROR(" fail to open file ");
248 return StatusCode::FAILURE;
249 }
250
251
252 int det,samp,reg,eta;
253 float value ;
254 int n = 0;
255 while ( infile>>det>>samp>>reg>>eta>>value )
256 {
257 ++n;
258 ATH_MSG_DEBUG(" det,samp,reg,eta,value="
259 <<det<<" "
260 <<samp<<" "
261 <<reg<<" "
262 <<eta<<" "
263 <<value<<" " );
264
265 Identifier id ;
266 if ( det==1 && samp==1 && reg==0 && eta==0 ){
267 // eta=0 for strip, not connected, but keep it
268 // Removed disconnected channels: 03/2016 RDS
269 // ATH_MSG_DEBUG(" disconnected strip ");
270 // id = em_idhelper->disc_channel_id(det,samp,reg,eta,0);
271 }else
272 id = em_idhelper->channel_id(det,samp,reg,eta,0);
273
274 HWIdentifier hid = cabling->createSignalChannelID(id);
275 LArDAC2uAComplete::LArCondObj & t = dac2ua->get(hid,0);
276 ATH_MSG_DEBUG(" online id = "<<online_idhelper->print_to_string(hid));
277
278 if( t.isEmpty() )
279 {
280 ATH_MSG_WARNING(" No existing conditions data " );
281 continue ;
282 }
283 ATH_MSG_DEBUG(" Old DAC2uA = "<< t.m_data<< " " );
284
285 t.m_data = value ;
286
287 const LArDAC2uAComplete::LArCondObj & t3 = dac2ua->get(hid,0);
288 ATH_MSG_DEBUG(" New DAC2uA = "<< t3.m_data << " " );
289
290 }
291
292 ATH_MSG_DEBUG(" Number of entries changes = " <<n );
293 return StatusCode::SUCCESS;
294}
295
296
297StatusCode FixLArElecCalib::fix2(const LArOnOffIdMapping *cabling) {
298
299 ATH_MSG_INFO ( " in fix2() " );
300
301 // Fix2 is for updating the FCAL conditions data after IdFix7
302 // Input should be MC Conditions data with DetDescrVersion=ATLAS-DC3-05
303
304 const LArFCAL_ID* fcal_idhelper = nullptr;
305 ATH_CHECK( detStore()->retrieve(fcal_idhelper) );
306
307 const LArOnlineID* online_idhelper = nullptr;
308 ATH_CHECK( detStore()->retrieve(online_idhelper) );
309
310 // retrieve DetDescrManager
311 SmartIF<IToolSvc> toolSvc{Gaudi::svcLocator()->service("ToolSvc")};
312 ATH_CHECK(toolSvc.isValid());
313
314 LArDAC2uAMC * dac2ua = nullptr;
315 ATH_CHECK( detStore()->retrieve(dac2ua) );
316
317 LAruA2MeVMC * ua2mev = nullptr;
318 ATH_CHECK( detStore()->retrieve(ua2mev) );
319
320 LArRampMC * ramp = nullptr;
321 ATH_CHECK( detStore()->retrieve(ramp) );
322
323 LArShape32MC * shape = nullptr;
324 ATH_CHECK( detStore()->retrieve(shape) );
325
326 LArNoiseMC * noise = nullptr;
327 ATH_CHECK( detStore()->retrieve(noise) );
328
329 LArfSamplMC * fsampl = nullptr;
330 ATH_CHECK( detStore()->retrieve(fsampl) );
331
332 LArMinBiasMC * minbias = nullptr;
333 ATH_CHECK( detStore()->retrieve(minbias) );
334
335 LArAutoCorrMC * ac = nullptr;
336 ATH_CHECK( detStore()->retrieve(ac) );
337
338
339 for( unsigned int gain=0;gain<3;++gain)
340 {
341 // loop over all the old data
342 LArRampMC::ConditionsMapIterator it = ramp->begin(gain);
343 LArRampMC::ConditionsMapIterator it_e = ramp->end(gain);
344
345 int n=0;
346 for (; it!=it_e;++it)
347 {
348 HWIdentifier hid = it.channelId();
349 if( (*it).isEmpty() ) continue;
350 if(cabling->isOnlineConnected(hid)){
351 continue;
352 }else
353 {
354 ATH_MSG_DEBUG(" unconnected channel"
355 << online_idhelper->print_to_string(hid) );
356 ac->get(hid,gain) = LArAutoCorrComplete::LArCondObj();
357 ramp->get(hid,gain) = LArRampComplete::LArCondObj();
358 shape->get(hid,gain) = LArShape32MC::LArCondObj();
359 noise->get(hid,gain) = LArNoiseComplete::LArCondObj();
360 if(gain==0){
361 dac2ua->get(hid,gain) = LArDAC2uAComplete::LArCondObj();
362 ua2mev->get(hid,gain) = LAruA2MeVComplete::LArCondObj();
363 fsampl->get(hid,gain) = LArfSamplComplete::LArCondObj();
364 minbias->get(hid,gain) = LArMinBiasComplete::LArCondObj();
365 }
366 ++n ;
367 }
368
369 }
370 ATH_MSG_DEBUG(" Gain="<<gain<<
371 " Number of entries removed = " <<n );
372 }
373
374
375 HWIdentifier hid_mod[3];
376 hid_mod[0] = online_idhelper->channel_Id(1,1,6,1,33);
377 hid_mod[1] = online_idhelper->channel_Id(1,1,6,10,12);
378 hid_mod[2] = online_idhelper->channel_Id(1,1,6,14,12);
379
380 // loop over all FCAL channels
381 std::vector<Identifier>::const_iterator it= fcal_idhelper->fcal_begin();
382 std::vector<Identifier>::const_iterator it_e= fcal_idhelper->fcal_end();
383 int n = 0;
384 for(;it!=it_e; ++it)
385 {
386 Identifier id = *it;
387 int pn = fcal_idhelper->pos_neg(id);
388 if(pn!=2) continue;
389 int phi = fcal_idhelper->phi(id);
390 if (phi>7) continue;
391
392 int module = fcal_idhelper->module(id)-1;
393
394 HWIdentifier hid = cabling->createSignalChannelID(id);
395
396 for(unsigned int gain = 0;gain<3;++gain){
397
398 LArRampComplete::LArCondObj& rampP = ramp->get(hid,gain) ;
399 if (!rampP.isEmpty()) continue ;
400
401 ATH_MSG_DEBUG(" channel needs repair "
402 << online_idhelper->print_to_string(hid) );
403 ATH_MSG_DEBUG ( fcal_idhelper->print_to_string(id) );
404 ATH_MSG_DEBUG ( "module = "<<module );
405
406 ++n;
407
408 LArRampComplete::LArCondObj ramp_std = ramp->get(hid_mod[module],gain) ;
409 ramp->setPdata(hid,ramp_std,gain);
410
411 LArAutoCorrComplete::LArCondObj ac_std = ac->get(hid_mod[module],gain) ;
412 ac->setPdata(hid,ac_std,gain);
413
414 LArShape32MC::LArCondObj shape_std = shape->get(hid_mod[module],gain) ;
415 shape->setPdata(hid,shape_std,gain);
416
417 LArNoiseComplete::LArCondObj noise_std = noise->get(hid_mod[module],gain) ;
418 noise->setPdata(hid,noise_std,gain);
419
420 if(gain==0){
421
422 LAruA2MeVComplete::LArCondObj ua2mev_std = ua2mev->get(hid_mod[module],gain) ;
423 ua2mev->setPdata(hid,ua2mev_std,gain);
424
425 LArDAC2uAComplete::LArCondObj dac2ua_std = dac2ua->get(hid_mod[module],gain) ;
426 dac2ua->setPdata(hid,dac2ua_std,gain);
427
428 LArfSamplComplete::LArCondObj fsampl_std = fsampl->get(hid_mod[module],gain) ;
429 fsampl->setPdata(hid,fsampl_std,gain);
430
431 LArMinBiasComplete::LArCondObj minbias_std = minbias->get(hid_mod[module],gain) ;
432 minbias->setPdata(hid,minbias_std,gain);
433
434 }
435
436 }
437 }
438
439 ATH_MSG_DEBUG( " Number of entries fixed " <<n );
440 return StatusCode::SUCCESS;
441}
442
443StatusCode FixLArElecCalib::fix3 ATLAS_NOT_THREAD_SAFE (const LArOnOffIdMapping *cabling) {
444
445 ATH_MSG_INFO ( " in fix3() " );
446 std::string filename ;
447
448 // updated for 13.0.20
449 if(m_g4Phys=="QGSP_EMV"){
450 filename = "fsampl_1302_qgsp-emv.txt";
451 }
452 else
453 if( m_g4Phys=="QGSP_BERT"){
454 filename = "fsampl_1303_qgsp-bert.txt";
455 }
456 else {
457 ATH_MSG_ERROR ( " wrong option "<<m_g4Phys );
458 return StatusCode::FAILURE;
459 }
460
461 // Fix3 is for updating the FCAL conditions data after IdFix7
462 // Input should be MC Conditions data with DetDescrVersion=ATLAS-DC3-05
463
464 ATH_CHECK( updateEMfSampl(filename, cabling ) );
465 ATH_CHECK( updateHADfSampl(cabling) );
466 return StatusCode::SUCCESS;
467}
468
469
470StatusCode FixLArElecCalib::fix4 ATLAS_NOT_THREAD_SAFE (const LArOnOffIdMapping *cabling) {
471 ATH_MSG_INFO ( " in fix4() " );
472 return updateEM_DACuAMeV( "dac2ua_ua2mev_rel13.txt", cabling );
473}
474
475StatusCode FixLArElecCalib::updateHADfSampl ATLAS_NOT_THREAD_SAFE (const LArOnOffIdMapping *cabling) {
476
477 float fsampl_fcal1,fsampl_fcal2,fsampl_fcal3;
478 float fsampl_hec1,fsampl_hec2;
479
480 if(m_g4Phys=="QGSP_EMV"){
481 fsampl_hec1=0.04355;
482 fsampl_hec2=0.021775;
483
484
485 // numbers for G4.8.3
486 fsampl_fcal1=0.01366;
487 fsampl_fcal2=0.00854;
488 fsampl_fcal3=0.01107;
489 // numbers for G4.8.2
490 //fsampl_fcal1=0.01412;
491 //fsampl_fcal2=0.00894;
492 //fsampl_fcal3=0.01149;
493 }
494 else
495 if( m_g4Phys=="QGSP_BERT"){
496 fsampl_hec1=0.0447;
497 fsampl_hec2=0.02235;
498
499 // for G4.8.3
500 fsampl_fcal1=0.01591;
501 fsampl_fcal2=0.01144;
502 fsampl_fcal3=0.01405;
503
504 // for G4.8.2
505 //fsampl_fcal1=0.01512 ;
506 //fsampl_fcal2=0.01086;
507 //fsampl_fcal3=0.01352;
508 }
509 else {
510 ATH_MSG_ERROR ( " wrong option "<<m_g4Phys );
511 return StatusCode::FAILURE;
512 }
513
514
515 const LArfSamplMC * fsampl_c = nullptr;
516 ATH_CHECK( detStore()->retrieve(fsampl_c) );
517
518 LArfSamplMC* fsampl = const_cast<LArfSamplMC*>(fsampl_c);
519
520 // loop over all the old data
521 LArfSamplMC::ConditionsMapIterator it = fsampl->begin(0);
522 LArfSamplMC::ConditionsMapIterator it_e = fsampl->end(0);
523 int n_hec=0;
524 int n_fcal=0;
525
526 for (; it!=it_e;++it){
527
528 HWIdentifier hid = it.channelId();
529 if( (*it).isEmpty() ) continue;
530 if(!cabling->isOnlineConnected(hid)){
531 continue;
532 }
533
534 LArfSamplComplete::LArCondObj& t2 = const_cast<LArfSamplComplete::LArCondObj&>(*it);
535
536 Identifier id = cabling->cnvToIdentifier(hid);
537
538
539 if(m_hec_idhelper->is_lar_hec(id)){
540 ATH_MSG_INFO(" HEC Old fsampl = "<< t2.m_fSampl<< " " );
541 int sam = m_hec_idhelper->sampling(id);
542
543 if(sam<=1){
544 t2.m_fSampl = fsampl_hec1;
545 }else
546 {
547 t2.m_fSampl = fsampl_hec2;
548 }
549
550 const LArfSamplComplete::LArCondObj & t3 = fsampl->get(hid,0);
551 ATH_MSG_INFO(" New fSampl = "<< t3.m_fSampl<< " " );
552
553 ++n_hec;
554 }
555 if(m_fcal_idhelper->is_lar_fcal(id)){
556 ATH_MSG_INFO(" FCAL Old fsampl = "<< t2.m_fSampl<< " " );
557 int sam = m_fcal_idhelper->module(id);
558
559 if(sam==1){
560 t2.m_fSampl = fsampl_fcal1;
561 }else
562 if(sam==2){
563 t2.m_fSampl = fsampl_fcal2;
564 }else
565 {
566 t2.m_fSampl = fsampl_fcal3;
567 }
568
569 const LArfSamplComplete::LArCondObj & t3 = fsampl->get(hid,0);
570 ATH_MSG_INFO(" New fSampl = "<< t3.m_fSampl<< " " );
571
572 ++n_fcal;
573 }
574
575 }
576
577 ATH_MSG_INFO(" number of hec cells "<<n_hec);
578 ATH_MSG_INFO(" number of fcal cells "<<n_fcal);
579
580 return StatusCode::SUCCESS;
581}
582
583
584StatusCode FixLArElecCalib::updateEMfSampl ATLAS_NOT_THREAD_SAFE (const std::string& filename, const LArOnOffIdMapping *cabling) {
585
586 ATH_MSG_INFO ( " in updateEMfSampl() " );
587
588 // this method updates the EM fSample, assuming symmetry.
589 // input is the text file.
590
591 const LArfSamplMC * fsampl_c = nullptr;
592 ATH_CHECK( detStore()->retrieve(fsampl_c) );
593 LArfSamplMC* fsampl = const_cast<LArfSamplMC*>(fsampl_c);
594
595 // read in the file
596
597 ATH_MSG_INFO(" opening file "<< filename );
598 std::ifstream infile( filename);
599 if(! infile.good() )
600 {
601 ATH_MSG_ERROR(" fail to open file ");
602 return StatusCode::FAILURE;
603 }
604 int det,samp,reg,eta;
605 float value ;
606 int n = 0;
607 while ( infile>>det>>samp>>reg>>eta>>value )
608 {
609 ++n;
610 ATH_MSG_INFO(" det,samp,reg,eta,value="
611 <<det<<" "
612 <<samp<<" "
613 <<reg<<" "
614 <<eta<<" "
615 <<value<<" " );
616
617 Identifier id ;
618 if ( det==1 && samp==1 && reg==0 && eta==0 ){
619 // eta=0 for strip, not connected, but keep it
620 // Removed disconnected channels: 03/2016 RDS
621 // ATH_MSG_INFO(" disconnected strip ");
622 // id = m_em_idhelper->disc_channel_id(det,samp,reg,eta,0);
623 }else
624 id = m_em_idhelper->channel_id(det,samp,reg,eta,0);
625
626 HWIdentifier hid = cabling->createSignalChannelID(id);
627 const LArfSamplComplete::LArCondObj & t = fsampl->get(hid,0);
628 std::string id_str = m_online_idhelper->print_to_string(hid);
629 ATH_MSG_INFO(" online id = "<<id_str);
630
631 if( t.isEmpty() )
632 {
633 ATH_MSG_ERROR(" No existing conditions data " );
634 ATH_MSG_ERROR( m_em_idhelper->print_to_string(id) );
635 // return StatusCode::FAILURE ;
636 continue ;
637 }
638 ATH_MSG_INFO(" Old fsampl = "<< t.m_fSampl<< " " );
639
640 LArfSamplComplete::LArCondObj& t2 = const_cast<LArfSamplComplete::LArCondObj&>(t);
641 t2.m_fSampl = value ;
642
643 const LArfSamplComplete::LArCondObj & t3 = fsampl->get(hid,0);
644 ATH_MSG_INFO(" New fSampl = "<< t3.m_fSampl<< " " );
645 }
646
647 ATH_MSG_INFO(" Number of entries changes = " <<n );
648 return StatusCode::SUCCESS;
649}
650
651
652StatusCode FixLArElecCalib::updateEM_DACuAMeV ATLAS_NOT_THREAD_SAFE (const std::string& filename, const LArOnOffIdMapping *cabling) {
653 // read in the file
654
655 const LArDAC2uAMC * dac2ua_c = nullptr;
656 ATH_CHECK( detStore()->retrieve(dac2ua_c) );
657 LArDAC2uAMC* dac2uaMC = const_cast<LArDAC2uAMC*>(dac2ua_c);
658
659 const LAruA2MeVMC * ua2mev_c = nullptr;
660 ATH_CHECK( detStore()->retrieve(ua2mev_c) );
661 LAruA2MeVMC* ua2mevMC = const_cast<LAruA2MeVMC*>(ua2mev_c);
662
663 std::ifstream infile(filename) ;
664
665 if(! infile.good() )
666 {
667 ATH_MSG_ERROR(" fail to open file ");
668 return StatusCode::FAILURE;
669 }
670
671
672 char s[200];
673 infile.getline(s,200);
674 ATH_MSG_INFO(" first line of the file "<<s);
675
676 int det,samp,reg,eta;
677 int n = 0;
678 float dac2ua0, ua2mev0,attenuation,dac2ua,ua2mev;
679 while ( infile>>det>>samp>>reg>>eta>>
680 dac2ua0>>ua2mev0>>attenuation>>dac2ua>>ua2mev )
681 {
682 ++n;
683 ATH_MSG_DEBUG(" det,samp,reg,eta,values="
684 <<det<<" "
685 <<samp<<" "
686 <<reg<<" "
687 <<eta<<" "
688 <<dac2ua<<" "
689 <<ua2mev<<" " );
690
691 Identifier id ;
692 if ( det==1 && samp==1 && reg==0 && eta==0 ){
693 // eta=0 for strip, not connected, but keep it
694 // Removed disconnected channels: 03/2016 RDS
695 // ATH_MSG_DEBUG(" disconnected strip ");
696 // id = m_em_idhelper->disc_channel_id(det,samp,reg,eta,0);
697 }else
698 id = m_em_idhelper->channel_id(det,samp,reg,eta,0);
699
700 HWIdentifier hid = cabling->createSignalChannelID(id);
701
702 const LArDAC2uAComplete::LArCondObj & t = dac2uaMC->get(hid,0);
703 std::string id_str = m_online_idhelper->print_to_string(hid);
704 std::string id_str_off = m_em_idhelper->print_to_string(id);
705 ATH_MSG_DEBUG(" online id = "<<id_str);
706 ATH_MSG_DEBUG(" offline id = "<<id_str_off);
707
708 if( t.isEmpty() )
709 {
710 ATH_MSG_WARNING(" No existing conditions data " );
711 continue ;
712 }
713 ATH_MSG_DEBUG(" Old DAC2uA = "<< t.m_data<< " " );
714
715 LArDAC2uAComplete::LArCondObj& t2 = const_cast<LArDAC2uAComplete::LArCondObj&>(t);
716 t2.m_data= dac2ua ;
717
718 const LArDAC2uAComplete::LArCondObj & t3 = dac2uaMC->get(hid,0);
719 ATH_MSG_DEBUG(" New DAC2uA = "<< t3.m_data<< " " );
720
721 /**************************/
722
723 const LAruA2MeVComplete::LArCondObj & u = ua2mevMC->get(hid,0);
724
725 if( u.isEmpty() )
726 {
727 ATH_MSG_ERROR(" No existing conditions data " );
728 // return StatusCode::FAILURE ;
729 continue ;
730 }
731 ATH_MSG_DEBUG(" Old uA2MeV = "<< u.m_data<< " " );
732
733 LAruA2MeVComplete::LArCondObj& u2 = const_cast<LAruA2MeVComplete::LArCondObj&>(u);
734 u2.m_data = ua2mev ;
735
736 const LAruA2MeVComplete::LArCondObj & u3 = ua2mevMC->get(hid,0);
737 ATH_MSG_DEBUG(" New uA2MeV = "<< u3.m_data<< " " );
738
739 }
740
741 ATH_MSG_DEBUG(" Number of entries changes = " <<n );
742 return StatusCode::SUCCESS;
743}
744
745
746
747StatusCode FixLArElecCalib::fix5 ATLAS_NOT_THREAD_SAFE (const LArOnOffIdMapping *cabling) {
748
749 ATH_MSG_INFO ( " in fix5() " );
750
751 // update EM
752 ATH_CHECK( updateMinBias("mbrms_em_rel12.txt", cabling) );
753 ATH_CHECK( updateMinBias("mbrms_hec_rel12.txt", cabling) );
754
755 // Fix5 is for updating the FCAL noise and MinBiasRMS data using
756 // Sven Menke's file.
757
758 const LArNoiseMC * noise_c = nullptr;
759 ATH_CHECK( detStore()->retrieve(noise_c) );
760 LArNoiseMC* noise = const_cast<LArNoiseMC*>(noise_c);
761
762 const LArMinBiasMC * minbias_c = nullptr;
763 ATH_CHECK( detStore()->retrieve(minbias_c) );
764 LArMinBiasMC* minbias = const_cast<LArMinBiasMC*>(minbias_c);
765
766 int ndisc=0;
767 int nconn=0;
768 for( unsigned int gain=0;gain<3;++gain)
769 {
770 // loop over all the old data
771 LArNoiseMC::ConditionsMapIterator it = noise->begin(gain);
772 LArNoiseMC::ConditionsMapIterator it_e = noise->end(gain);
773
774 for (; it!=it_e;++it)
775 {
776 HWIdentifier hid = it.channelId();
777 if( (*it).isEmpty() ) continue;
778
779 Identifier id = cabling->cnvToIdentifier(hid);
780 if(!m_fcal_idhelper->is_lar_fcal(id)) continue;
781
782 if(cabling->isOnlineConnected(hid)){
783 ++nconn;
784 }else {
785 ATH_MSG_ERROR(" unconnected channel"
786 << m_online_idhelper->print_to_string(hid) );
787
788 ++ndisc ;
789 }
790
791 }
792
793 ATH_MSG_INFO(" Gain="<<gain<<
794 " Number of connected and disconnected = " <<nconn<<" " <<ndisc );
795
796 }
797
798
799 int n=0;
800
801 std::string filename("FCal_noise_minbias.txt");
802
803 std::ifstream infile(filename ) ;
804
805 if(! infile.good() )
806 {
807 ATH_MSG_ERROR(" fail to open file "<<filename);
808 return StatusCode::FAILURE;
809 }
810
811
812 char s[200];
813
814 ATH_MSG_INFO("Opened FCAL file");
815 for(int i = 0;i<11;++i){
816 infile.getline(s,200);
817 ATH_MSG_INFO(s);
818 }
819
820 std::string str_id;
821
822 float vol,noise_p,noise_h, noise_m,noise_l;
823
824 while ( infile>>str_id >>vol>>noise_p>>noise_h>>noise_m>>noise_l )
825 {
826 const char* ch_id = str_id.c_str();
827 if(ch_id[0] != 'A') {
828 ATH_MSG_DEBUG(" skipping string"<<str_id);
829 continue;
830 }
831
832 int mod,phi,eta;
833 std::sscanf(ch_id, "A%d.%d.%d", &mod,&phi,&eta);
834 if(phi>7){
835 ATH_MSG_DEBUG(" skipping phi"<<str_id<<" phi="<<phi);
836 continue;
837 }
838 ++n;
839
840 ATH_MSG_INFO(" Setting channel "<<str_id);
841 Identifier id = m_fcal_idhelper->channel_id(2,mod,eta,phi);
842 HWIdentifier hid = cabling->createSignalChannelID(id);
843
844 const LArMinBiasComplete::LArCondObj& t1 = minbias->get(hid,0) ;
845 LArMinBiasComplete::LArCondObj& t2 = const_cast<LArMinBiasComplete::LArCondObj&>(t1);
846 ATH_MSG_INFO(" minBiasRMS, old new "<<t2.m_MinBiasRMS<<" " <<noise_p);
847 t2.m_MinBiasRMS = noise_p;
848
849 LArNoiseComplete::LArCondObj& u0 = const_cast<LArNoiseComplete::LArCondObj&>(noise->get(hid,0));
850 if(u0.m_Noise!=noise_h)
851 ATH_MSG_INFO(" noise, old new "<<u0.m_Noise<<" " <<noise_h);
852 u0.m_Noise=noise_h;
853
854 LArNoiseComplete::LArCondObj& u1 = const_cast<LArNoiseComplete::LArCondObj&>(noise->get(hid,1));
855 if(u1.m_Noise!=noise_m)
856 ATH_MSG_INFO(" noise, old new "<<u1.m_Noise<<" " <<noise_m);
857 u1.m_Noise=noise_m;
858
859 LArNoiseComplete::LArCondObj& u2 = const_cast<LArNoiseComplete::LArCondObj&>(noise->get(hid,2));
860 if(u2.m_Noise!=noise_l)
861 ATH_MSG_INFO(" noise, old new "<<u2.m_Noise<<" " <<noise_l);
862 u2.m_Noise=noise_l;
863
864 }
865
866 ATH_MSG_INFO(" number of channels in file ="<<n);
867
868 return StatusCode::SUCCESS;
869}
870
871StatusCode FixLArElecCalib::updateMinBias ATLAS_NOT_THREAD_SAFE (const std::string& filename, const LArOnOffIdMapping *cabling) {
872
873 ATH_MSG_INFO ( " in updateMinBias(), filename = "<<filename );
874
875 // this method updates the EM MinBias
876 // input is the text file.
877
878 const LArMinBiasMC * minbias_c = nullptr;
879 ATH_CHECK( detStore()->retrieve(minbias_c) );
880 LArMinBiasMC* minbias = const_cast<LArMinBiasMC*>(minbias_c);
881
882 // read in the file
883
884 ATH_MSG_INFO(" opening file "<< filename );
885 std::ifstream infile( filename);
886 if(! infile.good() )
887 {
888 ATH_MSG_ERROR(" fail to open file ");
889 return StatusCode::FAILURE;
890 }
891
892 int lar,tp,det,samp,reg,eta,phi;
893 //tp=1 for EM, 2=HEC
894
895 float value ;
896 int n = 0;
897 while ( infile>>lar>>tp>>det>>samp>>reg>>eta>>phi>>value )
898 {
899 ++n;
900 ATH_MSG_INFO(" det,samp,reg,eta,value="
901 <<det<<" "
902 <<samp<<" "
903 <<reg<<" "
904 <<eta<<" "
905 <<value<<" " );
906
907 Identifier id ;
908 if ( det==1 && samp==1 && reg==0 && eta==0 ){
909 // eta=0 for strip, not connected, but keep it
910 // Removed disconnected channels: 03/2016 RDS
911 // ATH_MSG_INFO(" disconnected strip ");
912 // id = m_em_idhelper->disc_channel_id(det,samp,reg,eta,0);
913 }else
914 {
915 if (tp==1){
916 id = m_em_idhelper->channel_id(det,samp,reg,eta,0);
917 }else
918 if(tp==2)
919 {
920 id = m_hec_idhelper->channel_id(det,samp,reg,eta,0);
921 }
922 else
923 {
924 ATH_MSG_ERROR(" unknown type "<<tp);
925 continue;
926 }
927 }
928
929 HWIdentifier hid = cabling->createSignalChannelID(id);
930 const LArMinBiasComplete::LArCondObj & t = minbias->get(hid,0);
931 ATH_MSG_INFO(" online id = "<<m_online_idhelper->print_to_string(hid));
932
933 if( t.isEmpty() )
934 {
935 ATH_MSG_ERROR(" No existing conditions data " );
936 ATH_MSG_ERROR( m_em_idhelper->print_to_string(id) );
937 // return StatusCode::FAILURE ;
938 continue ;
939 }
940 ATH_MSG_INFO(" Old MinBias = "<< t.m_MinBiasRMS<< " " );
941
942 LArMinBiasComplete::LArCondObj& t2 = const_cast<LArMinBiasComplete::LArCondObj&>(t);
943 t2.m_MinBiasRMS = value ;
944
945 const LArMinBiasComplete::LArCondObj & t3 = minbias->get(hid,0);
946 ATH_MSG_INFO(" New MinBias = "<< t3.m_MinBiasRMS<< " " );
947
948 }
949
950 ATH_MSG_INFO(" Number of entries changes = " <<n );
951 return StatusCode::SUCCESS;
952}
953
954
955StatusCode FixLArElecCalib::fix6 ATLAS_NOT_THREAD_SAFE (const LArOnOffIdMapping *cabling) {
956
957 ATH_MSG_INFO ( " in fix6() " );
958
959 // update FCAL noise and gain
960 // Fix6 is for updating the FCAL noise and ADC2DAC, uA2MeV and DAC2uA.
961
962 const LArNoiseMC * noise_c = nullptr;
963 ATH_CHECK( detStore()->retrieve(noise_c) );
964 LArNoiseMC* noise = const_cast<LArNoiseMC*>(noise_c);
965
966 const LArRampMC * ramp_c = nullptr;
967 ATH_CHECK( detStore()->retrieve(ramp_c) );
968 LArRampMC* ramp = const_cast<LArRampMC*>(ramp_c);
969
970 const LAruA2MeVMC * ua2MeV_c = nullptr;
971 ATH_CHECK( detStore()->retrieve(ua2MeV_c) );
972 LAruA2MeVMC* ua2MeV = const_cast<LAruA2MeVMC*>(ua2MeV_c);
973
974 const LArDAC2uAMC * dac2uA_c = nullptr;
975 ATH_CHECK( detStore()->retrieve(dac2uA_c) );
976 LArDAC2uAMC* dac2uA = const_cast<LArDAC2uAMC*>(dac2uA_c);
977
978 int ndisc=0;
979 int nconn=0;
980 for( unsigned int gain=0;gain<3;++gain)
981 {
982 // loop over all the old data
983 LArNoiseMC::ConditionsMapIterator it = noise->begin(gain);
984 LArNoiseMC::ConditionsMapIterator it_e = noise->end(gain);
985
986 for (; it!=it_e;++it)
987 {
988 HWIdentifier hid = it.channelId();
989 if( (*it).isEmpty() ) continue;
990
991 Identifier id = cabling->cnvToIdentifier(hid);
992 if(!m_fcal_idhelper->is_lar_fcal(id)) continue;
993
994 if(cabling->isOnlineConnected(hid)){
995 ++nconn;
996 continue;
997 }else
998 {
999 ATH_MSG_ERROR(" unconnected channel"
1000 << m_online_idhelper->print_to_string(hid) );
1001
1002 ++ndisc ;
1003 }
1004
1005 }
1006
1007 ATH_MSG_INFO(" Gain="<<gain<<
1008 " Number of connected and disconnected = " <<nconn<<" " <<ndisc );
1009
1010 }
1011
1012
1013 int n=0;
1014
1015 std::string filename("FCal_noise_minbias_adc2mev.txt");
1016 std::ifstream infile(filename) ;
1017
1018 if(! infile.good() )
1019 {
1020 ATH_MSG_ERROR(" fail to open file "<<filename);
1021 return StatusCode::FAILURE;
1022 }
1023
1024
1025 char s[200];
1026
1027 ATH_MSG_INFO("Opened FCAL file");
1028 for(int i = 0;i<27;++i){
1029 infile.getline(s,200);
1030 ATH_MSG_INFO(s);
1031 }
1032
1033 std::string str_id;
1034
1035 float vol,noise_p,noise_h, noise_m,noise_l;
1036 float ramp_val,ua2MeV_val,dac2uA_val;
1037 std::string channel_type;
1038 while ( infile>>str_id >>vol>>noise_p >> noise_h>>noise_m>>noise_l
1039 >>channel_type>> ramp_val>>ua2MeV_val>>dac2uA_val )
1040 {
1041 const char* ch_id = str_id.c_str();
1042
1043 if(str_id.substr(0,1)!=std::string("A")){
1044 ATH_MSG_INFO(" skipping string"<<str_id);
1045 continue;
1046 }
1047
1048 int mod,phi,eta;
1049 sscanf(ch_id, "A%d.%d.%d", &mod,&phi,&eta);
1050 if(phi>7){
1051 ATH_MSG_INFO(" skipping phi"<<str_id<<" phi="<<phi);
1052 continue;
1053 }
1054
1055 ++n;
1056
1057 ATH_MSG_INFO(" Setting channel "<<str_id);
1058 Identifier id = m_fcal_idhelper->channel_id(2,mod,eta,phi);
1059 HWIdentifier hid = cabling->createSignalChannelID(id);
1060
1061 const LArNoiseComplete::LArCondObj& noise0 = noise->get(hid,0) ;
1062 LArNoiseComplete::LArCondObj& u0 = const_cast<LArNoiseComplete::LArCondObj&>(noise0);
1063 if(u0.m_Noise!=noise_h)
1064 ATH_MSG_INFO(" noise, old new "<<u0.m_Noise<<" " <<noise_h);
1065 u0.m_Noise=noise_h;
1066
1067 const LArNoiseComplete::LArCondObj& noise1 = noise->get(hid,1) ;
1068 LArNoiseComplete::LArCondObj& u1 = const_cast<LArNoiseComplete::LArCondObj&>(noise1);
1069 if(u1.m_Noise!=noise_m)
1070 ATH_MSG_INFO(" noise, old new "<<u1.m_Noise<<" " <<noise_m);
1071 u1.m_Noise=noise_m;
1072
1073 const LArNoiseComplete::LArCondObj& noise2 = noise->get(hid,2) ;
1074 LArNoiseComplete::LArCondObj& u2 = const_cast<LArNoiseComplete::LArCondObj&>(noise2);
1075 if(u2.m_Noise!=noise_l)
1076 ATH_MSG_INFO(" noise, old new "<<u2.m_Noise<<" " <<noise_l);
1077 u2.m_Noise=noise_l;
1078
1079 LArRampComplete::LArCondObj& ramp0 = const_cast<LArRampComplete::LArCondObj&>(ramp->get(hid,0));
1080 LArRampComplete::LArCondObj& ramp1 = const_cast<LArRampComplete::LArCondObj&>(ramp->get(hid,1));
1081 LArRampComplete::LArCondObj& ramp2 = const_cast<LArRampComplete::LArCondObj&>(ramp->get(hid,2));
1082
1083 ramp0.m_vRamp={0., ramp_val};
1084
1085 ramp1.m_vRamp={0., ramp_val/(float)9.96};
1086
1087 ramp2.m_vRamp={0., ramp_val/(float)9.96/(float)9.67};
1088
1089 LAruA2MeVComplete::LArCondObj& ua2MeV0 = const_cast<LAruA2MeVComplete::LArCondObj&>(ua2MeV->get(hid,0));
1090 ua2MeV0.m_data=ua2MeV_val;
1091
1092 LArDAC2uAComplete::LArCondObj& dac2ua0 = const_cast<LArDAC2uAComplete::LArCondObj&>(dac2uA->get(hid,0));
1093 dac2ua0.m_data = dac2uA_val;
1094
1095 }
1096
1097 ATH_MSG_INFO(" number of channels in file ="<<n);
1098 return StatusCode::SUCCESS;
1099}
1100
1101
1102StatusCode FixLArElecCalib::fix7 ATLAS_NOT_THREAD_SAFE (const LArOnOffIdMapping *cabling) {
1103
1104 ATH_MSG_INFO ( " in fix7() " );
1105 std::string filename ;
1106
1107 // updating fSampl from 13.0.30 for QGSP_BERT
1108 if( m_g4Phys=="QGSP_BERT"){
1109 filename = "fsampl_1303_qgsp-bert.txt";
1110 }
1111 else {
1112 ATH_MSG_ERROR ( " wrong option "<<m_g4Phys );
1113 return StatusCode::FAILURE;
1114 }
1115
1116 ATH_CHECK( updateEMfSampl(filename, cabling ) );
1117 return StatusCode::SUCCESS;
1118}
1119
1120StatusCode FixLArElecCalib::fix8 ATLAS_NOT_THREAD_SAFE (const LArOnOffIdMapping *cabling) {
1121
1122 ATH_MSG_INFO ( " in fix8() " );
1123 // update EM/HEC 7 data objects.
1124
1125 ATH_CHECK( addMphysOverMcal(cabling) );
1126
1127 // withGain , nvar
1128 ATH_CHECK( update_EM_HEC<LArNoiseMC>("noise_em.txt","noise_hec.txt", cabling, true, 1 ) );
1129 ATH_CHECK( update_EM_HEC<LArAutoCorrMC>("","autocorr_hec.txt", cabling, true, 4 ) );
1130
1131 ATH_CHECK( update_EM_HEC<LArAutoCorrMC>("autocorr_em.txt","", cabling, true,5) );
1132 ATH_CHECK( update_EM_HEC<LArRampMC>("ramp_em.txt","ramp_hec.txt", cabling, true, 1 ) );
1133 ATH_CHECK( update_EM_HEC<LAruA2MeVMC>("ua2mev_em.txt","ua2mev_hec.txt", cabling, false, 1 ) );
1134 ATH_CHECK( update_EM_HEC<LArDAC2uAMC>("dac2ua_em.txt","dac2ua_hec.txt", cabling, false, 1 ) );
1135 ATH_CHECK( update_EM_HEC<LArShape32MC>("shape_em.txt","shape_hec.txt", cabling, true, 64 ) );
1136 ATH_CHECK( update_EM_HEC<LArMphysOverMcalMC>("mphys_em.txt","", cabling, true, 1 ) );
1137
1138 // additional fix for LArDAC2uA and LAruA2MeV
1139 ATH_CHECK( fixDACuAMeV() );
1140 return StatusCode::SUCCESS;
1141}
1142
1143
1144StatusCode FixLArElecCalib::ReadFile(const std::string& filename, const LArOnOffIdMapping *cabling, bool EM, bool withGain, int nvar ) {
1145
1146 std::ifstream infile(filename) ;
1147
1148 if(! infile.good() )
1149 {
1150 ATH_MSG_ERROR(" fail to open file "<<filename );
1151 return StatusCode::FAILURE;
1152 }
1153
1154 ATH_MSG_INFO(" Opened file "<<filename );
1155
1156 m_cache[0].clear();
1157 m_cache[1].clear();
1158 m_cache[2].clear();
1159
1160 char s[200];
1161 infile.getline(s,200);
1162 ATH_MSG_INFO(" first line of the file "<<s);
1163
1164 int det=2;
1165 int samp,reg,eta;
1166 int first;
1167 while ( infile>>first )
1168 {
1169 if (EM) {
1170 det = first;
1171 infile>>samp>>reg>>eta;
1172 }else
1173 {
1174 samp=first;
1175 infile>>reg>>eta;
1176 }
1177
1178 int gain=0;
1179 if(withGain) infile>>gain ;
1180 std::vector<float> vfl;
1181 float x;
1182
1183 for (int i=0;i<nvar;++i)
1184 {
1185 infile>>x;
1186 vfl.push_back(x);
1187 }
1188 ATH_MSG_DEBUG(" det,samp,reg,eta,values="
1189 <<det<<" "
1190 <<samp<<" "
1191 <<reg<<" "
1192 <<eta<<" " );
1193
1194 Identifier id ;
1195 if (EM)
1196 {
1197 if ( det==1 && samp==1 && reg==0 && eta==0 ){
1198 // eta=0 for strip, not connected, but keep it
1199 // Removed disconnected channels: 03/2016 RDS
1200 ATH_MSG_DEBUG(" disconnected strip ");
1201 }else
1202 id = m_em_idhelper->channel_id(det,samp,reg,eta,0);
1203 }else //HEC
1204 {
1205 id = m_hec_idhelper->channel_id(2,samp,reg,eta,0);
1206 }
1207 HWIdentifier hid = cabling->createSignalChannelID(id);
1208
1209 if (gain >= 0 && gain < 3)
1210 m_cache[gain].push_back(ROW_t(hid,vfl));
1211 }
1212
1213 return StatusCode::SUCCESS;
1214}
1215
1216StatusCode FixLArElecCalib::ReadFileAll(const std::string& filename, const LArOnOffIdMapping *cabling, bool withGain, int nvar ) {
1217
1218 std::ifstream infile(filename) ;
1219
1220 if(! infile.good() )
1221 {
1222 ATH_MSG_ERROR(" fail to open file "<<filename );
1223 return StatusCode::FAILURE;
1224 }
1225
1226 ATH_MSG_INFO(" Opened file "<<filename );
1227
1228 m_cache[0].clear();
1229 m_cache[1].clear();
1230 m_cache[2].clear();
1231
1232 char s[200];
1233 infile.getline(s,200);
1234 ATH_MSG_INFO(" first line of the file "<<s);
1235
1236 int det=0,samp=0,reg=0,eta=0;
1237 int first=0;
1238 while ( infile>>first>>samp>>reg>>eta ) {
1239 Identifier id ;
1240 int gain=0;
1241 float x;
1242 if(first <= 2) { // Calo 0,1,2 is EM
1243 det = first+1;
1244 if ( det==1 && samp==1 && reg==0 && eta==0 ){
1245 // eta=0 for strip, not connected, but keep it
1246 // Removed disconnected channels: 03/2016 RDS
1247 ATH_MSG_DEBUG(" disconnected strip ");
1248 // id = m_em_idhelper->disc_channel_id(det,samp,reg,eta,0);
1249 }else
1250 id = m_em_idhelper->channel_id(det,samp,reg,eta,0);
1251 } else if (first == 3) { // HEC
1252 id = m_hec_idhelper->channel_id(2,samp,reg,eta,0);
1253 } else if (first == 4) { // FCAL
1254 id = m_fcal_idhelper->channel_id(2,samp+1,eta,0);
1255 } else {
1256 ATH_MSG_WARNING(" Wrong calo number "<<first<<" skipping !!!");
1257 if(withGain) infile>>gain ;
1258 for (int i=0;i<nvar;++i) infile>>x;
1259 continue;
1260 }
1261 if(withGain) infile>>gain ;
1262 std::vector<float> vfl;
1263
1264 for (int i=0;i<nvar;++i)
1265 {
1266 infile>>x;
1267 vfl.push_back(x);
1268 }
1269 ATH_MSG_DEBUG(" first, det,samp,reg,eta,values="
1270 <<first<<" " <<det<<" " <<samp<<" " <<reg<<" " <<eta<<" " );
1271
1272 HWIdentifier hid = cabling->createSignalChannelID(id);
1273
1274 if (gain >= 0 && gain < 3) m_cache[gain].push_back(ROW_t(hid,vfl));
1275 else {
1276 ATH_MSG_WARNING(" Wrong gain " <<gain<<" skipping !");
1277 }
1278 }// while
1279
1280 return StatusCode::SUCCESS;
1281}
1282
1283void FixLArElecCalib::print_object(std::string_view msg, const LArNoiseMC::LArCondObj& obj)
1284{
1285 if( obj.isEmpty()){
1286 ATH_MSG_INFO(" LArNoiseMC " << msg << " is empty" );
1287 }else
1288 ATH_MSG_DEBUG(" LArNoiseMC" << msg << obj.m_Noise );
1289 return ;
1290}
1291
1292void FixLArElecCalib::set_object(LArNoiseMC::LArCondObj& obj, const std::vector<float>& v )
1293{
1294 if (v.size()!=1)
1295 {
1296 ATH_MSG_ERROR ("for LArNoiseMC, size of vector = "<< v.size() <<" differs from one");
1297 return ;
1298 }
1299 obj.m_Noise = v[0];
1300 return;
1301}
1302
1303void FixLArElecCalib::print_object(std::string_view s, const LArAutoCorrMC::LArCondObj& obj)
1304{
1305 if( obj.isEmpty()){
1306 ATH_MSG_INFO(" LArAutoCorrMC " << s << " is empty" );
1307 }else
1308 {
1309 msg()<<MSG::DEBUG<<" LArAutoCorrMC" << s ;
1310 for (unsigned int i =0 ; i<obj.m_vAutoCorr.size();++i)
1311 msg()<< " " << obj.m_vAutoCorr[i];
1312 msg()<<endmsg;
1313 }
1314 return ;
1315}
1316
1317void FixLArElecCalib::set_object(LArAutoCorrMC::LArCondObj& obj, const std::vector<float>& v )
1318{
1319 if (v.size()<4 )
1320 {
1321 ATH_MSG_ERROR( "for LArAutoCorrMC, size of vector = "<< v.size()<<" is less then 4" );
1322 return ;
1323 }
1324
1325 obj.m_vAutoCorr.resize(4);
1326 std::copy_n(v.begin(), 4, obj.m_vAutoCorr.begin());
1327 return;
1328}
1329
1330void FixLArElecCalib::print_object(std::string_view s, const LArRampMC::LArCondObj& obj)
1331{
1332 if( obj.isEmpty()){
1333 ATH_MSG_INFO(" LArRampMC " << s << " is empty" );
1334 }else
1335 {
1336 msg()<<MSG::DEBUG<<" LArRampMC" << s ;
1337 for (unsigned int i =0 ; i<obj.m_vRamp.size();++i)
1338 msg()<< " " << obj.m_vRamp[i];
1339 msg()<<endmsg;
1340 }
1341 return ;
1342}
1343
1344void FixLArElecCalib::set_object(LArRampMC::LArCondObj& obj, const std::vector<float>& v )
1345{
1346 if (v.size()!=1 )
1347 {
1348 ATH_MSG_ERROR ("for LArRampMC, size of vector = "<< v.size());
1349 return ;
1350 }
1351 obj.m_vRamp.resize(3);
1352 obj.m_vRamp[0]=0;
1353 obj.m_vRamp[1]=v[0];
1354 obj.m_vRamp[2]=0;
1355
1356 return;
1357}
1358
1359void FixLArElecCalib::print_object(std::string_view s, const LArShape32MC::LArCondObj& obj)
1360{
1361 if( obj.isEmpty()){
1362 ATH_MSG_INFO(" LArShape32MC " << s << " is empty" );
1363 }else
1364 {
1365 msg()<<MSG::DEBUG<<" LArShape" << s ;
1366 for (unsigned int i =0 ; i<obj.m_vShape.size();++i)
1367 msg()<< " " << obj.m_vShape[i];
1368 msg()<<endmsg;
1369
1370 msg()<<MSG::DEBUG<<" LArShapeDer" << s ;
1371 for (unsigned int i =0 ; i<obj.m_vShapeDer.size();++i)
1372 msg()<< " " << obj.m_vShapeDer[i];
1373 msg()<<endmsg;
1374 }
1375 return ;
1376}
1377
1378void FixLArElecCalib::set_object(LArShape32MC::LArCondObj& obj, const std::vector<float>& v )
1379{
1380
1381 if (v.size()!=64 && v.size()!=32 )
1382 {
1383 ATH_MSG_ERROR ("for LArShape32MC, size of vector = "<< v.size());
1384 return ;
1385 }
1386
1387 unsigned int size = 32;
1388 obj.m_vShape.resize(size);
1389 obj.m_vShapeDer.resize(size);
1390
1391 for(unsigned int i=0;i<size;++i){
1392 obj.m_vShape[i]=v[i];
1393 if(v.size() == 64 ) obj.m_vShapeDer[i]=v[i+size]; else obj.m_vShapeDer[i]=0.;
1394 }
1395
1396 return;
1397}
1398
1399
1400
1401
1402
1403void FixLArElecCalib::print_object(std::string_view msg, const LArSingleFloatP& obj)
1404{
1405 if( obj.isEmpty()){
1406 ATH_MSG_INFO(" LArSingleFloatP " << msg << " is empty" );
1407 }else
1408 ATH_MSG_DEBUG(" LArSingleFloatP " << msg << obj.m_data );
1409 return ;
1410}
1411
1412void FixLArElecCalib::set_object(LArSingleFloatP& obj, const std::vector<float>& v )
1413{
1414 if (v.size()!=1)
1415 {
1416 ATH_MSG_ERROR( "for LArSingleFloatP, size of vector = "<< v.size() );
1417 return ;
1418 }
1419 obj.m_data = v[0];
1420 return;
1421}
1422
1423
1424
1425
1426StatusCode FixLArElecCalib::addMphysOverMcal(const LArOnOffIdMapping *cabling) {
1427 // add the contain to DetStore.
1428 // fill 1 for all FCAL/HEC channels
1429
1430 ATH_MSG_INFO ( " addMphysOverMcal() " );
1431 // create LArMphysOverMcal with FCAL numbers = 1.
1432
1433 std::unique_ptr<LArMphysOverMcalMC> mphys = std::make_unique<LArMphysOverMcalMC>();
1434 mphys->setGroupingType(LArConditionsContainerBase::SingleGroup);
1435 ATH_CHECK( mphys->initialize() );
1436
1437 int n=0;
1438
1439 std::string filename("FCal_noise_minbias_adc2mev.txt");
1440
1441 std::ifstream infile(filename ) ;
1442
1443 if(! infile.good() )
1444 {
1445 ATH_MSG_ERROR(" fail to open file "<<filename);
1446 return StatusCode::FAILURE;
1447 }
1448
1449
1450 char s[200];
1451
1452 ATH_MSG_INFO("Opened FCAL file");
1453 for(int i = 0;i<27;++i){
1454 infile.getline(s,200);
1455 ATH_MSG_INFO(s);
1456 }
1457
1458 std::string str_id;
1459
1460 float vol,noise_p,noise_h, noise_m,noise_l;
1461 float ramp_val,ua2MeV_val,dac2uA_val;
1462 std::string channel_type;
1463 while ( infile>>str_id >>vol>>noise_p >> noise_h>>noise_m>>noise_l
1464 >>channel_type>> ramp_val>>ua2MeV_val>>dac2uA_val )
1465 {
1466 const char* ch_id = str_id.c_str();
1467
1468 if(str_id.substr(0,1)!=std::string("A")){
1469 ATH_MSG_INFO(" skipping string"<<str_id);
1470 continue;
1471 }
1472
1473 int mod,phi,eta;
1474 sscanf(ch_id, "A%d.%d.%d", &mod,&phi,&eta);
1475 if(phi>7){
1476 ATH_MSG_INFO(" skipping phi"<<str_id<<" phi="<<phi);
1477 continue;
1478 }
1479
1480 ++n;
1481
1482 ATH_MSG_INFO(" Setting channel "<<str_id);
1483 Identifier id = m_fcal_idhelper->channel_id(2,mod,eta,phi);
1484 HWIdentifier hid = cabling->createSignalChannelID(id);
1485
1486 LArMphysOverMcalMC::LArCondObj t;
1487 t.m_data =1. ;
1488 mphys->setPdata(hid,t,0);
1489 mphys->setPdata(hid,t,1);
1490 mphys->setPdata(hid,t,2);
1491 }
1492
1493 ATH_MSG_INFO(" MphysOverMcal added "<<n<<" FCAL channels");
1494
1495 bool EM=false ;
1496 bool withGain=false;
1497 int nvar = 1;
1498 std::string hec_filename("mphys_hec.txt");
1499 ATH_CHECK( ReadFile(hec_filename,cabling,EM,withGain,nvar) );
1500
1501 int igain=0;
1502 n=0;
1503 for( ROW_t &it : m_cache[igain])
1504 {
1505 HWIdentifier hid = it.first;
1506 LArMphysOverMcalMC::LArCondObj t;
1507 t.m_data =1. ;
1508 mphys->setPdata(hid,t,0);
1509 mphys->setPdata(hid,t,1);
1510 mphys->setPdata(hid,t,2);
1511 ++n;
1512
1513 }
1514
1515 ATH_CHECK( detStore()->record(std::move(mphys),"LArMphysOverMcal") );
1516
1517 ATH_MSG_ERROR(" Number of HEC channel added "<<n <<" per gain ");
1518 return StatusCode::SUCCESS ;
1519}
1520
1521
1522StatusCode FixLArElecCalib::fixDACuAMeV ATLAS_NOT_THREAD_SAFE ()
1523{
1524 // the old data has -10000000 for invalid. change it to {ERRORCODE = -999};
1525
1526 const LArDAC2uAMC * dac2ua_c = nullptr;
1527 ATH_CHECK( detStore()->retrieve(dac2ua_c) );
1528 LArDAC2uAMC* dac2uaMC = const_cast<LArDAC2uAMC*>(dac2ua_c);
1529
1530 const LAruA2MeVMC * ua2mev_c = nullptr;
1531 ATH_CHECK( detStore()->retrieve(ua2mev_c) );
1532 LAruA2MeVMC* ua2mevMC = const_cast<LAruA2MeVMC*>(ua2mev_c);
1533
1534 int n=0;
1535
1536 LAruA2MeVMC::ConditionsMapIterator it = ua2mevMC->begin(0);
1537 LAruA2MeVMC::ConditionsMapIterator it_e = ua2mevMC->end(0);
1538
1539 for(;it!=it_e;++it){
1540 HWIdentifier hid = it.channelId();
1541 const LAruA2MeVComplete::LArCondObj & u = (*it);
1542
1543 if( u.m_data> -990)
1544 {
1545 ATH_MSG_DEBUG(" ua2MeV channel OK "<<u.m_data );
1546 continue ;
1547 }
1548
1549 ATH_MSG_DEBUG(" Old uA2MeV = "<< u.m_data<< " " );
1550
1551 LAruA2MeVComplete::LArCondObj& u2 = const_cast<LAruA2MeVComplete::LArCondObj&>(u);
1552 u2.m_data= ILAruA2MeV::ERRORCODE ;
1553
1554 const LAruA2MeVComplete::LArCondObj & u3 = ua2mevMC->get(hid,0);
1555 ATH_MSG_DEBUG(" New uA2MeV = "<< u3.m_data<< " " );
1556
1557 ++n;
1558 }
1559
1560 ATH_MSG_DEBUG(" Number of uA2MeV entries changes = " <<n );
1561
1562 for(unsigned int igain=0;igain<3;++igain)
1563 {
1564 LArDAC2uAMC::ConditionsMapIterator it = dac2uaMC->begin(igain);
1565 LArDAC2uAMC::ConditionsMapIterator it_e = dac2uaMC->end(igain);
1566
1567 n=0;
1568 for( ;it!=it_e;++it){
1569 HWIdentifier hid = it.channelId();
1570 const LArDAC2uAMC::LArCondObj & u = (*it);
1571
1572 if( u.m_data> -990.)
1573 {
1574 ATH_MSG_DEBUG(" DAC2uA channel OK "<<u.m_data );
1575 continue ;
1576 }
1577
1578 ATH_MSG_DEBUG(" Old DAC2uA = "<< u.m_data<< " " );
1579
1580 LArDAC2uAMC::LArCondObj& u2 = const_cast<LArDAC2uAMC::LArCondObj&>(u);
1581 u2.m_data = ILArDAC2uA::ERRORCODE ;
1582
1583 const LArDAC2uAMC::LArCondObj & u3 = dac2uaMC->get(hid,igain);
1584 ATH_MSG_DEBUG(" New DACuA2 = "<< u3.m_data << " " );
1585 ++n;
1586 }
1587
1588 }
1589
1590 ATH_MSG_DEBUG(" Number of DAC2uA entries changes = " <<n );
1591 return StatusCode::SUCCESS;
1592}
1593
1594
1595StatusCode FixLArElecCalib::fix9 ATLAS_NOT_THREAD_SAFE (const LArOnOffIdMapping *cabling) {
1596
1597 ATH_MSG_INFO ( " in fix9(), replace FCAL AutoCorr " );
1598
1599 std::vector<float> fcal_autoCorr[3][3] ; //[module][gain]
1600 fcal_autoCorr[0][0] = {-0.01, -0.30, -0.09, 0.08};
1601 fcal_autoCorr[0][1] = { 0.01, -0.07, -0.01, 0.03};
1602 fcal_autoCorr[0][2] = { 0.2, 0.2, 0.2, 0.2};
1603 fcal_autoCorr[1][0] = { -0.02, -0.31, -0.06, 0.06};
1604 fcal_autoCorr[1][1] = { 0.0, -0.08, -0.01, 0.02};
1605 fcal_autoCorr[1][2] = { 0.02, 0.01, 0.02, 0.02};
1606 fcal_autoCorr[2][0] = { -0.03, -0.31, -0.05, 0.07};
1607 fcal_autoCorr[2][1] = { 0.01, -0.07, -0.01, 0.02};
1608 fcal_autoCorr[2][2] = { 0.02, 0.02, 0.02, 0.02};
1609
1610 // Fix9 is for updating the FCAL AutoCorr conditions data
1611 // Input should be MC Conditions data with DetDescrVersion=ATLAS-CSC-02-00-00
1612
1613 const LArAutoCorrMC * ac_c = nullptr;
1614 ATH_CHECK( detStore()->retrieve(ac_c) );
1615 LArAutoCorrMC* ac = const_cast<LArAutoCorrMC*>(ac_c);
1616
1617
1618 for( unsigned int gain=0;gain<3;++gain)
1619 {
1620 // loop over all the old data
1621 LArAutoCorrMC::ConditionsMapIterator it = ac->begin(gain);
1622 LArAutoCorrMC::ConditionsMapIterator it_e = ac->end(gain);
1623
1624 int n=0;
1625 for (; it!=it_e;++it)
1626 {
1627 HWIdentifier hid = it.channelId();
1628 const LArAutoCorrMC::LArCondObj & u = (*it);
1629 if( (*it).isEmpty() ) continue;
1630
1631 Identifier id = cabling->cnvToIdentifier(hid);
1632 if(! m_fcal_idhelper->is_lar_fcal(id)) continue ;
1633 int module = m_fcal_idhelper->module(id) - 1;
1634
1635 ATH_MSG_DEBUG("module= " << module << " Old AutoCorr = "
1636 << u.m_vAutoCorr[0]<< " "
1637 << u.m_vAutoCorr[1]<< " "
1638 << u.m_vAutoCorr[2]<< " "
1639 << u.m_vAutoCorr[3]<< " " );
1640
1641 LArAutoCorrMC::LArCondObj& u2 = const_cast<LArAutoCorrMC::LArCondObj&>(u);
1642 u2.m_vAutoCorr = fcal_autoCorr[module][gain] ;
1643
1644 const LArAutoCorrMC::LArCondObj & u3 = ac->get(hid,gain);
1645 ATH_MSG_DEBUG(" New AutoCorr = "
1646 << u3.m_vAutoCorr[0]<< " "
1647 << u3.m_vAutoCorr[1]<< " "
1648 << u3.m_vAutoCorr[2]<< " "
1649 << u3.m_vAutoCorr[3]<< " " );
1650 ++n;
1651
1652 }
1653 ATH_MSG_DEBUG(" Gain="<<gain<<
1654 " Number of entries modified = " <<n );
1655 }
1656
1657 return StatusCode::SUCCESS;
1658}
1659
1660
1661StatusCode FixLArElecCalib::fix10 ATLAS_NOT_THREAD_SAFE (const LArOnOffIdMapping *cabling) {
1662
1663 ATH_MSG_INFO ( " in fix10() " );
1664 // fix medium and low gain ramp
1665
1666 const LArRampMC * ramp_c = nullptr;
1667 ATH_CHECK( detStore()->retrieve(ramp_c) );
1668 LArRampMC* ramp = const_cast<LArRampMC*>(ramp_c);
1669
1670 LArRampMC::ConditionsMapIterator it = ramp->begin(0);
1671 LArRampMC::ConditionsMapIterator it_e = ramp->end(0);
1672
1673 int n=0;
1674 int ndisc=0;
1675 for (; it!=it_e;++it)
1676 {
1677 HWIdentifier hid = it.channelId();
1678 if( (*it).isEmpty() ) continue;
1679
1680 Identifier id = cabling->cnvToIdentifier(hid);
1681 if(!m_fcal_idhelper->is_lar_fcal(id)) continue;
1682
1683 if( ! cabling->isOnlineConnected(hid)){
1684 ATH_MSG_ERROR(" unconnected channel"
1685 << m_online_idhelper->print_to_string(hid) );
1686 ++ndisc ;
1687 continue ;
1688 }
1689
1690
1691 const LArRampComplete::LArCondObj& ramp0_c = ramp->get(hid,0) ;
1692 const LArRampComplete::LArCondObj& ramp1_c = ramp->get(hid,1) ;
1693 const LArRampComplete::LArCondObj& ramp2_c = ramp->get(hid,2) ;
1694 LArRampComplete::LArCondObj& ramp0 = const_cast<LArRampComplete::LArCondObj&>(ramp0_c);
1695 LArRampComplete::LArCondObj& ramp1 = const_cast<LArRampComplete::LArCondObj&>(ramp1_c);
1696 LArRampComplete::LArCondObj& ramp2 = const_cast<LArRampComplete::LArCondObj&>(ramp2_c);
1697
1698 float ramp_high = ramp0.m_vRamp[1];
1699
1700 ramp1.m_vRamp.assign ({0, ramp_high*9.96f});
1701 ramp2.m_vRamp.assign ({0, ramp_high*9.96f*9.67f});
1702 ++n;
1703
1704 ATH_MSG_DEBUG(" ramp hi,med,low"<< ramp0.m_vRamp[1]<< " "<<ramp1.m_vRamp[1]<< " " <<
1705 ramp2.m_vRamp[1]);
1706
1707 }
1708
1709 ATH_MSG_INFO( " Number of channels updated = " <<n );
1710 ATH_MSG_INFO( " Number of disconnected = " <<ndisc );
1711
1712 return StatusCode::SUCCESS;
1713}
1714
1715
1716StatusCode FixLArElecCalib::fix11 ATLAS_NOT_THREAD_SAFE (const LArOnOffIdMapping *cabling) {
1717
1718 ATH_MSG_INFO ( " in fix8() " );
1719 // update EM/HEC 7 data objects.
1720
1721 ATH_CHECK( update_EM_HEC<LArRampMC>("","ramp_hec_june2008.txt", cabling, true, 1 ) );
1722 return StatusCode::SUCCESS;
1723}
1724
1725
1726StatusCode FixLArElecCalib::fix13(const LArOnOffIdMapping *cabling) {
1727
1728 ATH_MSG_INFO ( " in fix13() " );
1729 // update EM/HEC 7 data objects.
1730
1731 ToolHandle<ICaloSuperCellIDTool> scidtool("CaloSuperCellIDTool");
1732 if ( scidtool.retrieve().isFailure() ) {
1733 ATH_MSG_ERROR ( " Could not retrieve scitool " );
1734 }
1735
1736 std::set<Identifier> scidset;
1737 std::map<HWIdentifier,int> sslot_schannel_idx;
1738 std::vector<unsigned int> OrderOnlHash_OffID;
1739 std::vector<unsigned int> OrderOffHash_OnlID;
1740 OrderOnlHash_OffID.resize(40000,0);
1741 OrderOffHash_OnlID.resize(40000,0);
1742
1743 Identifier::size_type channel_size = m_em_idhelper->channel_hash_max();
1744 unsigned int min_onl_hash = 999999;
1745 unsigned int max_onl_hash = 0;
1746 unsigned int min_off_hash = 999999;
1747 unsigned int max_off_hash = 0;
1748 std::ofstream hashes("AllHashChannels_All.txt");
1749 std::ofstream of("AllChannels_EM.txt");
1750
1751 for(size_t i = 0; i < channel_size ; i++) {
1752 Identifier chid = m_em_idhelper->channel_id(i);
1753 bool isEM = ( m_em_idhelper->is_em_barrel( chid ) || m_em_idhelper->is_em_endcap( chid ) ) ;
1754 if ( ! isEM ) continue;
1755 Identifier SCID = scidtool->offlineToSuperCellID(chid);
1756 if ( scidset.find(SCID) == scidset.end() && (m_scell_idhelper->calo_cell_hash( SCID ).value() < 99999) )
1757 scidset.insert(SCID);
1758 else continue;
1759 HWIdentifier hwid = cabling->createSignalChannelID(chid);
1760 if ( i == 0 ){
1761 of << "Off ID\t\tSCID\t\tOnl ID\t\tFT\tslot\tB-E pos_neg\tSamp\teta\tphi\tFEB_ID\t\tSHWID\t" << '\n';
1762 }
1763 of << chid.get_identifier32().get_compact() << "\t0x" <<
1764 SCID.get_identifier32().get_compact() << "\t0x" <<
1765 hwid.get_identifier32().get_compact() ;
1766 Identifier regId = m_em_idhelper->region_id( chid );
1767 int reg = m_em_idhelper->region( chid );
1768 IdentifierHash regHash = m_em_idhelper->region_hash( regId );
1769 int samp = m_em_idhelper->sampling( chid );
1770 int feedthrough = m_online_idhelper->feedthrough( hwid );
1771 int bar_ec = m_online_idhelper->barrel_ec( hwid );
1772 int pos_neg = m_online_idhelper->pos_neg( hwid );
1773 int slot = m_online_idhelper->slot( hwid );
1774 float etaG = m_em_idhelper->etaGranularity(regHash);
1775 float phiG = m_em_idhelper->phiGranularity(regHash);
1776 float eta0 = m_em_idhelper->eta0(regHash);
1777 float phi0 = m_em_idhelper->phi0(regHash);
1778 float eta = etaG*m_em_idhelper->eta( chid ) + eta0;
1779 float phi = phiG*m_em_idhelper->phi( chid ) + phi0;
1780 char etaChar[10];
1781 char phiChar[10];
1782 sprintf(etaChar,"%5.4f",eta);
1783 sprintf(phiChar,"%5.4f",phi);
1784 of << std::dec << "\t" << feedthrough << "\t" << slot;
1785 of << "\t" << bar_ec << " " << pos_neg << "\t\t" << samp << "\t";
1786 of << etaChar << " " << phiChar << "\t0x";
1787 HWIdentifier feb_id = m_online_idhelper->feb_Id(hwid);
1788 int sslot=1;
1789 bool InSlot= m_em_idhelper->is_em_endcap_inner ( chid );
1790 bool OutSlot= m_em_idhelper->is_em_endcap_outer ( chid ) ;
1791 bool secondOutSlot=false;
1792 if ( OutSlot ) {
1793 if ( (samp==1) && (reg==5) ) secondOutSlot=true;
1794 if ( (samp==2) && (reg==1) && ( m_em_idhelper->eta( chid )>=39 ) )
1795 secondOutSlot=true;
1796 if ( (samp==3) && (reg==0) && ( m_em_idhelper->eta( chid )>=18 ) )
1797 secondOutSlot=true;
1798 }
1799 HWIdentifier sfeb_id = m_sonline_idhelper->feb_Id(bar_ec,pos_neg,feedthrough,sslot);
1800
1801 if ( InSlot ) {
1802 sfeb_id = m_sonline_idhelper->feb_Id(bar_ec,pos_neg,feedthrough-1,sslot+1);
1803 }
1804 if ( secondOutSlot ) {
1805 sfeb_id = m_sonline_idhelper->feb_Id(bar_ec,pos_neg,feedthrough,sslot+1);
1806 }
1807 if ( sslot_schannel_idx.find(sfeb_id) == sslot_schannel_idx.end() )
1808 sslot_schannel_idx[sfeb_id]=0;
1809 else sslot_schannel_idx[sfeb_id]++;
1810 HWIdentifier shwid = m_sonline_idhelper->channel_Id(sfeb_id,sslot_schannel_idx[sfeb_id]);
1811 unsigned int onl_hash = m_sonline_idhelper->channel_Hash( shwid ).value();
1812 if ( onl_hash > max_onl_hash ) max_onl_hash = onl_hash;
1813 if ( onl_hash < min_onl_hash ) min_onl_hash = onl_hash;
1814 unsigned int off_hash = m_scell_idhelper->calo_cell_hash( SCID ).value();
1815 if ( off_hash > max_off_hash ) max_off_hash = off_hash;
1816 if ( off_hash < min_off_hash ) min_off_hash = off_hash;
1817 of << std::hex;
1818 of << feb_id.get_identifier32().get_compact();
1819 of << "\t0x" << shwid.get_identifier32().get_compact();
1820 of << " " << m_online_idhelper->channel_name(hwid) << " " << m_sonline_idhelper->channel_name(shwid);
1821 of << std::dec;
1822 of << " " << onl_hash << " " << off_hash;
1823 of << '\n';
1824
1825 if ( m_scell_idhelper->calo_cell_hash( SCID ).value() < 40000 )
1826 OrderOffHash_OnlID[m_scell_idhelper->calo_cell_hash( SCID ).value()] = shwid.get_identifier32().get_compact();
1827 if ( m_sonline_idhelper->channel_Hash( shwid ).value() < 40000 )
1828 OrderOnlHash_OffID[m_sonline_idhelper->channel_Hash( shwid ).value()] = SCID.get_identifier32().get_compact();
1829 }
1830 of << "Hash check. Onl : " << min_onl_hash << " " << max_onl_hash;
1831 of << "; Off : " << min_off_hash << " " << max_off_hash << '\n';;
1832 of.close();
1833
1834 channel_size = m_hec_idhelper->channel_hash_max();
1835 min_onl_hash = 999999;
1836 max_onl_hash = 0;
1837 min_off_hash = 999999;
1838 max_off_hash = 0;
1839 std::ofstream of1("AllChannels_HEC.txt");
1840
1841 of1 << "Off ID\t\tSCID\t\tOnl ID\t\tFT\tslot\tB-E pos_neg\tSamp\teta\tphi\tFEB_ID\t\tSHWID\t" << '\n';
1842 for(size_t i = 0; i < channel_size ; i++) {
1843 Identifier chid = m_hec_idhelper->channel_id(i);
1844 if ( ! ( m_hec_idhelper->is_lar_hec( chid ) ) ) continue;
1845 Identifier SCID = scidtool->offlineToSuperCellID(chid);
1846 if ( scidset.find(SCID) == scidset.end() )
1847 scidset.insert(SCID);
1848 else continue;
1849 HWIdentifier hwid = cabling->createSignalChannelID(chid);
1850 of1 << chid.get_identifier32().get_compact() << "\t0x" <<
1851 SCID.get_identifier32().get_compact() << "\t0x" <<
1852 hwid.get_identifier32().get_compact() ;
1853 Identifier regId = m_hec_idhelper->region_id( chid );
1854 IdentifierHash regHash = m_hec_idhelper->region_hash( regId );
1855 int samp = m_hec_idhelper->sampling( chid );
1856 int feedthrough = m_online_idhelper->feedthrough( hwid );
1857 int bar_ec = m_online_idhelper->barrel_ec( hwid );
1858 int pos_neg = m_online_idhelper->pos_neg( hwid );
1859 int slot = m_online_idhelper->slot( hwid );
1860 float etaG = m_hec_idhelper->etaGranularity(regHash);
1861 float phiG = m_hec_idhelper->phiGranularity(regHash);
1862 float eta0 = m_hec_idhelper->eta0(regHash);
1863 float phi0 = m_hec_idhelper->phi0(regHash);
1864 float eta = etaG*m_hec_idhelper->eta( chid ) + eta0;
1865 float phi = phiG*m_hec_idhelper->phi( chid ) + phi0;
1866 char etaChar[10];
1867 char phiChar[10];
1868 sprintf(etaChar,"%5.4f",eta);
1869 sprintf(phiChar,"%5.4f",phi);
1870 of1 << std::dec << "\t" << feedthrough << "\t" << slot;
1871 of1 << "\t" << bar_ec << " " << pos_neg << "\t\t" << samp << "\t";
1872 of1 << etaChar << " " << phiChar << "\t0x";
1873 HWIdentifier feb_id = m_online_idhelper->feb_Id(hwid);
1874 int sslot=1;
1875 int subtract=0;
1876 HWIdentifier sfeb_id = m_sonline_idhelper->feb_Id(bar_ec,pos_neg,feedthrough,sslot);
1877 if ( sslot_schannel_idx.find(sfeb_id) == sslot_schannel_idx.end() )
1878 sslot_schannel_idx[sfeb_id]=0;
1879 else sslot_schannel_idx[sfeb_id]++;
1880 if ( (feedthrough==6) && (bar_ec==1) && (slot>9) ) {
1881 sfeb_id = m_sonline_idhelper->feb_Id(bar_ec,pos_neg,feedthrough,sslot+1);
1882 subtract=192;
1883 }
1884 HWIdentifier shwid = m_sonline_idhelper->channel_Id(sfeb_id,sslot_schannel_idx[sfeb_id]-subtract);
1885 unsigned int onl_hash = m_sonline_idhelper->channel_Hash( shwid ).value();
1886 if ( onl_hash > max_onl_hash ) max_onl_hash = onl_hash;
1887 if ( onl_hash < min_onl_hash ) min_onl_hash = onl_hash;
1888 unsigned int off_hash = m_scell_idhelper->calo_cell_hash( SCID ).value();
1889 if ( off_hash > max_off_hash ) max_off_hash = off_hash;
1890 if ( off_hash < min_off_hash ) min_off_hash = off_hash;
1891 of1 << std::hex;
1892 of1 << feb_id.get_identifier32().get_compact();
1893 of1 << "\t0x" << shwid.get_identifier32().get_compact();
1894 of1 << " " << m_online_idhelper->channel_name(hwid) << " " << m_sonline_idhelper->channel_name(shwid);
1895 of1 << std::dec;
1896 of1 << " " << onl_hash << " " << off_hash;
1897 of1 << '\n';
1898
1899 OrderOffHash_OnlID[m_scell_idhelper->calo_cell_hash( SCID ).value()] = shwid.get_identifier32().get_compact();
1900 OrderOnlHash_OffID[m_sonline_idhelper->channel_Hash( shwid ).value()] = SCID.get_identifier32().get_compact();
1901 }
1902
1903 channel_size = m_fcal_idhelper->channel_hash_max();
1904 min_onl_hash = 999999;
1905 max_onl_hash = 0;
1906 min_off_hash = 999999;
1907 max_off_hash = 0;
1908 std::ofstream of3("AllChannels_FCAL.txt");
1909
1910 of3 << "Off ID\t\tSCID\t\tOnl ID\t\tFT\tslot\tB-E pos_neg\tSamp\teta\tphi\tFEB_ID\t\tSHWID\t" << '\n';
1911 for(size_t i = 0; i < channel_size ; i++) {
1912 Identifier chid = m_fcal_idhelper->channel_id(i);
1913 if ( ! ( m_fcal_idhelper->is_lar_fcal( chid ) ) ) continue;
1914 Identifier SCID = scidtool->offlineToSuperCellID(chid);
1915 if ( scidset.find(SCID) == scidset.end() )
1916 scidset.insert(SCID);
1917 else continue;
1918 HWIdentifier hwid = cabling->createSignalChannelID(chid);
1919 of3 << chid.get_identifier32().get_compact() << "\t0x" <<
1920 SCID.get_identifier32().get_compact() << "\t0x" <<
1921 hwid.get_identifier32().get_compact() ;
1922 int samp = 0;
1923 int feedthrough = m_online_idhelper->feedthrough( hwid );
1924 int bar_ec = m_online_idhelper->barrel_ec( hwid );
1925 int pos_neg = m_online_idhelper->pos_neg( hwid );
1926 int slot = m_online_idhelper->slot( hwid );
1927 of3 << std::dec << "\t" << feedthrough << "\t" << slot;
1928 of3 << "\t" << bar_ec << " " << pos_neg << "\t\t" << samp << "\t";
1929 HWIdentifier feb_id = m_online_idhelper->feb_Id(hwid);
1930 int sslot=1;
1931 HWIdentifier sfeb_id = m_sonline_idhelper->feb_Id(bar_ec,pos_neg,feedthrough,sslot);
1932 if ( (feedthrough==6) && (bar_ec==1) && (slot>9) ) {
1933 sfeb_id = m_sonline_idhelper->feb_Id(bar_ec,pos_neg,feedthrough,sslot+1);
1934 }
1935 if ( sslot_schannel_idx.find(sfeb_id) == sslot_schannel_idx.end() )
1936 sslot_schannel_idx[sfeb_id]=0;
1937 else sslot_schannel_idx[sfeb_id]++;
1938 HWIdentifier shwid = m_sonline_idhelper->channel_Id(sfeb_id,sslot_schannel_idx[sfeb_id]);
1939 unsigned int onl_hash = m_sonline_idhelper->channel_Hash( shwid ).value();
1940 if ( onl_hash > max_onl_hash ) max_onl_hash = onl_hash;
1941 if ( onl_hash < min_onl_hash ) min_onl_hash = onl_hash;
1942 unsigned int off_hash = m_scell_idhelper->calo_cell_hash( SCID ).value();
1943 if ( off_hash > max_off_hash ) max_off_hash = off_hash;
1944 if ( off_hash < min_off_hash ) min_off_hash = off_hash;
1945 of3 << std::hex;
1946 of3 << feb_id.get_identifier32().get_compact();
1947 of3 << "\t0x" << shwid.get_identifier32().get_compact();
1948 of3 << " " << m_online_idhelper->channel_name(hwid) << " " << m_sonline_idhelper->channel_name(shwid);
1949 of3 << std::dec;
1950 of3 << " " << onl_hash << " " << off_hash;
1951 of3 << '\n';
1952
1953 OrderOffHash_OnlID[m_scell_idhelper->calo_cell_hash( SCID ).value()] = shwid.get_identifier32().get_compact();
1954 OrderOnlHash_OffID[m_sonline_idhelper->channel_Hash( shwid ).value()] = SCID.get_identifier32().get_compact();
1955 }
1956
1957 of3 << "Hash check. Onl : " << min_onl_hash << " " << max_onl_hash;
1958 of3 << "; Off : " << min_off_hash << " " << max_off_hash << '\n';;
1959 of3.close();
1960
1961
1962
1963 const uint32_t onlHashMax=m_sonline_idhelper->channelHashMax();
1964 coral::AttributeListSpecification *spec_onOff = new coral::AttributeListSpecification();
1965 spec_onOff->extend("OnlineHashToOfflineId", "blob");
1966 spec_onOff->extend<unsigned>("version");
1967 std::unique_ptr<AthenaAttributeList> al_onOff = std::make_unique<AthenaAttributeList>(*spec_onOff);
1968 coral::Blob& blobOnOff=(*al_onOff)["OnlineHashToOfflineId"].data<coral::Blob>();
1969 (*al_onOff)["version"].setValue(0U);
1970 blobOnOff.resize(onlHashMax*sizeof(uint32_t));
1971 uint32_t* pBlobOnOff=static_cast<uint32_t*>(blobOnOff.startingAddress());
1972 unsigned nConn=0;
1973
1974 const uint32_t emptyId=Identifier().get_identifier32().get_compact();
1975 for(size_t ii=0;ii<onlHashMax;ii++) {
1976 if (OrderOnlHash_OffID[ii] != 0) {
1977 pBlobOnOff[ii]=OrderOnlHash_OffID[ii];
1978 nConn++;
1979 }
1980 else
1981 pBlobOnOff[ii]=emptyId;
1982 }
1983
1984 ATH_MSG_INFO ( "HashMax=" << onlHashMax << ", connected=" << nConn );
1985
1986 ATH_CHECK( detStore()->record(std::move(al_onOff),"/LAR/IdentifierOfl/OnOffIdMap_SC") );
1987
1988 hashes << "idx \t Off2OnlId \t Onl2OffId" << '\n';
1989 for(size_t ii=0;ii<40000;ii++)
1990 if ( (OrderOffHash_OnlID[ii] != 0) || ( OrderOnlHash_OffID[ii] != 0 ) )
1991 hashes << std::dec << ii << std::hex << " \t " << OrderOffHash_OnlID[ii] << " \t\t " << OrderOnlHash_OffID[ii] << '\n';
1992 hashes.close();
1993
1994 return StatusCode::SUCCESS;
1995}
1996
1997StatusCode FixLArElecCalib::fix12(const LArOnOffIdMapping *cabling) {
1998
1999 ATH_MSG_INFO ( " in fix12() " );
2000
2001 // Fix12 is for filling the MinBiasRMS and MinBiasAverage from ntuple
2002
2003 // Create new container
2004 std::unique_ptr<LArMinBiasMC> minbias = std::make_unique<LArMinBiasMC>();
2005 ATH_CHECK( minbias->setGroupingType("Single", msg()) );
2006 ATH_CHECK( minbias->initialize() );
2007 std::unique_ptr<LArMinBiasAverageMC> minbias_av = std::make_unique<LArMinBiasAverageMC>();
2008 ATH_CHECK( minbias_av->setGroupingType("Single", msg()) );
2009 ATH_CHECK( minbias_av->initialize() );
2010 //
2011 std::unique_ptr<TFile> fin= std::make_unique<TFile>("ntuple_av.root");
2012 TTree *tin=dynamic_cast<TTree*>(fin->Get("m_tree"));
2013 if (!tin) {
2014 ATH_MSG_ERROR("Can't read tree m_tree");
2015 return StatusCode::FAILURE;
2016 }
2017 const int nindex=1833;
2018 int ncell;
2019 std::vector<int> identifier(2862);
2020 std::vector<int> layer(2862);
2021 std::vector<int> region(2862);
2022 std::vector<int> ieta(2862);
2023 std::vector<float> eta(2862);
2024 std::vector<double> average(2862);
2025 std::vector<double> rms(2862);
2026 TBranch *b_ncell;
2027 TBranch *b_identifier;
2028 TBranch *b_layer;
2029 TBranch *b_region;
2030 TBranch *b_ieta;
2031 TBranch *b_eta;
2032 TBranch *b_average;
2033 TBranch *b_rms;
2034 tin->SetMakeClass(1);
2035 tin->SetBranchAddress("ncell", &ncell, &b_ncell);
2036 tin->SetBranchAddress("identifier", identifier.data(), &b_identifier);
2037 tin->SetBranchAddress("layer", layer.data(), &b_layer);
2038 tin->SetBranchAddress("region", region.data(), &b_region);
2039 tin->SetBranchAddress("ieta", ieta.data(), &b_ieta);
2040 tin->SetBranchAddress("eta", eta.data(), &b_eta);
2041 tin->SetBranchAddress("average", average.data(), &b_average);
2042 tin->SetBranchAddress("rms", rms.data(), &b_rms);
2043 tin->GetEntry(0);
2044
2045 if(ncell>nindex) ncell=nindex;
2046 for(int icell=0; icell<ncell; ++icell) {
2047
2048 Identifier32 id32(identifier[icell]);
2049 Identifier id(id32);
2050 HWIdentifier hid = cabling->createSignalChannelID(id);
2051
2052 minbias->set(hid, rms[icell]);
2053 minbias_av->set(hid, average[icell]);
2054
2055 }
2056
2057 ATH_MSG_INFO(" number of channels in intuple ="<<ncell);
2058
2059 ATH_MSG_INFO ( "Stored container " << minbias->totalNumberOfConditions() << " conditions, key LArMinBias " );
2060 ATH_CHECK( detStore()->record(std::move(minbias),"LArMinBias") );
2061 ATH_MSG_INFO ( "Stored container " << minbias_av->totalNumberOfConditions() << " conditions, key LArMinBiasAverage " );
2062 ATH_CHECK( detStore()->record(std::move(minbias_av),"LArMinBiasAverage") );
2063
2064 return StatusCode::SUCCESS;
2065}
2066
2067StatusCode FixLArElecCalib::fix14(const LArOnOffIdMapping *cabling) {
2068
2069 ATH_MSG_INFO ( " in fix14() " );
2070
2071 // Fix14 is for filling the LArPileupAverage from ntuple
2072
2073 const ILArfSampl* larfSampl = nullptr;
2074 ATH_CHECK( detStore()->retrieve(larfSampl,"") );
2075 // Will try to regenerate from scratch
2076 // Create new container
2077 std::unique_ptr<LArMinBiasAverageMC> minbias_av = std::make_unique<LArMinBiasAverageMC>();
2078 ATH_CHECK( minbias_av->setGroupingType("Single", msg()) );
2079 ATH_CHECK( minbias_av->initialize() );
2080 //
2081 std::unique_ptr<TFile> fin= std::make_unique<TFile>(m_infile.value().c_str());
2082 TTree *tin=dynamic_cast<TTree*>(fin->Get("m_tree"));
2083 if (!tin) {
2084 ATH_MSG_ERROR("Can't read tree m_tree");
2085 return StatusCode::FAILURE;
2086 }
2087 int ncell;
2088 std::vector<int> identifier(2862);
2089 std::vector<int> layer(2862);
2090 std::vector<int> region(2862);
2091 std::vector<int> ieta(2862);
2092 std::vector<float> eta(2862);
2093 std::vector<double> average(2862);
2094 std::vector<double> rms(2862);
2095 TBranch *b_ncell;
2096 TBranch *b_identifier;
2097 TBranch *b_layer;
2098 TBranch *b_region;
2099 TBranch *b_ieta;
2100 TBranch *b_eta;
2101 TBranch *b_average;
2102 TBranch *b_rms;
2103 tin->SetMakeClass(1);
2104 tin->SetBranchAddress("ncell", &ncell, &b_ncell);
2105 tin->SetBranchAddress("identifier", identifier.data(), &b_identifier);
2106 tin->SetBranchAddress("layer", layer.data(), &b_layer);
2107 tin->SetBranchAddress("region", region.data(), &b_region);
2108 tin->SetBranchAddress("ieta", ieta.data(), &b_ieta);
2109 tin->SetBranchAddress("eta", eta.data(), &b_eta);
2110 tin->SetBranchAddress("average", average.data(), &b_average);
2111 tin->SetBranchAddress("rms", rms.data(), &b_rms);
2112 tin->GetEntry(0);
2113
2114
2115 for(int icell=0; icell<ncell; ++icell) {
2116
2117 Identifier32 id32(identifier[icell]);
2118 Identifier id(id32);
2119 HWIdentifier hid = cabling->createSignalChannelID(id);
2120 float fsampl = larfSampl->FSAMPL(hid);
2121 minbias_av->set(hid, 6.31*average[icell]/fsampl);
2122
2123 }
2124
2125 ATH_MSG_INFO(" number of channels in intuple ="<<ncell);
2126
2127 ATH_MSG_INFO ( "Stored container " << minbias_av->totalNumberOfConditions() << " conditions, key LArPileupAverage " );
2128 ATH_CHECK( detStore()->record(std::move(minbias_av),"LArPileupAverage") );
2129
2130 return StatusCode::SUCCESS;
2131}
2132
2133StatusCode FixLArElecCalib::fix15 ATLAS_NOT_THREAD_SAFE () {
2134
2135 ATH_MSG_INFO ( " in fix15 " );
2136
2137 // this method updates the EM MinBias
2138 // input is the text file.
2139
2140 const LArMinBiasAverageMC * minbias_c = nullptr;
2141 ATH_CHECK( detStore()->retrieve(minbias_c,"LArPileupAverage") );
2142 LArMinBiasAverageMC* minbias = const_cast<LArMinBiasAverageMC*>(minbias_c);
2143
2144
2145 // here some iterator loop is needed
2146 int n=0;
2147
2148 LArMinBiasAverageMC::ConditionsMapIterator it = minbias->begin(0);
2149 LArMinBiasAverageMC::ConditionsMapIterator it_e = minbias->end(0);
2150
2151 for(;it!=it_e;++it){
2152 HWIdentifier hid = it.channelId();
2153 const LArMinBiasAverageComplete::LArCondObj & u = (*it);
2154
2155 ATH_MSG_INFO(" Old pileup = "<< u.m_MinBiasAverage<< " " );
2156
2157 LArMinBiasAverageComplete::LArCondObj& u2 = const_cast<LArMinBiasAverageComplete::LArCondObj&>(u);
2158
2159 u2.m_MinBiasAverage *= 1.0838; // correction value
2160
2161
2162 const LArMinBiasAverageComplete::LArCondObj & t3 = minbias->get(hid,0);
2163 ATH_MSG_INFO(" New Pileup = "<< t3.m_MinBiasAverage<< " " );
2164
2165 }
2166
2167 ATH_MSG_INFO(" Number of entries changes = " <<n );
2168 return StatusCode::SUCCESS;
2169}
2170
2171StatusCode FixLArElecCalib::fix16 ATLAS_NOT_THREAD_SAFE () {
2172
2173 ATH_MSG_INFO ( " in fix16() " );
2174
2175 std::string onOffIdKey="/LAR/Identifier/OnOffIdMap";
2176 const AthenaAttributeList *attrOnOff=nullptr;
2177 StatusCode sc=detStore()->retrieve(attrOnOff,onOffIdKey);
2178 if (sc.isFailure()) {
2179 ATH_MSG_ERROR("Failed to read AthenaAttributeList with key " << onOffIdKey);
2180 return StatusCode::FAILURE;
2181 }
2182 const coral::Blob& blobOnOff=(*attrOnOff)["OnlineHashToOfflineId"].data<coral::Blob>();
2183 unsigned nChan=blobOnOff.size()/sizeof(uint32_t);
2184 uint32_t* pBlobOnOff=const_cast<uint32_t*>(static_cast<const uint32_t*>(blobOnOff.startingAddress()));
2185
2186
2187 if (nChan!=m_online_idhelper->channelHashMax()) {
2188 ATH_MSG_WARNING("Number of channels read from DB (" << nChan << ") does not match online hash max ("
2189 <<m_online_idhelper->channelHashMax() << ")");
2190 nChan=std::min(nChan,static_cast<unsigned int>(m_online_idhelper->channelHashMax()));
2191 }
2192 std::vector<std::pair<unsigned int, unsigned int> > swapindex(8, std::make_pair(nChan+10,nChan+10)); // here we store, which indexes to swap
2193 // loop over all online hashes
2194 for (unsigned i=0;i<nChan;++i) {
2195 const HWIdentifier hwid = m_online_idhelper->channel_Id(IdentifierHash(i));
2196 if(m_online_idhelper->isEMECchannel(hwid) && m_online_idhelper->pos_neg(hwid) == 1 && m_online_idhelper->feedthrough(hwid) == 7 && m_online_idhelper->slot(hwid) == 11) { //EMEC-A FT 7, Slot 11
2197 if(m_online_idhelper->channel(hwid)>=96 && m_online_idhelper->channel(hwid)<=103) swapindex[m_online_idhelper->channel(hwid)-96].first=i;
2198 if(m_online_idhelper->channel(hwid)>=112 && m_online_idhelper->channel(hwid)<=129) swapindex[m_online_idhelper->channel(hwid)-112].second=i;
2199 }
2200 }
2201 for(unsigned i=0; i<8; ++i) {
2202 }
2203 // now do swaping
2204 for(unsigned i=0; i<8; ++i) {
2205 // check consistency of swapindex
2206 if (swapindex[i].first > nChan || swapindex[i].second > nChan ) {
2207 ATH_MSG_ERROR("Problem in swapindex: "<< i << " : " << swapindex[i].first << " " << swapindex[i].second);
2208 return StatusCode::FAILURE;
2209 }
2210 uint32_t id = pBlobOnOff[swapindex[i].first];
2211 pBlobOnOff[swapindex[i].first] = pBlobOnOff[swapindex[i].second];
2212 pBlobOnOff[swapindex[i].second] = id;
2213 }
2214 // and now record the changed blob to SG
2215 ATH_CHECK(detStore()->record(const_cast<AthenaAttributeList *>(attrOnOff),"/LAR/Identifier/OnOffIdMapNew"));
2216
2217 return StatusCode::SUCCESS;
2218}
2219
2220StatusCode FixLArElecCalib::fix17 ATLAS_NOT_THREAD_SAFE (const LArOnOffIdMapping *cabling) {
2221
2222 ATH_MSG_INFO ( " in fix17() " );
2223
2224 // withGain , nvar
2225 ATH_CHECK( update_All<LArShape32MC>(m_infile.value(), cabling, true, 32 ) );
2226
2227 return StatusCode::SUCCESS;
2228}
2229
2230StatusCode FixLArElecCalib::fix18(const LArCalibLineMapping *cabling) {
2231
2232 ATH_MSG_INFO ( " in fix18() " );
2233
2234 const uint32_t onlHashMax=m_online_idhelper->channelHashMax();
2235
2236 coral::AttributeListSpecification* spec_calib = new coral::AttributeListSpecification();
2237 spec_calib->extend("OnlineHashToCalibIds", "blob");
2238 spec_calib->extend<unsigned>("version");
2239 std::unique_ptr<AthenaAttributeList> al_calib = std::make_unique<AthenaAttributeList>(*spec_calib);
2240 coral::Blob& blobCalib=(*al_calib)["OnlineHashToCalibIds"].data<coral::Blob>();
2241 (*al_calib)["version"].setValue(0U);
2242 blobCalib.resize(onlHashMax*sizeof(uint32_t)*4); //Bigger than necessary
2243
2244 spec_calib->release();
2245 // cppcheck-suppress memleak
2246 spec_calib = nullptr;
2247
2248 uint32_t* pBlobCalib=static_cast<uint32_t*>(blobCalib.startingAddress());
2249 size_t calibIndex=0;
2250
2251
2252 // loop over all online hashes
2253 for (unsigned i=0;i<onlHashMax;++i) {
2254 const HWIdentifier hwid = m_online_idhelper->channel_Id(IdentifierHash(i));
2255
2256 const std::vector<HWIdentifier>& calibIDs=cabling->calibSlotLine(hwid);
2257 const size_t nCalibLines=calibIDs.size();
2258
2259 if (m_online_idhelper->isEMBchannel(hwid) && m_online_idhelper->pos_neg(hwid) == 1 && m_online_idhelper->feedthrough(hwid) == 0 ) { // EMB-A FT 0
2260 if(nCalibLines > 1) { //should not be in our channels
2261 ATH_MSG_ERROR("Wrong number of CL in our channels");
2262 return StatusCode::FAILURE;
2263 }
2264 if(nCalibLines==0) {
2265 pBlobCalib[calibIndex++]=0;
2266 } else {
2267 const HWIdentifier cmodule = m_online_idhelper->calib_module_Id(calibIDs[0]);
2268 const HWIdentifier newcl = m_online_idhelper->calib_channel_Id(cmodule, m_online_idhelper->channel(hwid) );
2269 if(!m_online_idhelper->isCalibration(newcl)) {
2270 ATH_MSG_ERROR("Something wrong, new CL not a calibration");
2271 ATH_MSG_ERROR("Channel: "<<hwid.get_identifier32().get_compact()<<" old CL: "<< calibIDs[0].get_identifier32().get_compact()<<" new CL: "<<newcl.get_identifier32().get_compact());
2272 return StatusCode::FAILURE;
2273 }
2274 ATH_MSG_INFO("Channel: "<<hwid.get_identifier32().get_compact()<<" old CL: "<< calibIDs[0].get_identifier32().get_compact()<<" new CL: "<<newcl.get_identifier32().get_compact());
2275 pBlobCalib[calibIndex++]=1;
2276 pBlobCalib[calibIndex++]=newcl.get_identifier32().get_compact();
2277 }
2278 } else {
2279 pBlobCalib[calibIndex++]=nCalibLines;
2280 for(uint32_t iCalib=0;iCalib<nCalibLines;++iCalib)
2281 pBlobCalib[calibIndex++]=calibIDs[iCalib].get_identifier32().get_compact();
2282 }
2283 }
2284 blobCalib.resize(calibIndex*sizeof(uint32_t)); //Size down to actual size
2285 ATH_MSG_INFO( "BlobSize CalibId:" << calibIndex);
2286
2287 // and now record the blob to SG
2288 ATH_CHECK(detStore()->record(std::move(al_calib),"/LAR/Identifier/CalibIdMap_EMF"));
2289
2290 return StatusCode::SUCCESS;
2291}
eta
Scalar eta() const
pseudorapidity method
Definition AmgMatrixBasePlugin.h:83
phi
Scalar phi() const
phi method
Definition AmgMatrixBasePlugin.h:67
endmsg
#define endmsg
Definition AnalysisConfig_Ntuple.cxx:54
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x,...)
Definition AthMsgStreamMacros.h:43
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x,...)
Definition AthMsgStreamMacros.h:47
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x,...)
Definition AthMsgStreamMacros.h:46
ATH_MSG_INFO
#define ATH_MSG_INFO(x,...)
Definition AthMsgStreamMacros.h:45
CaloCell_SuperCell_ID.h
Helper class for offline supercell identifiers.
ATLAS_NOT_THREAD_SAFE
StatusCode FixLArElecCalib::stop ATLAS_NOT_THREAD_SAFE()
Install fatal handler with default options.
Definition FixLArElecCalib.cxx:160
LArEM_ID.h
LArOnline_SuperCellID.h
sc
static Double_t sc
Definition LArPhysWaveHECTool.cxx:37
size
size_t size() const
Number of registered mappings.
x
#define x
AthAlgorithm::AthAlgorithm
AthAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Constructor.
Definition AthAlgorithm.cxx:10
AthCommonAlgorithm< Gaudi::Algorithm >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
Definition AthCommonDataStore.h:95
AthenaAttributeList
An AttributeList represents a logical row of attributes in a metadata table.
Definition PersistentDataModel/PersistentDataModel/AthenaAttributeList.h:46
AtlasDetectorID::print_to_string
std::string print_to_string(Identifier id, const IdContext *context=0) const
or provide the printout in string form
Definition AtlasDetectorID.cxx:358
FixLArElecCalib::fix13
StatusCode fix13(const LArOnOffIdMapping *cabling)
Definition FixLArElecCalib.cxx:1726
FixLArElecCalib::m_cablingKey
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKey
Definition FixLArElecCalib.h:68
FixLArElecCalib::fix12
StatusCode fix12(const LArOnOffIdMapping *cabling)
Definition FixLArElecCalib.cxx:1997
FixLArElecCalib::set_object
void set_object(LArNoiseMC::LArCondObj &obj, const std::vector< float > &v)
Definition FixLArElecCalib.cxx:1292
FixLArElecCalib::ReadFile
StatusCode ReadFile(const std::string &filename, const LArOnOffIdMapping *cabling, bool EM, bool withGain, int nvar)
Definition FixLArElecCalib.cxx:1144
FixLArElecCalib::m_sonline_idhelper
const LArOnline_SuperCellID * m_sonline_idhelper
Definition FixLArElecCalib.h:124
FixLArElecCalib::initialize
virtual StatusCode initialize() override
Definition FixLArElecCalib.cxx:129
FixLArElecCalib::fix2
StatusCode fix2(const LArOnOffIdMapping *cabling)
Definition FixLArElecCalib.cxx:297
FixLArElecCalib::m_sem_idhelper
const LArEM_SuperCell_ID * m_sem_idhelper
Definition FixLArElecCalib.h:122
FixLArElecCalib::m_infile
StringProperty m_infile
Definition FixLArElecCalib.h:73
FixLArElecCalib::fix1
StatusCode fix1(const LArOnOffIdMapping *cabling)
Definition FixLArElecCalib.cxx:221
FixLArElecCalib::fix18
StatusCode fix18(const LArCalibLineMapping *clmap)
Definition FixLArElecCalib.cxx:2230
FixLArElecCalib::m_CLKey
SG::ReadCondHandleKey< LArCalibLineMapping > m_CLKey
Definition FixLArElecCalib.h:69
FixLArElecCalib::m_hec_idhelper
const LArHEC_ID * m_hec_idhelper
Definition FixLArElecCalib.h:119
FixLArElecCalib::m_fixFlag
IntegerProperty m_fixFlag
Definition FixLArElecCalib.h:71
FixLArElecCalib::m_online_idhelper
const LArOnlineID * m_online_idhelper
Definition FixLArElecCalib.h:121
FixLArElecCalib::print_object
void print_object(std::string_view msg, const LArNoiseMC::LArCondObj &obj)
Definition FixLArElecCalib.cxx:1283
FixLArElecCalib::m_fcal_idhelper
const LArFCAL_ID * m_fcal_idhelper
Definition FixLArElecCalib.h:120
FixLArElecCalib::m_scell_idhelper
const CaloCell_SuperCell_ID * m_scell_idhelper
Definition FixLArElecCalib.h:125
FixLArElecCalib::m_em_idhelper
const LArEM_ID * m_em_idhelper
Definition FixLArElecCalib.h:118
FixLArElecCalib::ROW_t
std::pair< HWIdentifier, std::vector< float > > ROW_t
Definition FixLArElecCalib.h:127
FixLArElecCalib::execute
virtual StatusCode execute(const EventContext &ctx) override
Execute method.
Definition FixLArElecCalib.cxx:147
FixLArElecCalib::fix14
StatusCode fix14(const LArOnOffIdMapping *cabling)
Definition FixLArElecCalib.cxx:2067
FixLArElecCalib::addMphysOverMcal
StatusCode addMphysOverMcal(const LArOnOffIdMapping *cabling)
Definition FixLArElecCalib.cxx:1426
FixLArElecCalib::m_shec_idhelper
const LArHEC_SuperCell_ID * m_shec_idhelper
Definition FixLArElecCalib.h:123
FixLArElecCalib::ReadFileAll
StatusCode ReadFileAll(const std::string &filename, const LArOnOffIdMapping *cabling, bool withGain, int nvar)
Definition FixLArElecCalib.cxx:1216
FixLArElecCalib::FixLArElecCalib
FixLArElecCalib(const std::string &name, ISvcLocator *pSvcLocator)
Definition FixLArElecCalib.cxx:115
ILArfSampl::FSAMPL
virtual const float & FSAMPL(const HWIdentifier &id) const =0
Identifier32::get_compact
value_type get_compact() const
Get the compact id.
Definition Identifier32.h:47
IdentifierHash
This is a "hash" representation of an Identifier.
Definition IdentifierHash.h:25
Identifier::get_identifier32
Identifier32 get_identifier32() const
Get the 32-bit version Identifier, will be invalid if >32 bits needed.
LArAutoCorrMC
Implementation of the interface ILArAutoCorr for MC Derives from LArAutoCorrComplete,...
Definition LArAutoCorrMC.h:24
LArAutoCorrP1::m_vAutoCorr
std::vector< float > m_vAutoCorr
Definition LArAutoCorrP1.h:31
LArConditionsContainer::setPdata
void setPdata(const HWIdentifier id, const T &payload, unsigned int gain=0)
put payload in persistent data
LArConditionsContainer::get
ConstReference get(const HWIdentifier id, unsigned int gain=0) const
get data with online identifier
LArConditionsContainer::begin
ConstConditionsMapIterator begin(unsigned int gain) const
get iterator for all channels for a gain
LArConditionsContainer::end
ConstConditionsMapIterator end(unsigned int gain) const
end of all channels for this gain
LArDAC2uAMC
Implementation of the interface ILArDAC2uA for MC Derives from LArDAC2uAComplete, and implements the ...
Definition LArDAC2uAMC.h:21
LArEM_Base_ID::channel_id
Identifier channel_id(const ExpandedIdentifier &exp_id) const
Build a cell identifier from an expanded identifier.
LArEM_ID
Helper class for LArEM offline identifiers.
Definition LArEM_ID.h:111
LArFCAL_Base_ID::fcal_end
id_iterator fcal_end() const
end iterator over full set of Fcal Identifiers for channels
LArFCAL_Base_ID::fcal_begin
id_iterator fcal_begin() const
begin iterator over full set of Fcal Identifiers for channels
LArFCAL_Base_ID::phi
int phi(const Identifier id) const
phi [0,15]
LArFCAL_Base_ID::pos_neg
int pos_neg(const Identifier id) const
pos_neg : +/- 2 (A/C side)
LArFCAL_ID
Helper class for LArFCAL offline identifiers.
Definition LArFCAL_ID.h:49
LArMinBiasAverageMC
Implementation of the interface ILArMinBiasAverage for MC Derives from LArMinBiasAverageComplete,...
Definition LArMinBiasAverageMC.h:19
LArMinBiasMC
Implementation of the interface ILArMinBias for MC Derives from LArMinBiasComplete,...
Definition LArMinBiasMC.h:19
LArNoiseMC
Implementation of the interface ILArNoise for MC Derives from LArNoiseComplete, and implements the ph...
Definition LArNoiseMC.h:20
LArNoiseP::m_Noise
float m_Noise
Definition LArNoiseP.h:17
LArOnlineID_Base::channel_Id
HWIdentifier channel_Id(int barrel_ec, int pos_neg, int feedthrough, int slot, int channel) const
create channel identifier from fields
Definition LArOnlineID_Base.cxx:1275
LArRampMC
Implementation of the interface ILArRamp for MC Derives from LArRampComplete, and implements the phi-...
Definition LArRampMC.h:22
LArRampP1::m_vRamp
std::vector< float > m_vRamp
Definition LArRampP1.h:30
LArRampP1::isEmpty
bool isEmpty() const
Definition LArRampP1.h:29
LArShape32MC
This class implements the ILArShape interface.
Definition LArShape32MC.h:27
LArfSamplMC
Implementation of the interface ILArfSampl for MC Derives from LArfSamplComplete, and implements the ...
Definition LArfSamplMC.h:23
LAruA2MeVMC
Implementation of the interface ILAruA2MeV for MC Derives from LAruA2MeVComplete, and implements the ...
Definition LAruA2MeVMC.h:22
ALFA_EventTPCnv_Dict::t2
std::vector< ALFA_RawDataContainer_p1 > t2
Definition ALFA_EventTPCnvDict.h:44
ALFA_EventTPCnv_Dict::t1
std::vector< ALFA_RawDataCollection_p1 > t1
Definition ALFA_EventTPCnvDict.h:43
Base_Fragment.id
id
Definition Sherpa_i/share/common/Base_Fragment.py:61
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition CaloCondBlobAlgs_fillNoiseFromASCII.py:109
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
LUCID_EventTPCnv_Dict::t3
std::vector< LUCID_RawData_p1 > t3
Definition LUCID_EventTPCnvDict.h:28
TRTCalib_Extractor.det
det
Definition TRTCalib_Extractor.py:36
Trk::u
@ u
Enums for curvilinear frames.
Definition ParamDefs.h:77
read_hist_ntuple.t
t
Definition read_hist_ntuple.py:8
xAOD::uint32_t
setEventNumber uint32_t
Definition EventInfo_v1.cxx:127
Generated on for ATLAS Offline Software by doxygen 1.17.0