LArStripsCrossTalkCorrector Class Reference

#include <LArStripsCrossTalkCorrector.h>

Inheritance 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:
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
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.

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, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

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)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
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	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

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()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & 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());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & 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.

{ return m_detStore; }

evtStore()

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.

{ 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()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

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, AthHistogramAlgorithm, and PyAthena::Alg.

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.

{this,"AcceptableDifference",20, "For sanity check: By how much the corrected value may differ from the original one (in %)"};

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.

{this,"ADCsaturation",0,"Cutoff value to ignore saturated digits"};

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.

{this, "BadChanKey", "LArBadChannel", "SG key for LArBadChan object"};

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.

{this, "MissingFEBKey", "LArBadFeb", "SG key for miffing FEB object"};

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.

{this, "OnOffMap", "LArOnOffIdMap", "SG key for mapping object"};

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.

{6,0.3};

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.

{this,"NoXtalkCorr",{}, "Types of bad channel should be ignored and not x-talk corrected"};

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.

{this,"DontUseForXtalkCorr",{}, "Types of bad channel should not be taken into accout for xtalk correction of their neighbor"};

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.

{nullptr};

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.

{0xffff};

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.

{this,"KeyList",{},"List of input keys ('HIGH','MEDIUM','LOW')"};

m_knownMissingFebs

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

private

Definition at line 110 of file LArStripsCrossTalkCorrector.h.

m_MAXeta

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

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.

{9999999};

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.

{nullptr};

m_pedKey

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

private

Definition at line 99 of file LArStripsCrossTalkCorrector.h.

{this,"PedestalKey","Pedestal","Key of Pedestal object"};

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:

• LArStripsCrossTalkCorrector.h
• LArStripsCrossTalkCorrector.cxx