Loading [MathJax]/jax/input/TeX/config.js
ATLAS Offline Software
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
LArOFCAlg.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 // LArOFC: Algorithm to calculate optimal filtering constants.
6 
8 
20 
21 #include "CoralBase/Blob.h"
23 
27 #include "CaloDetDescr/CaloDetDescrElement.h"
31 
32 #include <cassert>
33 #include <tuple> //std::ignore
34 
35 #include "tbb/parallel_for.h"
36 
37 //#define LAROFCALG_DEBUGOUTPUT
38 
39 
40 LArOFCAlg::LArOFCAlg(const std::string& name, ISvcLocator* pSvcLocator)
41  : AthAlgorithm(name, pSvcLocator)
42 {}
43 
44 
45 
47 
49 
50  if ( m_nSamples>32 ) {
51  ATH_MSG_ERROR( "You are not allowed to compute OFC for Nsamples = " << m_nSamples ) ;
52  return StatusCode::FAILURE;
53  }
54 
55  StatusCode sc = m_AutoCorrDecoder.retrieve();
56  if (sc.isFailure()) {
57  ATH_MSG_FATAL( "Could not retrieve AutoCorrDecoder " << m_AutoCorrDecoder );
58  return StatusCode::FAILURE;
59  } else {
60  ATH_MSG_INFO( "Retrieved Decoder Tool: "<< m_AutoCorrDecoder );
61  }
62 
63 
64  if (m_computeV2) {
65  sc = m_AutoCorrDecoderV2.retrieve();
66  if (sc.isFailure()) {
67  ATH_MSG_FATAL( "Could not retrieve AutoCorrDecoderV2 " << m_AutoCorrDecoderV2 );
68  return StatusCode::FAILURE;
69  } else {
70  ATH_MSG_INFO( "Retrieved Decoder Tool: "<< m_AutoCorrDecoderV2 );
71  }
72  }
73 
74  if ( m_isSC ) {
76  sc = detStore()->retrieve(ll, "LArOnline_SuperCellID");
77  if (sc.isFailure()) {
78  msg(MSG::ERROR) << "Could not get LArOnlineID helper !" << endmsg;
79  return StatusCode::FAILURE;
80  }
81  else {
82  m_onlineID = (const LArOnlineID_Base*)ll;
83  ATH_MSG_DEBUG("Found the LArOnlineID helper");
84  }
85  } else { // m_isSC
86  const LArOnlineID* ll;
87  sc = detStore()->retrieve(ll, "LArOnlineID");
88  if (sc.isFailure()) {
89  msg(MSG::ERROR) << "Could not get LArOnlineID helper !" << endmsg;
90  return StatusCode::FAILURE;
91  }
92  else {
93  m_onlineID = (const LArOnlineID_Base*)ll;
94  ATH_MSG_DEBUG(" Found the LArOnlineID helper. ");
95  }
96  }
97 
102 
103  ATH_MSG_INFO( "Number of wave points needed : " << m_nPoints ) ;
104  if (m_computeV2) {
105  ATH_MSG_INFO( "Will compute two flavors of OFCs" );
106  ATH_MSG_INFO( "Version 1: useDelta= " << m_useDelta <<", output key: " << m_ofcKey << " AutoCorrDecoder: " << m_AutoCorrDecoder.name() );
107  ATH_MSG_INFO( "Version 2: useDelta= " << m_useDeltaV2 <<", output key: " << m_ofcKeyV2 << " AutoCorrDecoder: " << m_AutoCorrDecoderV2.name() );
108  }
109  return StatusCode::SUCCESS;
110 }
111 
112 
114 {
115 
116  ATH_MSG_DEBUG( "In LArOFCAlg finalize()");
117 
118  ATH_MSG_INFO( "Number of samples : " << m_nSamples ) ;
119  ATH_MSG_INFO( "Number of delays acquired : " << m_nDelays ) ;
120  ATH_MSG_INFO( "Number of phases in OFC : " << m_nPhases ) ;
121  ATH_MSG_INFO( "Spacing between two phases : " << m_dPhases ) ;
122 
123 
124  const LArOnOffIdMapping* cabling{nullptr};
125  if(m_isSC) {
127  ATH_CHECK(cablingHdl.isValid());
128  cabling = *cablingHdl;
129 
130  if (m_useDelta == 3 || m_useDeltaV2==3){
132  ATH_CHECK(caloSuperCellMgrHandle.isValid());
133  m_calo_dd_man = *caloSuperCellMgrHandle;
134  }
135  }
136  else {
138  ATH_CHECK(cablingHdl.isValid());
139  cabling = *cablingHdl;
140 
141  if (m_useDelta == 3 || m_useDeltaV2==3){
143  ATH_CHECK(caloMgrHandle.isValid());
144  m_calo_dd_man = *caloMgrHandle;
145  }
146  }
147 
148  if ( m_timeShift ) {
149  if( m_timeShiftByIndex == -1 ) {
150  ATH_MSG_INFO( " Will use helper class for start time." );
151  } else {
152  ATH_MSG_INFO( " Manually shifting pulses by time index " << m_timeShiftByIndex );
153  }
154  }
155 
156  if (!m_larPhysWaveBinKey.empty()) {
158  }
159 
160  if (m_readCaliWave) {
162  }
163  else {
165  }
166 
167  if (m_readDSPConfig) {
168  const AthenaAttributeList* attrList=nullptr;
170 
171  const coral::Blob& blob = (attrList->coralList())["febdata"].data<coral::Blob>();
172  if (blob.size()<3) {
173  ATH_MSG_INFO( "Found empty blob, nothing to do");
174  } else {
175  m_DSPConfig = std::make_unique<LArDSPConfig>(attrList);
176  }
177  }
178 
179  if (m_allChannelData.empty()) {
180  ATH_MSG_ERROR( "No input waves found" );
181  return StatusCode::FAILURE;
182  }
183 
185  if (m_nThreads>-1) {
186  //There are sone external tools, etc. that potentially cached stuff.
187  //We need to call them at least once to make sure all caches are filled before we go multi-threaded
188  perChannelData_t& chanData=m_allChannelData[0];
189 
190  m_AutoCorrDecoder->AutoCorr(chanData.chid,(CaloGain::CaloGain)chanData.gain,m_nSamples);
191  if (m_computeV2)
192  m_AutoCorrDecoderV2->AutoCorr(chanData.chid,(CaloGain::CaloGain)chanData.gain,m_nSamples);
193 
194  Identifier id=cabling->cnvToIdentifier(chanData.chid);
195  if (m_useDelta==3 || m_useDeltaV2) {
197  }
198 
200 
201 
202  if (!m_larPhysWaveBinKey.empty()) {
203  m_larPhysWaveBin->bin(chanData.chid,(CaloGain::CaloGain)chanData.gain);
204  }
206  std::unique_ptr<tbb::global_control> tbbgc;
207 
208  if (m_nThreads>0) {
209  tbbgc=std::make_unique<tbb::global_control>( tbb::global_control::max_allowed_parallelism, m_nThreads);
210  }
211 
212  //Instanciated the functor and start parallel_for
213  Looper looper(&m_allChannelData,cabling, this);
214  tbb::blocked_range<size_t> range(0, m_allChannelData.size());
215  ATH_MSG_INFO( "Starting parallel execution" );
216  tbb::parallel_for(tbb::blocked_range<size_t>(0, m_allChannelData.size()),looper);
217 
218  ATH_MSG_INFO( "Done with parallel execution" );
219 
220  }
221  else {
222  ATH_MSG_INFO( "Single threaded execution" );
223  for (perChannelData_t& chanData : m_allChannelData) {
224  this->process(chanData,cabling);
225  }
226  }
227 
229 
230  // OFC persistent object
231  std::unique_ptr<LArOFCComplete> larOFCComplete=std::make_unique<LArOFCComplete>();
232  StatusCode sc = larOFCComplete->setGroupingType(m_groupingType,msg());
233  if (sc.isFailure()) {
234  ATH_MSG_ERROR( "Failed to set groupingType for LArOFCComplete object" );
235  return sc;
236  }
237  sc=larOFCComplete->initialize();
238  if (sc.isFailure()) {
239  ATH_MSG_ERROR( "Failed initialize LArOFCComplete object" );
240  return sc;
241  }
242 
243 
244  std::unique_ptr<LArOFCComplete> larOFCCompleteV2=std::make_unique<LArOFCComplete>();
245  sc = larOFCComplete->setGroupingType(m_groupingType,msg());
246  if (sc.isFailure()) {
247  ATH_MSG_ERROR( "Failed to set groupingType for LArOFCComplete object" );
248  return sc;
249  }
250  sc=larOFCCompleteV2->initialize();
251  if (sc.isFailure()) {
252  ATH_MSG_ERROR( "Failed initialize LArOFCComplete object" );
253  return sc;
254  }
255 
256 
257  std::unique_ptr<LArOFCBinComplete> larOFCBinComplete;
258  if (m_storeMaxPhase) {
259  larOFCBinComplete=std::make_unique<LArOFCBinComplete>();
260  sc=larOFCBinComplete->setGroupingType(m_groupingType,msg());
261  if (sc.isFailure()) {
262  ATH_MSG_ERROR( "Failed to set groupingType for LArOFCBinComplete object" );
263  return sc;
264  }
265  sc = larOFCBinComplete->initialize();
266  if ( sc.isFailure() ) {
267  ATH_MSG_ERROR( "Could not initialize LArOFCComplete data object - exit!" ) ;
268  return sc ;
269  }
270  }
271 
272  // LArShape persistent object
273  std::unique_ptr<LArShapeComplete> larShapeComplete;
274  if (m_fillShape) {
275  larShapeComplete = std::make_unique<LArShapeComplete>();
276  sc=larShapeComplete->setGroupingType(m_groupingType,msg());
277  if (sc.isFailure()) {
278  ATH_MSG_ERROR( "Failed to set groupingType for LArShapeComplete object" );
279  return sc;
280  }
281  sc=larShapeComplete->initialize();
282  if (sc.isFailure()) {
283  ATH_MSG_ERROR( "Failed initialize LArShapeComplete object" );
284  return sc;
285  }
286  }
287 
288 
289  //Counters (for information only):
290  unsigned nChannels=0;
291  unsigned nFailed=0;
292 
293  for (const perChannelData_t& chanData : m_allChannelData) {
294  ++nChannels;
295  if (chanData.faultyOFC) ++nFailed;
296  // register channel to LArOFCComplete
297  const HWIdentifier ch_id=chanData.chid;
298  const int gain=chanData.gain;
299  ATH_MSG_DEBUG( "add to LArOFCComplete, channel " << m_onlineID->channel_name(ch_id) << ", gain=" << (int)gain);
300  const std::vector<std::vector<float> > & allPhaseOFCa=chanData.ofc_a;
301  const std::vector<std::vector<float> > & allPhaseOFCb=chanData.ofc_b;
302  const std::vector<std::vector<float> > & allPhaseShape=chanData.shape;
303  const std::vector<std::vector<float> > & allPhaseShapeDer=chanData.shapeDer;
304  larOFCComplete->set(ch_id,gain,allPhaseOFCa,allPhaseOFCb,chanData.tstart,chanData.timeBinWidthOFC);
305  if (larOFCBinComplete) larOFCBinComplete->set(ch_id,gain,chanData.phasewMaxAt3);
306  if ( m_fillShape ) larShapeComplete->set(ch_id,gain,allPhaseShape,allPhaseShapeDer,chanData.tstart,chanData.timeBinWidthOFC);
307 
308 
309  if (m_computeV2) {
310  const std::vector<std::vector<float> > & allPhaseOFCV2a=chanData.ofcV2_a;
311  const std::vector<std::vector<float> > & allPhaseOFCV2b=chanData.ofcV2_b;
312  larOFCCompleteV2->set(ch_id,gain,allPhaseOFCV2a,allPhaseOFCV2b,chanData.tstart,chanData.timeBinWidthOFC);
313  }
314 
315  } // end loop over m_allChannelData
316 
317  ATH_MSG_INFO( " Summary : Computed OFCs for " << nChannels << " channels * gains" );
318  if (nFailed)
319  ATH_MSG_ERROR( "Number of channels * gains with failed OFC verification: " << nFailed );
320 
321  if ( !m_dumpOFCfile.empty()) {
322  ATH_MSG_INFO( "Dumping OFCs to file " << m_dumpOFCfile ) ;
323  larOFCComplete->dumpOFC(m_dumpOFCfile) ;
324  }
325 
326  sc = detStore()->record(std::move(larOFCComplete),m_ofcKey);
327  if (sc.isFailure()) {
328  ATH_MSG_ERROR( "Could not record LArOFCComplete to DetStore with key " << m_ofcKey );
329  return StatusCode::FAILURE;
330  }
331  ATH_MSG_INFO( "LArOFCComplete object recorded with key " << m_ofcKey ) ;
332 
334  if (sc.isFailure()) {
335  ATH_MSG_ERROR( "Could not symlink ILArOFC with LArOFCComplete." );
336  return StatusCode::FAILURE;
337  }
338  ATH_MSG_INFO( "Symlink with ILArOFC done" ) ;
339 
340 
341  // record and symlink second version of LArOFCComplete object
342  if (m_computeV2) {
343  sc = detStore()->record(std::move(larOFCCompleteV2),m_ofcKeyV2);
344  if (sc.isFailure()) {
345  ATH_MSG_ERROR( "Could not record LArOFCComplete to DetStore with key " << m_ofcKeyV2 );
346  return StatusCode::FAILURE;
347  }
348  ATH_MSG_INFO( "LArOFCComplete object recorded with key " << m_ofcKeyV2 ) ;
349 
351  if (sc.isFailure()) {
352  ATH_MSG_ERROR( "Could not symlink ILArOFC with LArOFCComplete." );
353  return StatusCode::FAILURE;
354  }
355  ATH_MSG_INFO( "Symlink with ILArOFC done" ) ;
356  }
357 
358  if (larOFCBinComplete) {
359  sc = detStore()->record(std::move(larOFCBinComplete),m_ofcBinKey);
360  if (sc.isFailure()) {
361  ATH_MSG_ERROR( "Could not record LArOFCBinCompete object" );
362  return StatusCode::FAILURE;
363  }
364  }
365 
366  // record and symlink LArShapeComplete object
367  if ( m_fillShape ) {
368  ATH_MSG_DEBUG( "Trying to record LArShapeComplete object to detector store, key = " << m_shapeKey);
369  sc = detStore()->record(std::move(larShapeComplete),m_shapeKey);
370  if (sc.isFailure()) {
371  ATH_MSG_ERROR( "Could not record LArShapeComplete to DetStore with key " << m_shapeKey );
372  return StatusCode::FAILURE;
373  }
374  ATH_MSG_INFO( "LArShapeComplete object recorded to DetStore successfully with key " << m_shapeKey ) ;
375  ATH_MSG_DEBUG( "Trying to symlink ILArShape with LArShapeComplete");
377  if (sc.isFailure()) {
378  ATH_MSG_ERROR( "Could not symlink ILArShape with LArShapeComplete." );
379  return StatusCode::FAILURE;
380  }
381  ATH_MSG_INFO( "ILArShape symlink with LArShapeComplete successfully" ) ;
382  }
383 
384 
385  //Undo corrections, if they are applied by this algo:
386  if (m_waveCnt_nc) {
388  ATH_MSG_INFO("Reverted corrections of non-cost wave container");
389  }
390 
391  return StatusCode::SUCCESS;
392 }
393 
394 
396 
397  LArWaveHelper larWaveHelper;
398  const LArWaveCumul* nextWave=chanData.inputWave;
399  if (!nextWave) {
400  ATH_MSG_ERROR( "input wave is 0" );
401  return;
402  }
403 
404  if ( nextWave->getFlag() == LArWave::dac0 ) return ; // skip dac0 waves
405 
406  const HWIdentifier ch_id=chanData.chid;
407  const unsigned gain=chanData.gain;
408  ATH_MSG_DEBUG( "Computing OFC for channel " << m_onlineID->channel_name(ch_id) << " in gain = " << gain);
409 
410 
411  // check constistency of settings
412  if ( m_nPoints > nextWave->getSize() ) {
413  ATH_MSG_ERROR( "Channel " << m_onlineID->channel_name(ch_id) <<": Wave size (" << nextWave->getSize()
414  << ") is too small to fit your OFC request (" << m_nPoints << " points)" ) ;
415  chanData.shortWave=true;
416  return;
417  }
418 
419  // the current waveform
420  LArWave aWave = *nextWave; // Actually *copying* the Wave to get rid of the const: need to manipulate Wave to normalize...
421 
422  if (m_larPhysWaveBin) {
423  const int bin = m_larPhysWaveBin->bin(ch_id,gain);
424  if (bin>-998) { //>ERRORCODE
425  ATH_MSG_VERBOSE("Channel " << m_onlineID->channel_name(ch_id) << ": shift by index " << bin);
426  aWave=larWaveHelper.translate(aWave,-bin,0);
427  }
428  else
429  ATH_MSG_VERBOSE("Channel 0x" << MSG::hex << ch_id.get_identifier32().get_compact() << MSG::dec << ": No valid index for shifting");
430  }//end if larPhysWaveBin
431 
432 
433  // normalize input wave, if requested
434  if (m_normalize) {
435  const double peak = aWave.getSample( larWaveHelper.getMax(aWave) );
436  if ( peak == 0 ) {
437  ATH_MSG_ERROR( "Wave maximum is zero, skipping channel " << m_onlineID->channel_name(ch_id) ) ;
438  return;
439  }
440 
441  ATH_MSG_VERBOSE("Channel 0x" << m_onlineID->channel_name(ch_id) << " has amplitude = " << peak << ": normalizing...");
442  aWave = aWave * (1./peak);
443  }
444 
445  ATH_MSG_VERBOSE("Channel " << m_onlineID->channel_name(ch_id) << " has now amplitude = " << aWave.getSample( larWaveHelper.getMax(aWave)));
446  // compute tstart to shift input wave, if requested
447  if ( m_timeShift ) {
448  if( m_timeShiftByIndex == -1 ) {
449  chanData.tstart = larWaveHelper.getStart(aWave) ;
450  } else {
451  chanData.tstart = m_timeShiftByIndex;
452  }
453  }
454 
455  ATH_MSG_DEBUG("Channel" << m_onlineID->channel_name(ch_id) << ", Tstart = " << chanData.tstart);
456 
457  //Calculate derivative for this wave
458  LArWave aDerivedWave = larWaveHelper.derive_smooth(aWave);
459 
460  chanData.timeBinWidthOFC = m_dPhases*aWave.getDt();
461 
462  float maxSampleValAt3=-1;
463 
464  //prepare output vectors
465  chanData.ofc_a.resize(m_nPhases);
466  chanData.ofc_b.resize(m_nPhases);
467  chanData.shape.resize(m_nPhases);
468  chanData.shapeDer.resize(m_nPhases);
469 
470  if (m_computeV2) {
471  chanData.ofcV2_a.resize(m_nPhases);
472  chanData.ofcV2_b.resize(m_nPhases);
473  }
474 
475 
476  const Eigen::MatrixXd acInverse=m_AutoCorrDecoder->AutoCorr(chanData.chid,(CaloGain::CaloGain)chanData.gain,m_nSamples).inverse();
477  Eigen::MatrixXd acInverseV2;
478  if (m_computeV2)
479  acInverseV2=m_AutoCorrDecoderV2->AutoCorr(chanData.chid,(CaloGain::CaloGain)chanData.gain,m_nSamples).inverse();
480 
481  unsigned tShift=0;
483  if(m_DSPConfig->peakSample(m_onlineID->feb_Id(ch_id)) < 2 ) { // 2 is canonical value for peak
484  tShift = 2 - m_DSPConfig->peakSample(m_onlineID->feb_Id(ch_id));
485  }
486  }
487  if(m_forceShift) tShift=1;
488 
489  ATH_MSG_DEBUG("Channel " << m_onlineID->channel_name(ch_id) << "shift: " << tShift);
490 
491  for (unsigned iPhase=0;iPhase<m_nPhases;iPhase++) { //Loop over all phases
492 
493  ATH_MSG_VERBOSE ("Channel " << m_onlineID->channel_name(ch_id)
494  << ", Gain = " << gain << ", Phase = " << iPhase << ":");
495 
496 
497  //Reference to the samples and deriviative to be filled
498  std::vector<float>& theSamples=chanData.shape[iPhase];
499  std::vector<float>& theSamplesDer=chanData.shapeDer[iPhase];
500 
501  //Extract the points where we compute the OFCs from the wave and the derived wave
502  //and fill the samples an derivative vector
503  theSamples.reserve(m_nSamples);
504  theSamplesDer.reserve(m_nSamples);
505  for (unsigned iSample=0;iSample<m_nSamples;++iSample){ //Loop over all samples
506  const unsigned tbin = chanData.tstart + iPhase*m_dPhases + (iSample+tShift)*m_nDelays ;
507  theSamples.push_back( aWave.getSample(tbin) );
508  theSamplesDer.push_back( aDerivedWave.getSample(tbin) );
509  } //End loop over samples
510 
511 
512  if (m_storeMaxPhase && m_nSamples>2 && theSamples[2]>maxSampleValAt3) {
513  maxSampleValAt3=theSamples[2];
514  chanData.phasewMaxAt3=iPhase;
515  }
516 
517  bool thisChanUseDelta=useDelta(ch_id,m_useDelta,cabling);
518  bool thisChanUseDeltaV2=m_computeV2 && useDelta(ch_id,m_useDeltaV2,cabling);
519  Eigen::VectorXd delta;
520 
521  if (thisChanUseDelta || thisChanUseDeltaV2) { // will need delta for at least one of the two versions
522  std::vector<float> theSamples32;
523  theSamples32.reserve(32);
524  for (unsigned iSample=0;iSample<32 ;++iSample){ //Loop over all samples
525  const unsigned tbin = chanData.tstart + iPhase*m_dPhases + (iSample+tShift)*m_nDelays ;
526  if (tbin>=aWave.getSize()) continue;
527  theSamples32.push_back( aWave.getSample(tbin) );
528  } //End loop over samples
529  delta=getDelta(theSamples32,ch_id,m_nSamples);
530  }
531 
532  //OFC V1 computiation (i.e. not pileup-optimized)
533  //Reference to the OFCa and OFCb to be filled
534  std::vector<float>& vOFC_a= chanData.ofc_a[iPhase];
535  std::vector<float>& vOFC_b= chanData.ofc_b[iPhase];
536 
537  if(m_computePed){
538  optFiltPed(theSamples,theSamplesDer,acInverse,vOFC_a,vOFC_b);
539  } else {
540  if (thisChanUseDelta) {
541  optFiltDelta(theSamples,theSamplesDer,acInverse,delta,vOFC_a,vOFC_b);
542  }
543  else { //don't use Delta
544  optFilt(theSamples,theSamplesDer,acInverse,vOFC_a,vOFC_b);
545  }
546  }
547 
548  // verify OFC consistency
549  if (m_verify) {
550  chanData.faultyOFC |= verify(chanData.chid,vOFC_a,vOFC_b,theSamples,"OFC",iPhase);
551  }
552 
553 
554  if (m_computeV2) {
555  //OFC V2 computiation (i.e. pileup-optimized)
556  //Reference to the OFCa and OFCb to be filled
557  std::vector<float>& vOFCV2_a= chanData.ofcV2_a[iPhase];
558  std::vector<float>& vOFCV2_b= chanData.ofcV2_b[iPhase];
559 
560  if(m_computePed){
561  optFiltPed(theSamples,theSamplesDer,acInverseV2,vOFCV2_a,vOFCV2_b);
562  } else {
563  if (thisChanUseDeltaV2) {
564  optFiltDelta(theSamples,theSamplesDer,acInverseV2,delta,vOFCV2_a,vOFCV2_b);
565  }
566  else { //don't use Delta
567  optFilt(theSamples,theSamplesDer,acInverseV2,vOFCV2_a,vOFCV2_b);
568  }
569  }
570 
571  // verify OFC consistency
572  if (m_verify) {
573  chanData.faultyOFC |= verify(chanData.chid,vOFCV2_a,vOFCV2_b,theSamples,"OFCV2",iPhase);
574  }
575  }//end if computeV2
576  } //End loop over all phases
577 
578  // in case we're dealing with a LArPhysWave, add any possible previous time shift
579  if (!m_readCaliWave) {
580  const LArPhysWave* pwave=dynamic_cast<const LArPhysWave*>(nextWave);
581  if (pwave)
582  chanData.tstart += pwave->getTimeOffset()+m_addOffset;
583  }
584  }
585 
586 
587 
588 
590 
592 
593  for (unsigned k=0 ; k<m_keylist.size() ; k++ ) { // Loop over all containers that are to be processed (e.g. different gains)
594  ATH_MSG_INFO( "Processing WaveContainer from StoreGate! key = " << m_keylist[k] );
595 
596  const LArPhysWaveContainer* waveCnt;
597  StatusCode sc=detStore()->retrieve(waveCnt,m_keylist[k]);
598  if (sc.isFailure()) {
599  ATH_MSG_ERROR( "Failed to retrieve a LArPhysWaveContainer with key " << m_keylist[k] );
600  return sc;
601  }
602 
603  m_allChannelData.reserve(m_allChannelData.size()+128*waveCnt->size());// Size doesn't give the expected response on a CondtitionsContainer
604 
605  for (unsigned gain = CaloGain::LARHIGHGAIN ; gain < CaloGain::LARNGAIN ; gain++ ) { // loop on possible gains
606  WAVEIT it=waveCnt->begin(gain);
607  WAVEIT it_e=waveCnt->end(gain);
608  for (;it!=it_e;++it) {
609  const HWIdentifier chid=it.channelId();
610  if (cabling->isOnlineConnected (chid)){
611  const LArWaveCumul* wave= &(*it); //down-cast
612  if (!wave->isEmpty()) {
613  m_allChannelData.emplace_back(wave, chid,gain);
614  }
615  }
616  } //end loop over channels
617  }//end loop over gains
618  }//end loop over SG keys
619  return StatusCode::SUCCESS;
620 }
621 
622 
624 
626  for (unsigned k=0 ; k<m_keylist.size() ; k++ ) { // Loop over all containers that are to be processed (e.g. different gains)
627  ATH_MSG_INFO( "Processing WaveContainer from StoreGate! key = " << m_keylist[k] );
628 
629  //Input cali-wave might come from the same job. In this case we see a non-const container in SG probably w/o corrections applied.
630  //Try non-const retrieve:
631  const LArCaliWaveContainer* waveCnt = nullptr;
633  if (m_waveCnt_nc) {
634  waveCnt=m_waveCnt_nc; //Retain const pointer
636  ATH_MSG_INFO( "LArCaliWaveContainer: Corrections not yet applied, applying them now..." );
637  if (m_waveCnt_nc->applyCorrections().isFailure()) {
638  ATH_MSG_ERROR( "Failed to apply corrections to LArCaliWaveContainer!" );
639  return StatusCode::FAILURE;
640  }
641  else {
642  ATH_MSG_INFO("Applied corrections to non-const Wave container");
643  }
644  }
645  }
646  else {
647  waveCnt=detStore()->tryConstRetrieve<LArCaliWaveContainer>(m_keylist[k]);
648  if (!waveCnt) {
649  ATH_MSG_ERROR( "Failed to retrieve a LArCaliWaveContainer with key " << m_keylist[k] );
650  return StatusCode::FAILURE;
651  }
652  }
653 
654 
655  m_allChannelData.reserve(m_allChannelData.size()+128*waveCnt->size());// Size doesn't give the expected response on a CondtitionsContainer
656 
657  for (unsigned gain = CaloGain::LARHIGHGAIN ; gain < CaloGain::LARNGAIN ; gain++ ) { // loop on possible gains
658  WAVEIT it=waveCnt->begin(gain);
659  WAVEIT it_e=waveCnt->end(gain);
660  for (;it!=it_e;++it) {
661  const LArCaliWaveVec& wVec=*it;
662  for (const auto& cw : wVec) {
663  const LArWaveCumul* wave= &(cw); //down-cast
664  if (!wave->isEmpty()) {
665  m_allChannelData.emplace_back(wave,it.channelId(),gain);
666  }
667  }
668  } //end loop over channels
669  }//end loop over gains
670  }//end loop over SG keys
671  return StatusCode::SUCCESS;
672 }
673 
674 
675 void LArOFCAlg::optFilt(const std::vector<float> &gWave, const std::vector<float> &gDerivWave, const Eigen::MatrixXd& acInverse, //input variables
676  std::vector<float>& vecOFCa, std::vector<float>& vecOFCb) { // Output variables;
677  assert(gWave.size()==gDerivWave.size());
678  //assert autoCorr size ....
679  const int optNpt = gWave.size();
680 
681  Eigen::VectorXd gResp(optNpt), gDerivResp(optNpt);
682  for (int i=0;i<optNpt;i++) {
683  gResp[i] = gWave[i];
684  gDerivResp[i] = gDerivWave[i];
685  }
686 
687  Eigen::Matrix2d isol;
688  isol <<
689  (gResp.transpose()*acInverse*gResp)[0],
690  (gResp.transpose()*acInverse*gDerivResp)[0],
691  (gDerivResp.transpose()*acInverse*gResp)[0],
692  (gDerivResp.transpose()*acInverse*gDerivResp)[0];
693 
694  Eigen::Vector2d Amp;
695  Eigen::Vector2d Atau;
696  Eigen::Vector2d Ktemp;
697  Eigen::Matrix2d isolInv = isol.inverse();
698 
699  // we solve for the lagrange multiplers
700  Ktemp[0] = 1.;
701  Ktemp[1] = 0.;
702  Amp = isolInv*Ktemp;
703 
704  Ktemp[0] = 0.;
705  Ktemp[1] = -1.;
706  Atau = isolInv*Ktemp;
707 
708  // we express the a and b vectors in terms of the lagrange multipliers
709  Eigen::VectorXd OFCa = Amp[0]*acInverse*gResp + Amp[1]*acInverse*gDerivResp;
710  Eigen::VectorXd OFCb = Atau[0]*acInverse*gResp + Atau[1]*acInverse*gDerivResp;
711 
712  //Convert back to std::vector
713  vecOFCa.resize(optNpt);
714  vecOFCb.resize(optNpt);
715  for (int i=0;i<optNpt;i++) {
716  vecOFCa[i]=OFCa[i];
717  vecOFCb[i]=OFCb[i];
718  }
719  }
720 
721 void LArOFCAlg::optFiltPed(const std::vector<float> &gWave, const std::vector<float> &gDerivWave, const Eigen::MatrixXd& acInverse, //input variables
722  std::vector<float>& vecOFCa, std::vector<float>& vecOFCb) { // Output variables;
723  assert(gWave.size()==gDerivWave.size());
724  //assert autoCorr size ....
725  const int optNpt = gWave.size();
726 
727  Eigen::VectorXd gResp(optNpt), gDerivResp(optNpt);
728  for (int i=0;i<optNpt;i++) {
729  gResp[i] = gWave[i];
730  gDerivResp[i] = gDerivWave[i];
731  }
732 
733  Eigen::Matrix3d isol;
734  Eigen::Vector3d Kunit(1.,1.,1.);
735  auto s3=(gDerivResp.transpose()*acInverse*gResp)[0];
736  auto s4=(gResp.transpose()*acInverse*Kunit)[0];
737  auto s5=(gDerivResp.transpose()*acInverse*Kunit)[0];
738  isol <<
739  (gResp.transpose()*acInverse*gResp)[0], s3, s4,
740  s3, (gDerivResp.transpose()*acInverse*gResp)[0], s5,
741  s4, s5, (Kunit.transpose()*acInverse*Kunit)[0];
742 
743  Eigen::Vector3d Amp;
744  Eigen::Vector3d Atau;
745  Eigen::Vector3d Ktemp;
746  Eigen::Matrix3d isolInv = isol.inverse();
747 
748  // we solve for the lagrange multiplers
749  Ktemp[0] = 1.;
750  Ktemp[1] = 0.;
751  Ktemp[2] = 0.;
752  Amp = isolInv*Ktemp;
753 
754  Ktemp[0] = 0.;
755  Ktemp[1] = -1.;
756  Ktemp[2] = 0.;
757  Atau = isolInv*Ktemp;
758 
759  // we express the a and b vectors in terms of the lagrange multipliers
760  Eigen::VectorXd OFCa = Amp[0]*acInverse*gResp + Amp[1]*acInverse*gDerivResp + Amp[2]*acInverse*Kunit;
761  Eigen::VectorXd OFCb = Atau[0]*acInverse*gResp + Atau[1]*acInverse*gDerivResp + Atau[2]*acInverse*Kunit;
762 
763  //Convert back to std::vector
764  vecOFCa.resize(optNpt);
765  vecOFCb.resize(optNpt);
766  for (int i=0;i<optNpt;i++) {
767  vecOFCa[i]=OFCa[i];
768  vecOFCb[i]=OFCb[i];
769  }
770  }
771 
772 
773 void LArOFCAlg::optFiltDelta(const std::vector<float> &gWave, const std::vector<float> &gDerivWave,
774  const Eigen::MatrixXd& acInverse, const Eigen::VectorXd& delta,
775  std::vector<float>& vecOFCa, std::vector<float>& vecOFCb) {
776 
777 
778 
779  assert(gWave.size()==gDerivWave.size());
780  //assert autoCorr size ....
781  const int optNpt = gWave.size();
782 
783  Eigen::VectorXd gResp(optNpt), gDerivResp(optNpt);
784  for (int i=0;i<optNpt;i++) {
785  gResp[i] = gWave[i];
786  gDerivResp[i] = gDerivWave[i];
787  }
788 
789  // try 3X3 matrix with offsets
790 
791 
801  Eigen::Matrix3d isol;
802  isol <<
803  (gResp.transpose()*acInverse*gResp)[0],
804  (gResp.transpose()*acInverse*gDerivResp),
805  (gResp.transpose()*acInverse*delta)[0],
806 
807  (gDerivResp.transpose()*acInverse*gResp)[0],
808  (gDerivResp.transpose()*acInverse*gDerivResp)[0],
809  (gDerivResp.transpose()*acInverse*delta)[0],
810 
811  (delta.transpose()*acInverse*gResp)[0],
812  (delta.transpose()*acInverse*gDerivResp)[0],
813  (delta.transpose()*acInverse*delta)[0];
814 
815 
816  Eigen::Vector3d Amp;
817  Eigen::Vector3d Atau;
818  Eigen::Vector3d Ktemp;
819  Eigen::Matrix3d isolInv = isol.inverse();
820 
821  // we solve for the lagrange multiplers
822 
823  Ktemp[0] = 1.;
824  Ktemp[1] = 0.;
825  Ktemp[2] = 0.;
826 
827  Amp = isolInv*Ktemp;
828 
829  Ktemp[0] = 0.;
830  Ktemp[1] = -1.;
831  Atau = isolInv*Ktemp;
832 
833  // we express the a and b vectors in terms of the lagrange multipliers
834  Eigen::VectorXd OFCa = Amp[0]*acInverse*gResp + Amp[1]*acInverse*gDerivResp + Amp[2]*acInverse * delta;
835  Eigen::VectorXd OFCb = Atau[0]*acInverse*gResp + Atau[1]*acInverse*gDerivResp + Atau[2]*acInverse * delta ;
836 
837 
838  //Convert back to std::vector
839  vecOFCa.resize(optNpt);
840  vecOFCb.resize(optNpt);
841  for (int i=0;i<optNpt;i++) {
842  vecOFCa[i]=OFCa[i];
843  vecOFCb[i]=OFCb[i];
844  }
845  }
846 
847 
848 
849 const float LArOFCAlg::m_fcal3Delta[5] ={0.0790199937765, 0.0952000226825, 0.0790199937765, 0.0952000226825, 0.0790199937765};
850 const float LArOFCAlg::m_fcal2Delta[5]={-0.01589001104, -0.0740399733186, -0.01589001104, -0.0740399733186, -0.01589001104};
851 const float LArOFCAlg::m_fcal1Delta[5] ={0.0679600232979, -0.139479996869, 0.0679600232979, -0.139479996869, 0.0679600232979};
852 
853 Eigen::VectorXd LArOFCAlg::getDelta(std::vector<float>& samples, const HWIdentifier chid, unsigned nSamples) const{
854 
855  if (nSamples>5) nSamples=5;
856 
857  Eigen::VectorXd delta(nSamples); //return value
858 
859  if (m_onlineID->isFCALchannel(chid) ){
860  // FCAL use fixed delta from data.
861  const int slot = m_onlineID->slot(chid) ;
862  if ( slot <=9){ // FCAL 1
863  for (unsigned i=0;i<nSamples;++i) {
864  delta[i]=m_fcal1Delta[i];
865  }
866  }else
867  if(slot <=13){ // FCAL 2
868  for (unsigned i=0;i<nSamples;++i) {
869  delta[i]=m_fcal2Delta[i];
870  }
871  }else { //FCAL 3
872  for (unsigned i=0;i<nSamples;++i) {
873  delta[i]=m_fcal3Delta[i];
874  }
875  }
876 
877  }else
878  { // from Shape
879  float odd = 0.;
880  float even = 0.;
881  for (unsigned int i = 0;i<samples.size();++i) {
882  if (i%2==0){
883  even += samples[i];
884  }
885  else {
886  odd += samples[i];
887  }
888  }
889 
890  for (unsigned i=0;i<nSamples;++i) {
891  if (i%2==0)
892  delta[i]=even;
893  else
894  delta[i]=odd;
895  }
896  }
897 
898  return delta;
899 
900 }
901 
902 bool LArOFCAlg::useDelta(const HWIdentifier chid, const int jobOFlag, const LArOnOffIdMapping* cabling) const {
903 
904  if (jobOFlag==2){
905  return true;
906  }
907 
908  if(jobOFlag==1) { // only HEC/EMECIW/FCAL
909  if (m_onlineID->isEMECIW(chid) || m_onlineID->isFCALchannel(chid) || m_onlineID->isHECchannel(chid)) {
910  return true;
911  }
912  }
913 
914  if(jobOFlag==3) { // only HEC/EMECIW/FCAL1 and high eta FCAL2-3
915  if (m_onlineID->isEMECIW(chid) || m_onlineID->isHECchannel(chid)) {
916  return true;
917  }
918  else if (m_onlineID->isFCALchannel(chid) ){
919 
920  if (cabling->isOnlineConnected (chid)){
921  Identifier ofl_id = cabling->cnvToIdentifier(chid);
922  const CaloDetDescrElement* dde = m_calo_dd_man->get_element(ofl_id);
923  if (! dde) {
924  ATH_MSG_ERROR( " dde = 0 , onl_id, ofl_id= "<< chid<<" "<<ofl_id );
925  return false; // Exception better?
926  }
927  if ( m_isSC ) {
929  if (sampling==CaloCell_ID::FCAL0){
930  return true;
931  }
932  else {
933  if (fabs(dde->eta())>4.0){
934  return true;
935  }
936  }
937  } else {
938  CaloCell_ID::CaloSample sampling = dde->getSampling();
939  if (sampling==CaloCell_ID::FCAL0){
940  return true;
941  }
942  else {
943  if (fabs(dde->eta())>4.0){
944  return true;
945  }
946  }
947  }
948 
949  }//end if connected
950  }//end if isFCALchannel
951 
952  }//else if jobOFlag=3
953 
954  return false;
955 }
956 
957 
958 bool LArOFCAlg::verify(const HWIdentifier chid, const std::vector<float>& OFCa, const std::vector<float>& OFCb,
959  const std::vector<float>& Shape, const char* ofcversion, const unsigned phase) const {
960 
961  bool result=false;
962  float recAmpl=0, recTime=0;
963  for (unsigned iSample=0;iSample<m_nSamples;++iSample){
964 
965 #ifdef LAROFCALG_DEBUGOUTPUT
966  ATH_MSG_VERBOSE("a["<<iSample<<"]="<<vOFC_a[iSample] << " b["<<iSample<<"]="<<vOFC_b[iSample]
967  << " Sample=" << aWave.getSample(tbin));
968 #endif
969  recAmpl += OFCa[iSample] * Shape[iSample];
970  recTime += OFCb[iSample] * Shape[iSample];
971  } //End loop over samples
972 
973  recTime /= recAmpl ;
974 
975  // At this point the reconstructed amplitude must be = 1 by definition, whatever the initial normalisation!
976  ATH_MSG_VERBOSE("recAmp=" << recAmpl << " ; recTime=" << recTime);
977  if ( fabs(1.-recAmpl) > m_errAmpl ) {
978  ATH_MSG_WARNING( "Applying phase " << phase << " of " << ofcversion << " to original wave yields an Amplitude of "<< recAmpl
979  << " instead of 1. -> Wrong OFCs? channel " << m_onlineID->channel_name(chid) );
980  LArOFCAlg::printOFCVec(OFCa,msg());
981  result=true;
982  }
983  if ( fabs(recTime) > m_errTime ) {
984  ATH_MSG_WARNING( "Applying phase " << phase << " of " << ofcversion << " to original wave yields a time offset of " << recTime
985  << " -> Wrong OFCs? channel " << m_onlineID->channel_name(chid) );
986  LArOFCAlg::printOFCVec(OFCb,msg());
987  result=true;
988  }
989  return result;
990 }
991 
992 void LArOFCAlg::printOFCVec(const std::vector<float>& vec, MsgStream& mLog) {
993  mLog << MSG::WARNING << "OFCs";
994  for(float v : vec)
995  mLog << " " << v;
996  mLog << endmsg;
997 }
998 
999 
1000 #ifdef LAROFCALG_DEBUGOUTPUT
1001 #undef LAROFCALG_DEBUGOUTPUT
1002 #endif
LArWave
Definition: LArWave.h:31
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
LArOFCAlg::perChannelData_t::shapeDer
std::vector< std::vector< float > > shapeDer
Definition: LArOFCAlg.h:79
LArOFCAlg::m_computeV2
BooleanProperty m_computeV2
Definition: LArOFCAlg.h:162
LArOFCAlg::getDelta
Eigen::VectorXd getDelta(std::vector< float > &samples, const HWIdentifier chid, unsigned nSamples) const
Definition: LArOFCAlg.cxx:853
RPDUtils::nChannels
unsigned constexpr int nChannels
Definition: RPDUtils.h:23
LArOFCAlg::optFilt
static void optFilt(const std::vector< float > &gWave_in, const std::vector< float > &gDerivWave_in, const Eigen::MatrixXd &autoCorrInv, std::vector< float > &OFCa, std::vector< float > &OFCb)
Definition: LArOFCAlg.cxx:675
LArOFCAlg::m_caloSuperCellMgrKey
SG::ReadCondHandleKey< CaloSuperCellDetDescrManager > m_caloSuperCellMgrKey
Definition: LArOFCAlg.h:60
ReadOfcFromCool.phase
phase
Definition: ReadOfcFromCool.py:127
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
LArOFCAlg::m_nDelays
UnsignedIntegerProperty m_nDelays
Definition: LArOFCAlg.h:136
LArConditionsContainer::applyCorrections
StatusCode applyCorrections()
apply correction set
LArOFCAlg::m_errAmpl
DoubleProperty m_errAmpl
Definition: LArOFCAlg.h:146
LArOFCAlg::perChannelData_t::ofc_a
std::vector< std::vector< float > > ofc_a
Definition: LArOFCAlg.h:72
get_generator_info.result
result
Definition: get_generator_info.py:21
LArWaveCumul
Definition: LArWaveCumul.h:30
LArOFCComplete::set
void set(const HWIdentifier &CellID, int gain, const std::vector< std::vector< float > > &vOFC_a, const std::vector< std::vector< float > > &vOFC_b, float timeOffset=0, float timeBinWidth=25./24.)
Definition: LArOFCComplete.cxx:17
detail::ll
long long ll
Definition: PrimitiveHelpers.h:47
LArWave::getSize
size_t getSize() const
number of time samples
Definition: LArWave.h:62
LArCaliWaveContainer.h
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
LArOFCAlg::m_isSC
BooleanProperty m_isSC
Definition: LArOFCAlg.h:172
LArWaveHelper::getStart
unsigned getStart(const LArWave &theWave) const
Definition: LArWaveHelper.cxx:413
LArWave::getFlag
unsigned getFlag() const
flag: ...
Definition: LArWave.h:178
LArOFCBinComplete::bin
virtual const int & bin(const HWIdentifier &chid, const int &gain) const
Definition: LArOFCBinComplete.h:19
LArOFCAlg::perChannelData_t::shortWave
bool shortWave
Definition: LArOFCAlg.h:85
LArOFCAlg::m_cablingKey
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKey
Definition: LArOFCAlg.h:52
LArConditionsContainer::undoCorrections
StatusCode undoCorrections()
undo corrections that have been already applied
LArOFCAlg::m_DSPConfigFolder
StringProperty m_DSPConfigFolder
Definition: LArOFCAlg.h:167
LArOnlineID_Base::isEMECIW
virtual bool isEMECIW(const HWIdentifier id) const =0
LArOFCAlg::perChannelData_t
Definition: LArOFCAlg.h:65
LArOFCAlg::m_fillShape
BooleanProperty m_fillShape
Definition: LArOFCAlg.h:150
LArOFCAlg::m_errTime
DoubleProperty m_errTime
Definition: LArOFCAlg.h:147
LArPhysWaveContainer.h
LArConditionsContainerDB::iteratorT
Declaration of const iterator.
Definition: LArConditionsContainerDB.h:72
CaloDetDescrElement
This class groups all DetDescr information related to a CaloCell. Provides a generic interface for al...
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:66
LArOFCAlg::m_groupingType
StringProperty m_groupingType
Definition: LArOFCAlg.h:157
LArOFCAlg::perChannelData_t::ofc_b
std::vector< std::vector< float > > ofc_b
Definition: LArOFCAlg.h:73
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:110
CaloDetDescrManager_Base::get_element
const CaloDetDescrElement * get_element(const Identifier &cellId) const
get element by its identifier
Definition: CaloDetDescrManager.cxx:159
ReadCellNoiseFromCool.cabling
cabling
Definition: ReadCellNoiseFromCool.py:154
skel.it
it
Definition: skel.GENtoEVGEN.py:407
LArOFCAlg::m_timeShift
BooleanProperty m_timeShift
Definition: LArOFCAlg.h:127
LArWave::getDt
const double & getDt() const
delta time
Definition: LArWave.h:50
LArOnlineID_Base::slot
int slot(const HWIdentifier id) const
Return the slot number of a hardware cell identifier: slot = [1,15] Slot-ID in top part of the crat...
Definition: LArOnlineID_Base.cxx:1957
bin
Definition: BinsDiffFromStripMedian.h:43
LArWaveHelper::translate
LArWave translate(const LArWave &theWave, int nShift, double baseline=0.) const
Definition: LArWaveHelper.cxx:11
Identifier::get_identifier32
Identifier32 get_identifier32() const
Get the 32-bit version Identifier, will be invalid if >32 bits needed.
LArOFCAlg::useDelta
bool useDelta(const HWIdentifier chid, const int jobOFlag, const LArOnOffIdMapping *cabling) const
Definition: LArOFCAlg.cxx:902
LArWaveHelper
Definition: LArWaveHelper.h:14
LArOFCAlg::perChannelData_t::inputWave
const LArWaveCumul * inputWave
Definition: LArOFCAlg.h:67
LArOFCAlg::Looper
Definition: LArOFCAlg.h:186
python.subdetectors.tile.Blob
Blob
Definition: tile.py:17
AthenaAttributeList::coralList
const coral::AttributeList & coralList() const
Definition: PersistentDataModel/PersistentDataModel/AthenaAttributeList.h:65
LArOFCAlg::m_nThreads
IntegerProperty m_nThreads
Definition: LArOFCAlg.h:164
LArOFCAlg::m_normalize
BooleanProperty m_normalize
Definition: LArOFCAlg.h:126
LArOFCAlg::m_keylist
StringArrayProperty m_keylist
Definition: LArOFCAlg.h:124
ReadCellNoiseFromCoolCompare.s4
s4
Definition: ReadCellNoiseFromCoolCompare.py:381
vec
std::vector< size_t > vec
Definition: CombinationsGeneratorTest.cxx:9
LArShapeComplete.h
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
LArWaveHelper::getMax
unsigned int getMax(const LArWave &theWave) const
return index of maximum sample
Definition: LArWaveHelper.cxx:89
LArOFCAlg::perChannelData_t::faultyOFC
bool faultyOFC
Definition: LArOFCAlg.h:84
HWIdentifier
Definition: HWIdentifier.h:13
CaloGain::LARNGAIN
@ LARNGAIN
Definition: CaloGain.h:19
LArOFCAlg::m_fcal1Delta
static const float m_fcal1Delta[5]
Definition: LArOFCAlg.h:182
LArOFCAlg::m_ofcKeyV2
StringProperty m_ofcKeyV2
Definition: LArOFCAlg.h:152
LArOFCAlg::perChannelData_t::ofcV2_a
std::vector< std::vector< float > > ofcV2_a
Definition: LArOFCAlg.h:75
AthenaAttributeList.h
LArPhysWave
Definition: LArPhysWave.h:14
Identifier32::get_compact
value_type get_compact() const
Get the compact id.
Definition: Identifier32.h:44
CaloDetDescrManager.h
Definition of CaloDetDescrManager.
LArPhysWaveContainer
Liquid Argon Physics Wave Container.
Definition: LArPhysWaveContainer.h:23
LArOFCAlg::m_larPhysWaveBinKey
StringProperty m_larPhysWaveBinKey
Definition: LArOFCAlg.h:158
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
CaloCell_ID.h
LArCaliWaveContainer
Liquid Argon Cumulative Wave Container.
Definition: LArCaliWaveContainer.h:33
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
LArOFCAlg::m_fcal3Delta
static const float m_fcal3Delta[5]
Definition: LArOFCAlg.h:180
LArOFCAlg::m_AutoCorrDecoder
ToolHandle< ILArAutoCorrDecoderTool > m_AutoCorrDecoder
Definition: LArOFCAlg.h:139
LArOFCAlg::m_addOffset
FloatProperty m_addOffset
Definition: LArOFCAlg.h:137
LArOFCAlg::process
void process(perChannelData_t &, const LArOnOffIdMapping *cabling) const
Definition: LArOFCAlg.cxx:395
LArOnlineID_Base::isFCALchannel
bool isFCALchannel(const HWIdentifier id) const
Definition: LArOnlineID_Base.cxx:1653
DiTauMassTools::ignore
void ignore(T &&)
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:58
LArWave::getSample
const double & getSample(const unsigned int i) const
Amplitude per time bin.
Definition: LArWave.h:53
LArOFCAlg::m_allChannelData
std::vector< perChannelData_t > m_allChannelData
Definition: LArOFCAlg.h:94
LArOFCAlg::m_computePed
BooleanProperty m_computePed
Definition: LArOFCAlg.h:163
LArOFCAlg::verify
bool verify(const HWIdentifier chid, const std::vector< float > &OFCa, const std::vector< float > &OFCb, const std::vector< float > &Shape, const char *ofcversion, const unsigned phase) const
Definition: LArOFCAlg.cxx:958
LArWave::isEmpty
bool isEmpty() const
is LArWave uninitialized?
Definition: LArWave.h:183
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
LArOFCAlg::initPhysWaveContainer
StatusCode initPhysWaveContainer(const LArOnOffIdMapping *cabling)
Definition: LArOFCAlg.cxx:589
LArConditionsContainer::end
ConstConditionsMapIterator end(unsigned int gain) const
end of all channels for this gain
LArOFCAlg::perChannelData_t::ofcV2_b
std::vector< std::vector< float > > ofcV2_b
Definition: LArOFCAlg.h:76
LArOFCBinComplete.h
LArOFCAlg::m_onlineID
const LArOnlineID_Base * m_onlineID
Definition: LArOFCAlg.h:143
lumiFormat.i
int i
Definition: lumiFormat.py:85
CaloSampling::CaloSample
CaloSample
Definition: Calorimeter/CaloGeoHelpers/CaloGeoHelpers/CaloSampling.h:22
LArOFCComplete.h
LArOnlineID_Base::isHECchannel
virtual bool isHECchannel(const HWIdentifier id) const =0
LArOFCAlg::m_calo_dd_man
const CaloDetDescrManager_Base * m_calo_dd_man
Definition: LArOFCAlg.h:142
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_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
LArOFCAlg::m_fcal2Delta
static const float m_fcal2Delta[5]
Definition: LArOFCAlg.h:181
LArOFCAlg::m_useDelta
IntegerProperty m_useDelta
Definition: LArOFCAlg.h:160
LArOFCAlg::perChannelData_t::gain
unsigned gain
Definition: LArOFCAlg.h:69
LArOFCAlg::m_ofcBinKey
StringProperty m_ofcBinKey
Definition: LArOFCAlg.h:155
ClassID_traits
Default, invalid implementation of ClassID_traits.
Definition: Control/AthenaKernel/AthenaKernel/ClassID_traits.h:37
LArOFCAlg::m_verify
BooleanProperty m_verify
Definition: LArOFCAlg.h:125
plotBeamSpotVxVal.range
range
Definition: plotBeamSpotVxVal.py:195
LArOFCAlg::printOFCVec
static void printOFCVec(const std::vector< float > &vec, MsgStream &mLog)
Definition: LArOFCAlg.cxx:992
CaloCell_SuperCell_ID.h
Helper class for offline supercell identifiers.
LArOFCAlg::optFiltPed
static void optFiltPed(const std::vector< float > &gWave_in, const std::vector< float > &gDerivWave_in, const Eigen::MatrixXd &autoCorrInv, std::vector< float > &OFCa, std::vector< float > &OFCb)
Definition: LArOFCAlg.cxx:721
LArCaliWaveVec
Definition: LArCaliWave.h:91
LArOFCAlg::perChannelData_t::shape
std::vector< std::vector< float > > shape
Definition: LArOFCAlg.h:78
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
LArOFCAlg::m_dumpOFCfile
StringProperty m_dumpOFCfile
Definition: LArOFCAlg.h:123
AthenaAttributeList
An AttributeList represents a logical row of attributes in a metadata table. The name and type of eac...
Definition: PersistentDataModel/PersistentDataModel/AthenaAttributeList.h:45
LArOFCAlg::m_nPoints
unsigned int m_nPoints
Definition: LArOFCAlg.h:121
LArWave::dac0
@ dac0
Definition: LArWave.h:125
LArOFCAlg::m_readCaliWave
BooleanProperty m_readCaliWave
Definition: LArOFCAlg.h:149
LArOFCAlg::m_AutoCorrDecoderV2
ToolHandle< ILArAutoCorrDecoderTool > m_AutoCorrDecoderV2
Definition: LArOFCAlg.h:140
LArPhysWave::getTimeOffset
int getTimeOffset() const
Definition: LArPhysWave.h:97
LArOFCAlg::m_DSPConfig
std::unique_ptr< LArDSPConfig > m_DSPConfig
Definition: LArOFCAlg.h:168
LArOFCAlg::initCaliWaveContainer
StatusCode initCaliWaveContainer()
Definition: LArOFCAlg.cxx:623
AthAlgorithm
Definition: AthAlgorithm.h:47
LArOnlineID_Base::feb_Id
HWIdentifier feb_Id(int barrel_ec, int pos_neg, int feedthrough, int slot) const
Create feb_Id from fields.
Definition: LArOnlineID_Base.cxx:1479
LArOFCAlg::optFiltDelta
static void optFiltDelta(const std::vector< float > &gWave_in, const std::vector< float > &gDerivWave_in, const Eigen::MatrixXd &autoCorrInv, const Eigen::VectorXd &delta, std::vector< float > &vecOFCa, std::vector< float > &vecOFCb)
Definition: LArOFCAlg.cxx:773
LArOFCAlg::m_nSamples
UnsignedIntegerProperty m_nSamples
Definition: LArOFCAlg.h:133
LArOFCAlg::m_forceShift
BooleanProperty m_forceShift
Definition: LArOFCAlg.h:170
LArOnlineID_Base
Helper for the Liquid Argon Calorimeter cell identifiers.
Definition: LArOnlineID_Base.h:105
ReadCellNoiseFromCoolCompare.s3
s3
Definition: ReadCellNoiseFromCoolCompare.py:380
LArOFCAlg.h
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
LArShapeComplete::set
void set(const HWIdentifier &CellID, int gain, const std::vector< std::vector< float > > &vShape, const std::vector< std::vector< float > > &vShapeDer, float timeOffset=0, float timeBinWidth=25./24.)
Definition: LArShapeComplete.cxx:17
LArOFCAlg::perChannelData_t::chid
HWIdentifier chid
Definition: LArOFCAlg.h:68
LArOFCAlg::m_timeShiftByIndex
IntegerProperty m_timeShiftByIndex
Definition: LArOFCAlg.h:128
LArOFCAlg::perChannelData_t::tstart
float tstart
Definition: LArOFCAlg.h:81
LArOFCAlg::m_larPhysWaveBin
const LArOFCBinComplete * m_larPhysWaveBin
Definition: LArOFCAlg.h:144
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
LArOnlineID
Definition: LArOnlineID.h:20
CaloGain::LARHIGHGAIN
@ LARHIGHGAIN
Definition: CaloGain.h:18
LArOnline_SuperCellID
Definition: LArOnline_SuperCellID.h:20
LArOFCAlg::m_dPhases
UnsignedIntegerProperty m_dPhases
Definition: LArOFCAlg.h:135
CaloGain::CaloGain
CaloGain
Definition: CaloGain.h:11
LArOFCAlg::m_cablingKeySC
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKeySC
Definition: LArOFCAlg.h:53
LArOFCAlg::LArOFCAlg
LArOFCAlg(const std::string &name, ISvcLocator *pSvcLocator)
Definition: LArOFCAlg.cxx:40
python.PyAthena.v
v
Definition: PyAthena.py:154
LArWaveHelper.h
LArOFCAlg::m_waveCnt_nc
LArCaliWaveContainer * m_waveCnt_nc
Definition: LArOFCAlg.h:131
CaloDetDescrElement::getSampling
CaloCell_ID::CaloSample getSampling() const
cell sampling
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:395
LArConditionsContainer::initialize
virtual StatusCode initialize()
Initialization done after creation or read back - derived classes may augment the functionality.
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
AthCommonMsg< Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
LArConditionsContainer::begin
ConstConditionsMapIterator begin(unsigned int gain) const
get iterator for all channels for a gain
LArWaveCumul.h
LArOFCAlg::m_readDSPConfig
BooleanProperty m_readDSPConfig
Definition: LArOFCAlg.h:166
LArWaveHelper::derive_smooth
LArWave derive_smooth(const LArWave &theWave) const
smoothed derivative
Definition: LArWaveHelper.cxx:274
LArOFCAlg::m_caloMgrKey
SG::ReadCondHandleKey< CaloDetDescrManager > m_caloMgrKey
Definition: LArOFCAlg.h:55
LArOnline_SuperCellID.h
LArPhysCaliTdiffComplete.h
CaloDetDescrElement::eta
float eta() const
cell eta
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:344
LArDigits2NtupleDumper.nSamples
nSamples
Definition: LArDigits2NtupleDumper.py:85
LArOFCAlg::m_nPhases
UnsignedIntegerProperty m_nPhases
Definition: LArOFCAlg.h:134
LArOFCAlg::m_useDeltaV2
IntegerProperty m_useDeltaV2
Definition: LArOFCAlg.h:161
LArOFCComplete::dumpOFC
void dumpOFC(const std::string &output_file_name) const
Definition: LArOFCComplete.cxx:92
LArOFCBinComplete::set
void set(const HWIdentifier &chid, const int &gain, const int &bin)
Definition: LArOFCBinComplete.cxx:11
LArOFCAlg::m_ofcKey
StringProperty m_ofcKey
Definition: LArOFCAlg.h:151
LArOnlineID_Base::channel_name
std::string channel_name(const HWIdentifier id) const
Return a string corresponding to a feedthrough name given an identifier.
Definition: LArOnlineID_Base.cxx:219
CaloGain.h
LArOFCAlg::perChannelData_t::timeBinWidthOFC
float timeBinWidthOFC
Definition: LArOFCAlg.h:82
CaloCell_ID_FCS::FCAL0
@ FCAL0
Definition: FastCaloSim_CaloCell_ID.h:40
LArOFCAlg::perChannelData_t::phasewMaxAt3
unsigned phasewMaxAt3
Definition: LArOFCAlg.h:83
LArOFCAlg::m_shapeKey
StringProperty m_shapeKey
Definition: LArOFCAlg.h:153
LArOFCAlg::m_storeMaxPhase
BooleanProperty m_storeMaxPhase
Definition: LArOFCAlg.h:154
LArOFCAlg::stop
virtual StatusCode stop()
Definition: LArOFCAlg.cxx:113
CaloCondBlobAlgs_fillNoiseFromASCII.blob
blob
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:96
LArOFCAlg::initialize
StatusCode initialize()
Definition: LArOFCAlg.cxx:46
fitman.k
k
Definition: fitman.py:528
LArOnlineID.h
LArConditionsContainer::correctionsApplied
bool correctionsApplied() const
Have corrections been applied?
LArOnOffIdMapping
Definition: LArOnOffIdMapping.h:20
Identifier
Definition: IdentifierFieldParser.cxx:14