#include <LArStripsCrossTalkCorrector.h>

Inheritance diagram for LArStripsCrossTalkCorrector:

Collaboration diagram for LArStripsCrossTalkCorrector:

Classes
struct	neighbour_t

Public Member Functions
virtual StatusCode	initialize () override final

virtual StatusCode	execute () override final

virtual StatusCode	finalize () override final

	AthAlgorithm (const std::string &name, ISvcLocator *pSvcLocator)
	Constructor with parameters: More...

virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...

virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)

void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	initKnownMissingFebs ()

size_t	getEtaIndex (const Identifier) const

size_t	getPhiIndex (const Identifier) const

void	correctSamples (std::vector< double > &dest, const neighbour_t &neighbor) const

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Static Private Member Functions
static std::string	printMaxSample (const LArAccumulatedCalibDigit *thisDig)

Private Attributes
SG::ReadCondHandleKey< LArBadChannelCont >	m_BCKey {this, "BadChanKey", "LArBadChannel", "SG key for LArBadChan object"}

SG::ReadCondHandleKey< LArBadFebCont >	m_BFKey {this, "MissingFEBKey", "LArBadFeb", "SG key for miffing FEB object"}

SG::ReadCondHandleKey< LArOnOffIdMapping >	m_cablingKey {this, "OnOffMap", "LArOnOffIdMap", "SG key for mapping object"}

Gaudi::Property< std::vector< std::string > >	m_dontUseForCorr {this,"DontUseForXtalkCorr",{}, "Types of bad channel should not be taken into accout for xtalk correction of their neighbor"}

LArBadChannelMask	m_dontUseForCorrMask

Gaudi::Property< std::vector< std::string > >	m_dontCorr {this,"NoXtalkCorr",{}, "Types of bad channel should be ignored and not x-talk corrected"}

LArBadChannelMask	m_dontCorrMask

const LArOnlineID *	m_onlineHelper {nullptr}

const LArEM_ID *	m_emId {nullptr}

unsigned int	m_event_counter =0

const unsigned int	m_MAXphi =64

int	m_nStrips =-1

Gaudi::Property< std::vector< std::string > >	m_keylist {this,"KeyList",{},"List of input keys ('HIGH','MEDIUM','LOW')"}

Gaudi::Property< unsigned int >	m_ADCsatur {this,"ADCsaturation",0,"Cutoff value to ignore saturated digits"}

Gaudi::Property< float >	m_acceptableDifference {this,"AcceptableDifference",20, "For sanity check: By how much the corrected value may differ from the original one (in %)"}

SG::ReadCondHandleKey< ILArPedestal >	m_pedKey {this,"PedestalKey","Pedestal","Key of Pedestal object"}

uint16_t	m_fatalFebErrorPattern {0xffff}

const size_t	m_noIdx {9999999}

std::array< std::vector< std::vector< const LArAccumulatedCalibDigit * > >, 2 >	m_stripsLookUp

std::array< std::vector< std::bitset< 128 > >, 2 >	m_knownMissingFebs

bool	m_missingFEBsDone =false

std::set< HWIdentifier >	m_uncorrectedIds

XtalkCorrHisto	m_differences {6,0.3}

DataObjIDColl	m_extendedExtraObjects

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Static Private Attributes
static constexpr auto	m_MAXeta =std::to_array<unsigned>({448,208})

static constexpr auto	m_MINeta =std::to_array<unsigned>({1,0})

Detailed Description

Definition at line 58 of file LArStripsCrossTalkCorrector.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Function Documentation

◆ AthAlgorithm()

AthAlgorithm::AthAlgorithm

Constructor with parameters:

Definition at line 51 of file AthAlgorithm.cxx.

                                                        :
   ::AthCommonDataStore<AthCommonMsg<Algorithm>>   ( name, pSvcLocator )
 {
   // Set up to run AthAlgorithmDHUpdate in sysInitialize before
   // merging dependency lists.  This extends the output dependency
   // list with any symlinks implied by inheritance relations.
   m_updateDataHandles =
     std::make_unique<AthenaBaseComps::AthAlgorithmDHUpdate>
     (m_extendedExtraObjects,
      std::move (m_updateDataHandles));
 }

◆ correctSamples()

void LArStripsCrossTalkCorrector::correctSamples	(	std::vector< double > &	dest,
		const neighbour_t &	neighbor
	)		const

inlineprivate

Definition at line 138 of file LArStripsCrossTalkCorrector.h.

                                                                                                                                        {
   const size_t nSamples=std::min(dest.size(),nb.dig->sampleSum().size());
   const double pedTimesTrig=nb.ped*(double)nb.dig->nTriggers();
   for (size_t i=0;i<nSamples;++i) {
     dest[i]+=nb.weight*(nb.dig->sampleSum()[i]-pedTimesTrig);
   }
   return;
 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleKeyArrayType &
	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
  
   }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleKeyType &
	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
  
   }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleType &
	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
   }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	t,
		const SG::NotHandleType &
	)

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                  {
     typedef typename SG::HandleClassifier<T>::type htype;
     return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
   }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( ) const

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode LArStripsCrossTalkCorrector::execute ( )

finaloverridevirtual

Definition at line 56 of file LArStripsCrossTalkCorrector.cxx.

 { 
   if ( m_event_counter < 100 || ( m_event_counter < 1000 && m_event_counter%100==0 ) || m_event_counter%1000==0 )
     ATH_MSG_INFO( "Processing event " << m_event_counter );
   ++m_event_counter;
   
   if (m_keylist.size()==0) {
     ATH_MSG_ERROR( "Key list is empty! No containers to process!" );
     return StatusCode::FAILURE;
   }
   
  
   StatusCode sc;
   unsigned nSaturation=0;
  
   const LArFebErrorSummary* febErrSum=nullptr;
   if (evtStore()->contains<LArFebErrorSummary>("LArFebErrorSummary")) {
     sc=evtStore()->retrieve(febErrSum);
     if (sc.isFailure()) {
       ATH_MSG_ERROR( "Failed to retrieve FebErrorSummary object!" );
       return sc;
     }
   }
   else
     if (m_event_counter==1)
       ATH_MSG_WARNING( "No FebErrorSummaryObject found! Feb errors not checked!" );
  
   SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKey};
   const LArOnOffIdMapping* cabling{*cablingHdl};
   if(!cabling) {
      ATH_MSG_ERROR( "Do not have cabling object LArOnOffIdMapping");
      return StatusCode::FAILURE;
   }
  
   SG::ReadCondHandle<LArBadChannelCont> bcHdl{m_BCKey};
   const LArBadChannelCont* bcCont{*bcHdl};
  
   SG::ReadCondHandle<ILArPedestal> pedHdl{m_pedKey};
   const ILArPedestal* larPedestal=*pedHdl; 
  
  
   const LArAccumulatedCalibDigitContainer* larAccumulatedCalibDigitContainer;
   
   // now start to deal with digits   
  
   for (const std::string& key : m_keylist) { // Loop over all containers that are to be processed (e.g. different gains)
     
     sc = evtStore()->retrieve(larAccumulatedCalibDigitContainer,key);
     if (sc.isFailure()){ 
       ATH_MSG_WARNING( "Cannot read LArAccumulatedCalibDigitContainer from StoreGate! key=" << key );
       continue; // Try next container
     }
     
  
     LArAccumulatedCalibDigit febErrorDummy; //Use the address of this object to mark cells belonging to a errornous FEB
     LArAccumulatedCalibDigit inexistingDummy; //Use the address of this object for "cells" that would be outside of cryostat
     
     
     HWIdentifier  lastFailedFEB(0);
  
     if(larAccumulatedCalibDigitContainer->empty()) {
       ATH_MSG_DEBUG( "LArAccumulatedCalibDigitContainer with key = " << key << " is empty " );
       //return StatusCode::SUCCESS;
       continue; // Try next container
     } else {
       ATH_MSG_DEBUG( "Processing LArAccumulatedCalibDigitContainer with key = " << key
              << ". Size: " << larAccumulatedCalibDigitContainer->size() );
     }
     
     //Fill missing febs (if not done yet)
     if (!m_missingFEBsDone) {
       ATH_CHECK(initKnownMissingFebs());
     }
     
       
     //Reset strips lookup table to nullptr:
     for (int bec : {0,1}) {
       for (unsigned ieta=0;ieta!=m_MAXeta[bec];++ieta) {  //Loop over Strips cells
         for (unsigned iphi=0;iphi!=m_MAXphi;++iphi) {  //Loop over Strips cells    
           for (unsigned iside=0;iside<2;++iside) {
               m_stripsLookUp[bec][iphi+iside*m_MAXphi][ieta]=nullptr;
           }
         }
       }    
     } //end loop over barrel & EC
     ATH_MSG_DEBUG( "Filling strips lookup table..." ) ;
     int nStrips=0;
     
     for (const LArAccumulatedCalibDigit* dig : *larAccumulatedCalibDigitContainer) {  //Loop over all cells to fill Strips lookup table
       const HWIdentifier chid=dig->hardwareID();     
       if (!(m_onlineHelper->isEMBchannel(chid) || m_onlineHelper->isEMECchannel(chid))) continue; //Deal only with EM calos case
       if (!cabling->isOnlineConnected(chid)) continue; //ignore disconnected channels
       
  
       const Identifier id=cabling->cnvToIdentifier(chid);
       if (m_emId->sampling(id)!=1) continue; //Deal only with strips
     
       const HWIdentifier febid=m_onlineHelper->feb_Id(chid);
       if (febErrSum) {
           const uint16_t febErrs=febErrSum->feb_error(febid);
            if (febErrs & m_fatalFebErrorPattern) {
              if (febid!=lastFailedFEB) {
               lastFailedFEB=febid;
                ATH_MSG_ERROR( "Event " << m_event_counter << " Feb " <<  m_onlineHelper->channel_name(febid) 
                   << " reports error(s):" << febErrSum->error_to_string(febErrs) << ". Data ignored." );
             }   
             dig=&febErrorDummy;
           } //end if fatal feb error
       }//end if check feb error summary
  
  
       const int bec=m_onlineHelper->barrel_ec(chid);  
       const size_t ieta=getEtaIndex(id);
       if (ieta==m_noIdx) continue; //Not a cell we care about
       const size_t iphi=getPhiIndex(id);
       if (iphi>=2*m_MAXphi || ieta>=m_MAXeta[bec]) {
           ATH_MSG_FATAL( "Array index out of range: iphi=" <<  iphi << " (max " << m_MAXphi << "), ieta=" 
                             << ieta << "(max " << m_MAXeta[bec] << ")" );
           return StatusCode::FAILURE;
       }
       ++nStrips;
  
  
       //check for saturation:
       bool saturated=false;
       if (m_ADCsatur>0) {
     const std::vector<uint64_t>& samples=dig->sampleSum();
     const size_t& nS=samples.size();
     const uint32_t maxValue=(uint32_t)(m_ADCsatur*dig->nTriggers());
     for (size_t i=0;i<nS;++i) {
       if (samples[i] >= maxValue) {
         saturated=true;
         ATH_MSG_DEBUG("Found saturating digit (index = " << i           
               << ", <ADC> = " << samples[i]/dig->nTriggers()
               << ", DAC = " << dig->DAC()
               << ") for channel 0x"  << MSG::hex << chid.get_compact() << MSG::dec
               << ". Skipping.");
         break;
       }//end if>maxvalue
     }//end loop over digits
       }
       if (saturated) {
     ++nSaturation;
     continue; //Skip this channel
       }
      
     m_stripsLookUp[bec][iphi][ieta]=dig;
  
     }//End loop over all cells
     
     if (m_nStrips<0) 
       m_nStrips=nStrips;
     
     if (m_nStrips != nStrips) {
       ATH_MSG_WARNING( "Number of strips changed! Have " <<  nStrips << ", had " << m_nStrips << " before.");
       m_nStrips=nStrips;
     }
     else
       ATH_MSG_DEBUG("strips lookup table filled. Have " <<  nStrips << " out of " << 2*m_MAXphi*(1+m_MAXeta[0]-m_MINeta[0]) 
               << " barrel channels plus " << 2*m_MAXphi*(1+m_MAXeta[1]-m_MINeta[1]) << "endcap channels.");
  
  
     //Weight for the four neighbors: 
     //only half the signal of the next-to-next neihbor is summed 
     //A more correct approach would be to check if the 'mirrored' neighbor is pulsed as well and compute this weights on-the-fly
     //const float weight[4]={0.5,1,1,0.5};
     neighbour_t neighbours[4]={}; //Keep pointers for the four neightbors
     neighbours[0].dist=-2;
     neighbours[1].dist=-1;
     neighbours[2].dist=1;
     neighbours[3].dist=2;
  
     for (unsigned bec : {0,1}) { //Loop over barrel and endcap
       for (unsigned iside=0; iside<2; iside++) {          //Loop over both sides of the detector
         for (int ieta=0; ieta<(int)m_MAXeta[bec]; ieta++) {    // Loop over eta range
       for (unsigned iphi=0; iphi<m_MAXphi; iphi++) {  // Loop over phi range
         const unsigned iphi2=iphi+m_MAXphi*iside;    //Phi index inside lookup table 
         const LArAccumulatedCalibDigit* currDig=m_stripsLookUp[bec][iphi2][ieta];
         if (currDig==nullptr || currDig==&febErrorDummy) continue; //Digit not found or FEB in error: ignore
         
         if ( currDig->isPulsed() ) {
           HWIdentifier chid = currDig->hardwareID();
           CaloGain::CaloGain t_gain = currDig->gain();
           if (m_dontCorrMask.cellShouldBeMasked(bcCont,chid)) {
         ATH_MSG_DEBUG("Strip " << m_onlineHelper->channel_name(chid) <<" (Eta = " << ieta << ", Phi = " 
                   << iphi2 << ") should not be touched accoring to jobConfig");
         continue;
           }
  
           const unsigned NtotSamples = currDig->nsamples(); 
           const unsigned NbTriggers = currDig->nTriggers();     
           ATH_MSG_VERBOSE("Now processing strip "<< m_onlineHelper->channel_name(chid) << " (Eta = " << ieta << ", Phi = " << iphi2 << ")");
  
           //Fill the pointers and pedestal in the 'neighbours' array
           for (unsigned i=0;i<4;i++) {
         //Set all zero to start with...
         neighbours[i].dig=nullptr;
         neighbours[i].ped=0.;
         const int neigbEtaItx=neighbours[i].dist+(int)ieta;
         //Check if we are supposed to have this neighbour
         if (neigbEtaItx<(int)m_MINeta[bec] || neigbEtaItx>=(int)m_MAXeta[bec]) {
           ATH_MSG_DEBUG("Neighbour " << neighbours[i].dist <<" , ieta=" << neigbEtaItx 
                 << " doesn't exist. (min="<< m_MINeta[bec] << " ,max=" << m_MAXeta[bec] <<  ")");
           neighbours[i].dig=&inexistingDummy;
           continue;
         }
         const LArAccumulatedCalibDigit* neighDig=m_stripsLookUp[bec][iphi2][neigbEtaItx];
         //Check if neighbour is present
         if (!neighDig) {
           //neighbor missing. Could be known missing FEB or new problem
           //Reported only if at least WARNING
           if (msgLvl(MSG::WARNING)) {
             if (m_knownMissingFebs[bec][neigbEtaItx].test(iphi2)) {
               ATH_MSG_DEBUG("FEB missing for neighbour " << neighbours[i].dist << " to be added to strip 0x" 
                     << m_onlineHelper->channel_name(chid) << " (Eta = " << ieta << ", Phi = " << iphi << ")");
             }
             else {
               ATH_MSG_WARNING( "Cannot find neighbour " << neighbours[i].dist << " to be added to strip 0x" 
                        << m_onlineHelper->channel_name(chid) << " (Eta = " << ieta << ", Phi = " << iphi << ")" );
             } 
           }//end if msgLvl(WARNING)
           continue;
         }//end if !neighDIg
         if (neighDig==&febErrorDummy) { //Pointer comparison!!
           ATH_MSG_WARNING("Neighbour " << neighbours[i].dist << " of strip " << m_onlineHelper->channel_name(chid)
                   << " (Eta = " << ieta << ", Phi = " << iphi <<"), has a FEB error. Ignored.");
           continue;
         }
         
         //Check if neighbour is pulsed
         if (neighDig->isPulsed()) {
           ATH_MSG_WARNING( "Neighbour " << neighbours[i].dist << " of strip " << m_onlineHelper->channel_name(chid)
                    << " (Eta = " << ieta << ", Phi = " << iphi <<", " << printMaxSample(neighDig) 
                    << ") is pulsed. Not used for correction." );
           continue;
         }
         
         //Check if neighbour is on the bad-channel list
         if (m_dontUseForCorrMask.cellShouldBeMasked(bcCont,neighDig->hardwareID())) {
           ATH_MSG_DEBUG("Neighbour " << neighbours[i].dist << " of strip " << m_onlineHelper->channel_name(chid) 
                 << " (Eta = " << ieta << ", Phi = " << iphi 
                 << ") is flagged by the LArBadChannelMaskingTool. Not used for correction.");
           continue;
         }
  
         //Get Pedestal
         const float pedestal = larPedestal->pedestal(neighDig->hardwareID(),t_gain);
         if (pedestal <= (1.0+LArElecCalib::ERRORCODE)) {
           ATH_MSG_ERROR( "No pedestal are available for neighbour " << neighbours[i].dist << " of strip " 
                  << m_onlineHelper->channel_name(chid) << " (Eta = " << ieta << ", Phi = " << iphi << "). Not used for correction!" );
           continue;
         }
         //All went ok, fill struct
         neighbours[i].dig=neighDig;
         neighbours[i].ped=pedestal;
  
         //The weight is one, unless the neighbor-of-the-neighbor is pulsed too
         neighbours[i].weight=1.0;   
         //Now check if the neighbor-of-the-neighbor is pulsed to set a different weight.
         const int nnEta=ieta+2*neighbours[i].dist;
         if (nnEta>=(int)m_MINeta[bec] && nnEta<(int)m_MAXeta[bec]) {
           const LArAccumulatedCalibDigit* nnDig=m_stripsLookUp[bec][iphi2][nnEta];
           if (nnDig!=nullptr) {
             //Could be also FebErrorDummy (which will always pretentd to be not pulsed)
             if (nnDig->isPulsed()) {
               ATH_MSG_VERBOSE("Neighbour " << neighbours[i].dist << " of strip " << m_onlineHelper->channel_name(chid) 
                       << " has another pulsed cell in the neighborhood. Setting weight to 0.5");
               neighbours[i].weight=0.5;
             }//end if isPulsed
           }//end if neighbor-of-neighbor not NULL
         }//end if neighbor-of-neighbor in eta range
           }//End loop over four neighbours
  
  
           //Now loop over samples to apply xtalk correction
           std::vector<double> SampleSums(NtotSamples);
           for (std::size_t SampleIndex=0;SampleIndex<NtotSamples; ++SampleIndex ) {
         SampleSums[SampleIndex]=(double)currDig->sampleSum()[SampleIndex];
         ATH_MSG_VERBOSE("SampleSum " << SampleIndex << " (" << SampleSums[SampleIndex] << " ADC counts / " << NbTriggers << " Ntriggers)");
           }
           //Loop over the neighbours and apply corrections
           for (unsigned i=0;i<4;i++) {   
         if (neighbours[i].dig==&inexistingDummy) { //Pointer comparision!
           ATH_MSG_VERBOSE("Neighbour " << neighbours[i].dist << " of strip " << m_onlineHelper->channel_name(chid) 
                   << " (Eta = " << ieta << ", Phi = " << iphi << ") does not exist.");
           //no neighbor (end of calorimeter). Do nothing
           continue;
         }
           
         if (neighbours[i].dig) { //"Normal" case
           correctSamples(SampleSums,neighbours[i]);
           ATH_MSG_VERBOSE("Neighbour " << neighbours[i].dist << " of strip " << m_onlineHelper->channel_name(chid) 
                   << " (Eta = " << ieta << ", Phi = " << iphi << ") is used for correction");
         } //end if have pointer to neighbor cell
         else { //Neighbor not usable for some reason, try mirrored neighbor
           const int j = 3-i; //get mirrored neighbor
           ATH_MSG_INFO( "Neighbour " << neighbours[i].dist << " of strip " << m_onlineHelper->channel_name(chid) 
                 << " cannot be used. Taking mirrored neighbour " << neighbours[j].dist << " instead." );
           if (neighbours[j].dig!=nullptr && neighbours[j].dig!=&inexistingDummy){
             correctSamples(SampleSums,neighbours[j]);
             ATH_MSG_VERBOSE("Mirrored neighbour " << neighbours[j].dist << " of strip " << m_onlineHelper->channel_name(chid) 
                     << " (Eta = " << ieta << ", Phi = " << iphi << ") is used for correction");
           }//end if neighbours[j].dig
           else {
             ATH_MSG_WARNING( "Mirrored Neighbour " << neighbours[j].dist << " of strip " << m_onlineHelper->channel_name(chid) 
                      << " cannot be used too. No correction applied" );
           } 
         }//end if no neighboring cell
           }//end loop over the four neighbors
         
         
         std::vector<uint64_t> SampleSumInt(NtotSamples);
         bool unresonable=false;
         std::size_t iPeak=std::max_element(currDig->sampleSum().begin(),currDig->sampleSum().end())-currDig->sampleSum().begin();
         for (std::size_t SampleIndex=0;SampleIndex<NtotSamples; ++SampleIndex ) {
           const double& thisSampleSum=SampleSums[SampleIndex];
           const uint32_t& oldVal=currDig->sampleSum()[SampleIndex];
           if (thisSampleSum<0) {
         unresonable=true;
         ATH_MSG_WARNING( "Channel 0x"  << MSG::hex << chid.get_compact() << MSG::dec
                   << " (Eta = " << ieta << ", Phi = " << iphi << ") Resulting ADC sample " << SampleIndex <<" negative! " 
                   << thisSampleSum << " instead of " << oldVal << " Not corrected." );
         break;
           }
  
         if (SampleIndex==iPeak) { //check value of correction at peak
           const float dev=(thisSampleSum-oldVal)/oldVal;
           m_differences.add(currDig,dev);
           if (std::fabs(dev)>m_acceptableDifference) {
             unresonable=true;
             ATH_MSG_WARNING("Strip " << m_onlineHelper->channel_name(chid) << " (Eta = " << ieta << ", Phi = " << iphi
                     << ") DAC=" << currDig->DAC() << ":  Resulting ADC sample " << SampleIndex <<" looks unreasonable: " 
                     << thisSampleSum << " instead of " << oldVal << " (off by " << dev*100 << "%)" 
                     << " (=" << thisSampleSum/NbTriggers << " -> " << oldVal/NbTriggers <<", ped=" 
                     << larPedestal->pedestal(chid,t_gain)
                     << " Not Corrected.");
             break;
           }//end if dev>m_acceptableDifference
         } // end if at peak sample
           SampleSumInt[SampleIndex] = (uint64_t)(thisSampleSum);
         }//End loop over samples
  
      
           if (unresonable) {
         m_uncorrectedIds.insert(chid);
         ATH_MSG_DEBUG("Correction for channel " << m_onlineHelper->channel_name(chid) << " failed");
           }
           else {
         ATH_MSG_VERBOSE("Correction for channel " << m_onlineHelper->channel_name(chid) << " DAC="<<currDig->DAC() << " succeeded " 
                 << currDig->sampleSum()[2] << "->" << SampleSumInt[2]);
         // FIXME: const_cast, modifying object in SG.
         const_cast<LArAccumulatedCalibDigit*>(currDig)->setSampleSum(SampleSumInt);
           }      
         }// end if-pulsed 
       }//end loop over phi
     }//end loop over eta
       }//End loop over sides
     }//End loop over barrel-EC   
   } //End loop over all containers    
  
   if (nSaturation) {
     ATH_MSG_INFO( "Found " << nSaturation << " saturating digits in this event." );
   }
   return StatusCode::SUCCESS;
 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

 {
   // If we didn't find any symlinks to add, just return the collection
   // from the base class.  Otherwise, return the extended collection.
   if (!m_extendedExtraObjects.empty()) {
     return m_extendedExtraObjects;
   }
   return Algorithm::extraOutputDeps();
 }

◆ finalize()

StatusCode LArStripsCrossTalkCorrector::finalize ( )

finaloverridevirtual

Definition at line 424 of file LArStripsCrossTalkCorrector.cxx.

                                                  { 
   if (msgLvl(MSG::WARNING) && !m_uncorrectedIds.empty() ) {
     const LArBadChanBitPacking packing;
     ATH_MSG_WARNING( "The following "<<  m_uncorrectedIds.size() << " channels are (partly) uncorrected because of unresonable high correction:" );
     SG::ReadCondHandle<LArBadChannelCont> bcHdl{m_BCKey};
     const LArBadChannelCont* bcCont{*bcHdl};
     if(bcCont) {
        std::set<HWIdentifier>::const_iterator it=m_uncorrectedIds.begin();
        std::set<HWIdentifier>::const_iterator it_e=m_uncorrectedIds.end();
        for (;it!=it_e;++it) {
          LArBadChannel bc=bcCont->status(*it);
          ATH_MSG_WARNING( "Not corrected: " << m_onlineHelper->channel_name(*it) << " " << packing.stringStatus(bc) );
        }
     }
   }         
  
   m_differences.print(msg(),m_onlineHelper);
  
   return StatusCode::SUCCESS;
 }

◆ getEtaIndex()

size_t LArStripsCrossTalkCorrector::getEtaIndex ( const Identifier id ) const

inlineprivate

Definition at line 147 of file LArStripsCrossTalkCorrector.h.

                                                                                 {
   if (m_emId->sampling(id)!=1) return m_noIdx; //Deal only with layer 1
   const int region = m_emId->region(id);
   const int keta = m_emId->eta(id);
   if (abs(m_emId->barrel_ec(id))== 1) { // Barrel case
     if (region==0)
       return keta;
     else
       return m_noIdx;
   }// end if barrel
   else if (abs(m_emId->barrel_ec(id))== 2) {  //Endcap case
     switch (region) {
     case 2:
       return keta;
       break;
     case 3: 
       return keta+96;
       break;
     case 4:
       return keta+144;
       break;
     default:
       return m_noIdx;
       break;
     }   
   }// end if endcap
   return m_noIdx; //endcap OW or unknown region
 }

◆ getPhiIndex()

size_t LArStripsCrossTalkCorrector::getPhiIndex ( const Identifier id ) const

inlineprivate

Definition at line 176 of file LArStripsCrossTalkCorrector.h.

                                                                                 {
    const int kphi = m_emId->phi(id);
    const int kside=m_emId->barrel_ec(id)>0; 
    return kphi+kside*m_MAXphi;
  }

◆ initialize()

StatusCode LArStripsCrossTalkCorrector::initialize ( )

finaloverridevirtual

Definition at line 18 of file LArStripsCrossTalkCorrector.cxx.

                                                    {
  
   StatusCode sc = detStore()->retrieve(m_onlineHelper, "LArOnlineID");
   if (sc.isFailure()) {
     ATH_MSG_ERROR( "Could not get LArOnlineID helper !" );
     return StatusCode::FAILURE;
   }
   
   sc = detStore()->retrieve(m_emId, "LArEM_ID");
   if (sc.isFailure()) {
     ATH_MSG_ERROR( "Could not get LArEM_ID helper !" );
     return StatusCode::FAILURE;
   }
   
  
   ATH_CHECK(m_dontUseForCorrMask.buildBitMask(m_dontUseForCorr,msg()));
   ATH_CHECK(m_dontCorrMask.buildBitMask(m_dontCorr,msg()));
  
   ATH_CHECK(m_BCKey.initialize());
   ATH_CHECK(m_BFKey.initialize());
   ATH_CHECK(m_cablingKey.initialize());
   ATH_CHECK(m_pedKey.initialize());
   
   m_acceptableDifference.value()/=100; //Convert from % to fraction
  
   //Initialize strips lookup table:
   for (unsigned bec : {0,1}) {
     m_stripsLookUp[bec].resize(2*m_MAXphi); //change index to coded index
     for (unsigned iside=0;iside<2;++iside) {
       for (unsigned iphi=0; iphi!=m_MAXphi; ++iphi) {
           m_stripsLookUp[bec][iphi+iside*m_MAXphi].resize(m_MAXeta[bec],nullptr); 
       }   
     }
   }
   return StatusCode::SUCCESS;
 }

◆ initKnownMissingFebs()

StatusCode LArStripsCrossTalkCorrector::initKnownMissingFebs ( )

private

Definition at line 456 of file LArStripsCrossTalkCorrector.cxx.

                                                              {
 unsigned nMissing=0;  
  
   for (unsigned bec : {0,1}) {    
     m_knownMissingFebs[bec].clear();
     m_knownMissingFebs[bec].resize(m_MAXeta[bec]);
   }
   
   //const std::vector<HWIdentifier> mf=m_badChannelTool->missingFEBs();
   SG::ReadCondHandle<LArBadFebCont> bfHdl{m_BFKey};
   const LArBadFebCont* bfCont{*bfHdl};
   if(!bfCont) {
      ATH_MSG_ERROR( "Do not have missing FEBs " << m_BFKey.key() );
      return StatusCode::FAILURE;
   }
   SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKey};
   const LArOnOffIdMapping* cabling{*cablingHdl};
   if(!cabling) {
      ATH_MSG_ERROR( "Do not have cabling object LArOnOffIdMapping");
      return StatusCode::FAILURE;
   }
  
   LArBadChannelDBTools::BadFebVec mf;
   for (const auto& entry : bfCont->fullCont()) {
       const HWIdentifier hid=HWIdentifier(entry.first);
       mf.emplace_back(LArBadChannelDBTools::BadFebEntry(hid,entry.second));
   } 
  
   //ATH_MSG_DEBUG( "Got " << mf.size() << " missing FEBs" );
   LArBadChannelDBTools::BadFebVec::const_iterator it=mf.begin();
   LArBadChannelDBTools::BadFebVec::const_iterator it_e=mf.end();
   for (;it!=it_e;++it) {
     const HWIdentifier& fid=it->first;
     const LArBadFeb& bf=it->second;
     if (bf.deadAll() || bf.deadReadout() || bf.deactivatedInOKS()) {
       if (m_onlineHelper->isEMBchannel(fid) || m_onlineHelper->isEMECchannel(fid)) {
           ATH_MSG_DEBUG( "Feb  " << MSG::hex << fid.get_compact() << MSG::dec << " reported as missing" );
           const int nChan=m_onlineHelper->channelInSlotMax(fid);
         const unsigned bec=m_onlineHelper->barrel_ec(fid);
           for (int c=0;c<nChan;++c) {
             const HWIdentifier chid=m_onlineHelper->channel_Id(fid,c);
             const Identifier id=cabling->cnvToIdentifier(chid);
             const size_t ieta=getEtaIndex(id);
             if (ieta==m_noIdx) continue; //Not a cell we care about
             const size_t iphi=getPhiIndex(id);
             if (iphi>=2*m_MAXphi || ieta>=m_MAXeta[bec]) {
               ATH_MSG_FATAL( "Array index out of range: iphi=" << iphi << " (max " << m_MAXphi << "), ieta=" 
                     << ieta << "(max " << m_MAXeta[bec] << ")" );
               return StatusCode::FAILURE;
             }
             m_knownMissingFebs[bec][ieta].set(iphi);
             ++nMissing;
           }//end loop over channels of one feb
       }//end if is barrel/endcap & EM
     }//end if is dead
   }//end loop over problematic febs
   ATH_MSG_INFO( "Number of known missing strip cells: "<< nMissing );
   m_missingFEBsDone=true;
   return StatusCode::SUCCESS;
 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ msg() [1/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                                {
     return this->msgLevel(lvl);
   }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ printMaxSample()

std::string LArStripsCrossTalkCorrector::printMaxSample ( const LArAccumulatedCalibDigit * thisDig )

staticprivate

Definition at line 446 of file LArStripsCrossTalkCorrector.cxx.

                                                                                               {
  
   const std::vector<uint64_t>& ss=thisDig->sampleSum();
   std::vector<uint64_t>::const_iterator imax=std::max_element(ss.begin(),ss.end());
   std::ostringstream output;
   output << "S[" << imax-ss.begin() << "]=" << *imax/thisDig->nTriggers(); 
   return output.str();
 }

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

   {
     h.renounce();
     PBASE::renounce (h);
   }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                           {
     handlesArray.renounce();
   }

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, PyAthena::Alg, and AthHistogramAlgorithm.

Definition at line 66 of file AthAlgorithm.cxx.

                                        {
   StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
  
   if (sc.isFailure()) {
     return sc;
   }
   ServiceHandle<ICondSvc> cs("CondSvc",name());
   for (auto h : outputHandles()) {
     if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
       // do this inside the loop so we don't create the CondSvc until needed
       if ( cs.retrieve().isFailure() ) {
         ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
         return StatusCode::SUCCESS;
       }
       if (cs->regHandle(this,*h).isFailure()) {
         sc = StatusCode::FAILURE;
         ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                       << " with CondSvc");
       }
     }
   }
   return sc;
 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                                {
     // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
     //         << "  size: " << m_vhka.size() << endmsg;
     for (auto &a : m_vhka) {
       std::vector<SG::VarHandleKey*> keys = a->keys();
       for (auto k : keys) {
         k->setOwner(this);
       }
     }
   }

Member Data Documentation

◆ m_acceptableDifference

Gaudi::Property<float> LArStripsCrossTalkCorrector::m_acceptableDifference {this,"AcceptableDifference",20, "For sanity check: By how much the corrected value may differ from the original one (in %)"}

private

Definition at line 96 of file LArStripsCrossTalkCorrector.h.

◆ m_ADCsatur

Gaudi::Property<unsigned int> LArStripsCrossTalkCorrector::m_ADCsatur {this,"ADCsaturation",0,"Cutoff value to ignore saturated digits"}

private

Definition at line 95 of file LArStripsCrossTalkCorrector.h.

◆ m_BCKey

SG::ReadCondHandleKey<LArBadChannelCont> LArStripsCrossTalkCorrector::m_BCKey {this, "BadChanKey", "LArBadChannel", "SG key for LArBadChan object"}

private

Definition at line 71 of file LArStripsCrossTalkCorrector.h.

◆ m_BFKey

SG::ReadCondHandleKey<LArBadFebCont> LArStripsCrossTalkCorrector::m_BFKey {this, "MissingFEBKey", "LArBadFeb", "SG key for miffing FEB object"}

private

Definition at line 72 of file LArStripsCrossTalkCorrector.h.

◆ m_cablingKey

SG::ReadCondHandleKey<LArOnOffIdMapping> LArStripsCrossTalkCorrector::m_cablingKey {this, "OnOffMap", "LArOnOffIdMap", "SG key for mapping object"}

private

Definition at line 73 of file LArStripsCrossTalkCorrector.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_differences

XtalkCorrHisto LArStripsCrossTalkCorrector::m_differences {6,0.3}

private

Definition at line 124 of file LArStripsCrossTalkCorrector.h.

◆ m_dontCorr

Gaudi::Property<std::vector<std::string> > LArStripsCrossTalkCorrector::m_dontCorr {this,"NoXtalkCorr",{}, "Types of bad channel should be ignored and not x-talk corrected"}

private

Definition at line 80 of file LArStripsCrossTalkCorrector.h.

◆ m_dontCorrMask

LArBadChannelMask LArStripsCrossTalkCorrector::m_dontCorrMask

private

Definition at line 81 of file LArStripsCrossTalkCorrector.h.

◆ m_dontUseForCorr

Gaudi::Property<std::vector<std::string> > LArStripsCrossTalkCorrector::m_dontUseForCorr {this,"DontUseForXtalkCorr",{}, "Types of bad channel should not be taken into accout for xtalk correction of their neighbor"}

private

Definition at line 76 of file LArStripsCrossTalkCorrector.h.

◆ m_dontUseForCorrMask

LArBadChannelMask LArStripsCrossTalkCorrector::m_dontUseForCorrMask

private

Definition at line 79 of file LArStripsCrossTalkCorrector.h.

◆ m_emId

const LArEM_ID* LArStripsCrossTalkCorrector::m_emId {nullptr}

private

Definition at line 86 of file LArStripsCrossTalkCorrector.h.

◆ m_event_counter

unsigned int LArStripsCrossTalkCorrector::m_event_counter =0

private

Definition at line 87 of file LArStripsCrossTalkCorrector.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_fatalFebErrorPattern

uint16_t LArStripsCrossTalkCorrector::m_fatalFebErrorPattern {0xffff}

private

Definition at line 101 of file LArStripsCrossTalkCorrector.h.

◆ m_keylist

Gaudi::Property<std::vector<std::string> > LArStripsCrossTalkCorrector::m_keylist {this,"KeyList",{},"List of input keys ('HIGH','MEDIUM','LOW')"}

private

Definition at line 94 of file LArStripsCrossTalkCorrector.h.

◆ m_knownMissingFebs

std::array<std::vector < std::bitset< 128 > >,2> LArStripsCrossTalkCorrector::m_knownMissingFebs

private

Definition at line 110 of file LArStripsCrossTalkCorrector.h.

◆ m_MAXeta

constexpr auto LArStripsCrossTalkCorrector::m_MAXeta =std::to_array<unsigned>({448,208})

staticconstexprprivate

Definition at line 89 of file LArStripsCrossTalkCorrector.h.

◆ m_MAXphi

const unsigned int LArStripsCrossTalkCorrector::m_MAXphi =64

private

Definition at line 91 of file LArStripsCrossTalkCorrector.h.

◆ m_MINeta

constexpr auto LArStripsCrossTalkCorrector::m_MINeta =std::to_array<unsigned>({1,0})

staticconstexprprivate

Definition at line 90 of file LArStripsCrossTalkCorrector.h.

◆ m_missingFEBsDone

bool LArStripsCrossTalkCorrector::m_missingFEBsDone =false

private

Definition at line 112 of file LArStripsCrossTalkCorrector.h.

◆ m_noIdx

const size_t LArStripsCrossTalkCorrector::m_noIdx {9999999}

private

Definition at line 103 of file LArStripsCrossTalkCorrector.h.

◆ m_nStrips

int LArStripsCrossTalkCorrector::m_nStrips =-1

private

Definition at line 92 of file LArStripsCrossTalkCorrector.h.

◆ m_onlineHelper

const LArOnlineID* LArStripsCrossTalkCorrector::m_onlineHelper {nullptr}

private

Definition at line 85 of file LArStripsCrossTalkCorrector.h.

◆ m_pedKey

SG::ReadCondHandleKey<ILArPedestal> LArStripsCrossTalkCorrector::m_pedKey {this,"PedestalKey","Pedestal","Key of Pedestal object"}

private

Definition at line 99 of file LArStripsCrossTalkCorrector.h.

◆ m_stripsLookUp

std::array<std::vector < std::vector < const LArAccumulatedCalibDigit* > >,2> LArStripsCrossTalkCorrector::m_stripsLookUp

private

Definition at line 108 of file LArStripsCrossTalkCorrector.h.

◆ m_uncorrectedIds

std::set<HWIdentifier> LArStripsCrossTalkCorrector::m_uncorrectedIds

private

Definition at line 114 of file LArStripsCrossTalkCorrector.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:

Classes

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Member Function Documentation

◆ AthAlgorithm()

◆ correctSamples()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ finalize()

◆ getEtaIndex()

◆ getPhiIndex()

◆ initialize()

◆ initKnownMissingFebs()

◆ inputHandles()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ printMaxSample()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_acceptableDifference

◆ m_ADCsatur

◆ m_BCKey

◆ m_BFKey

◆ m_cablingKey

◆ m_detStore

◆ m_differences

◆ m_dontCorr

◆ m_dontCorrMask

◆ m_dontUseForCorr

◆ m_dontUseForCorrMask

◆ m_emId

◆ m_event_counter

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_fatalFebErrorPattern

◆ m_keylist

◆ m_knownMissingFebs

◆ m_MAXeta

◆ m_MAXphi

◆ m_MINeta

◆ m_missingFEBsDone

◆ m_noIdx

◆ m_nStrips

◆ m_onlineHelper

◆ m_pedKey

◆ m_stripsLookUp

◆ m_uncorrectedIds

◆ m_varHandleArraysDeclared

◆ m_vhka