LArCalibDigitsAccumulator Class Reference

Emulator of DSP code in accumulation calibration mode. More...

#include <LArCalibDigitsAccumulator.h>

Inheritance diagram for LArCalibDigitsAccumulator:

Collaboration diagram for LArCalibDigitsAccumulator:

Classes
class	LArAccumulated
	Class of intermediate accumulations. More...

Public Member Functions
	LArCalibDigitsAccumulator (const std::string &name, ISvcLocator *pSvcLocator)
StatusCode	initialize ()
StatusCode	execute ()
StatusCode	finalize ()
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
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	getPatternName (const std::string &gain, bool isPulsed, int delay, int dac)

Private Attributes
ToolHandle< ICaloSuperCellIDTool >	m_sc2ccMappingTool
SG::ReadCondHandleKey< LArCalibLineMapping >	m_calibMapKey {this,"CalibCablingKey","LArCalibLineMap","SG Key of LArCalibLineMapping object"}
SG::ReadCondHandleKey< LArCalibLineMapping >	m_calibMapSCKey {this,"CalibMapSCKey","LArCalibIdMapSC","SG Key of calib line mapping object"}
SG::ReadCondHandleKey< LArOnOffIdMapping >	m_cablingKey {this, "OnOffMap", "LArOnOffIdMap", "SG key for mapping object"}
SG::ReadCondHandleKey< LArOnOffIdMapping >	m_cablingKeySC {this,"ScCablingKey","LArOnOffIdMapSC","SG Key of SC LArOnOffIdMapping object"}
const LArOnlineID_Base *	m_onlineHelper
int	m_delay
	Store delay.
std::string	m_calibAccuDigitContainerName
	LArAccumulatedCalibDigitContainer name.
std::vector< std::string >	m_keylist
	list of key for input digit container (=gain)
unsigned int	m_nStepTrigger
	Number of intermediate accumulations (JO property)
double	m_delayScale
	Set delay scale.
bool	m_keepPulsed
	Tells you whether you keep only pulsed cells or all cells.
bool	m_isSC
	Tells you whether you run on SuperCells or Cells.
bool	m_keepFullyPulsedSC
	Tells you whether you keep only fully pulsed supercells or all supercells.
double	m_DropPercentTrig
	Percentage of the used triggers that we will skip over at the end, in order ot ensure that the accumulation is done, even if there are lots of missing events from SC.
std::map< std::string, std::vector< LArAccumulated > >	m_Accumulated_map
	Vector (index=hash ID) of accumulation quantities.
unsigned int	m_event_counter
	Event counter.
unsigned int	m_eventNb = 0U
int	m_sampleShift
	Samples to shift by, usually used in the case of SCs.
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

Detailed Description

Emulator of DSP code in accumulation calibration mode.

Version

$Id: LArCalibDigitsAccumulator.h,v 1.8 2008-06-12 14:51:35 lafaye Exp $

Author

Sandrine Laplace lapla.nosp@m.ce@l.nosp@m.app.i.nosp@m.n2p3.nosp@m..fr

Date

22-January-2006

Input to this algorithm are LArCalibDigits. These LArCalibDigits are accumulated (sum and squared sum)over a number of triggers given by the calibration run settings. Intermediate sums are also computed if the JO property "StepOfTriggers" is set to a larger number than one. The output of the algorithm is a LArAccumulatedCalibDigitContainer.

Definition at line 33 of file LArCalibDigitsAccumulator.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

LArCalibDigitsAccumulator()

LArCalibDigitsAccumulator::LArCalibDigitsAccumulator	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 15 of file LArCalibDigitsAccumulator.cxx.

                                                                                                    :
  AthAlgorithm(name, pSvcLocator),
  m_sc2ccMappingTool("CaloSuperCellIDTool"), 
  m_onlineHelper(nullptr),
  m_sampleShift(0)
{
  declareProperty("LArAccuCalibDigitContainerName",m_calibAccuDigitContainerName, "LArAccumulatedCalibDigits");
  declareProperty("KeyList",m_keylist);
  declareProperty("StepOfTriggers",m_nStepTrigger=1);
  declareProperty("DelayScale",m_delayScale=1*ns);
  declareProperty("KeepOnlyPulsed",m_keepPulsed=false);
  declareProperty("KeepFullyPulsedSC",m_keepFullyPulsedSC=false);
  declareProperty("DropPercentTrig",m_DropPercentTrig=10);
  declareProperty("isSC",m_isSC=false);
  declareProperty("SampleShift",m_sampleShift=0);
  m_delay=-1;
  m_event_counter=0;
}

Member Function Documentation

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 LArCalibDigitsAccumulator::execute

(

)

first check if there is a -1 and continue

why this is not reset to -1 each event, does not make sense

assuming sizeSamples>m_sampleShift, is there a protection for this somehwere?

Definition at line 73 of file LArCalibDigitsAccumulator.cxx.

{
  
  StatusCode sc;
 
  if ( m_event_counter < 100 || m_event_counter%100==0 )
    ATH_MSG_INFO( "Processing event " << m_event_counter );
  ++m_event_counter;
  
  const LArCalibLineMapping *clcabling = nullptr;
  SG::ReadCondHandle<LArCalibLineMapping> clHdl{m_calibMapKey};
  clcabling =*clHdl;
  if(!clcabling) {
    ATH_MSG_WARNING( "Do not have calib line mapping from key " << m_calibMapKey.key() );
    return StatusCode::FAILURE;
  }
 
  const LArCalibLineMapping *clcablingSC = nullptr;
  if(m_isSC) {
     SG::ReadCondHandle<LArCalibLineMapping> clHdl{m_calibMapSCKey};
     clcablingSC =*clHdl;
     if(!clcablingSC) {
         ATH_MSG_WARNING( "Do not have calib line mapping from key " << m_calibMapSCKey.key() );
         return StatusCode::FAILURE;
     }
  }
  
  // new here ====
  const LArOnOffIdMapping* cabling(nullptr);
  const LArOnOffIdMapping* cablingLeg(nullptr);
  if( m_isSC ){
    SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKeySC};
    cabling = {*cablingHdl};
    if(!cabling) {
      ATH_MSG_ERROR("Do not have mapping object " << m_cablingKeySC.key());
      return StatusCode::FAILURE;
    }
    
    SG::ReadCondHandle<LArOnOffIdMapping> cablingHdlLeg{m_cablingKey};
    cablingLeg = {*cablingHdlLeg};
    if(!cablingLeg) {
      ATH_MSG_ERROR("Do not have mapping object " << m_cablingKey.key());
      return StatusCode::FAILURE;
    }
  }
 
  // =============
 
   
 
  // pointer to input container
  const LArCalibDigitContainer* calibDigitContainer=nullptr;
 
  // Event info 
  const xAOD::EventInfo* thisEventInfo = nullptr;
  ATH_CHECK( evtStore()->retrieve(thisEventInfo) );
  unsigned eventNb = thisEventInfo->eventNumber();
  // retrieve calibration settings
  const LArCalibParams* calibParams;
  sc=detStore()->retrieve(calibParams,"LArCalibParams");
  if (sc.isFailure())
    {ATH_MSG_ERROR( "Cannot load LArCalibParams from DetStore." );
      return StatusCode::FAILURE;
    }
 
  unsigned int sizeSteps = (m_nStepTrigger>1 ? (m_nStepTrigger+1):1);
 
  // retrieve input calibDigits
  
  //Loop over all containers that are to be processed (e.g. different gains)
  for (const std::string& key : m_keylist) {
 
    sc=evtStore()->retrieve(calibDigitContainer,key);
    if(sc.isFailure()) {
      ATH_MSG_ERROR( "Can't retrieve LArCalibDigitContainer with key " << key << "from StoreGate." );
      return StatusCode::SUCCESS;
    }else{
      ATH_MSG_DEBUG( "Retrieved LArCalibDigitContainer with key " << key << " from StoreGate." );
    }
 
    if(calibDigitContainer->empty()) {
      ATH_MSG_DEBUG( "LArCalibDigitContainer with key=" << key << " is empty " );
    }else{
      ATH_MSG_DEBUG( "LArCalibDigitContainer with key=" << key << " has size =  " << calibDigitContainer->size() );
    }
 
    // counter of triggers 
    std::vector<unsigned int> ntrigger, nTriggerPerStep, nStepTrigger, iStepTrigger;
    // effective number of triggers: per channel
    ntrigger.resize(calibDigitContainer->size(),0);
    // asked number of triggers (from calib settings): per FEB
    nTriggerPerStep.resize(m_onlineHelper->febHashMax(),0);
    nStepTrigger.resize(m_onlineHelper->febHashMax(),0);
    iStepTrigger.resize(m_onlineHelper->febHashMax(),0);
 
    // output container
    LArAccumulatedCalibDigitContainer* larAccuCalibDigitContainer = new LArAccumulatedCalibDigitContainer();
    //Loop over all cells
    for (const LArCalibDigit* digit : *calibDigitContainer) {
      if(m_keepPulsed && !digit->isPulsed()) continue;
      
      // identificators
      HWIdentifier chid=digit->hardwareID();      
      const HWIdentifier febid=m_onlineHelper->feb_Id(chid);
      const IdentifierHash febhash = m_onlineHelper->feb_Hash(febid);
      const IdentifierHash hashid = m_onlineHelper->channel_Hash(chid);
 
 
      
 
      std::vector<Identifier> ccellIds(0);
      unsigned numPulsedLeg = 0;
      unsigned numCL = 0;
      if( m_isSC ){

    bool hasInvalid=false;
    for(auto s : digit->samples()){
      if(s<0){
        hasInvalid=true;
        break;
      }
    }
    if(hasInvalid) continue;
 
    Identifier myofflineID = cabling->cnvToIdentifier(digit->hardwareID()) ;
    ccellIds = m_sc2ccMappingTool->superCellToOfflineID( myofflineID );
        for (Identifier id : ccellIds) {// loop cells in sc
      HWIdentifier cellLegHWID  = cablingLeg->createSignalChannelID(id);
      const std::vector<HWIdentifier>& calibLineLeg = clcabling->calibSlotLine(cellLegHWID);
      numCL += calibLineLeg.size();
          for (HWIdentifier calibLineHWID : calibLineLeg) {// loop legacy calib lines
        if ( calibParams->isPulsed(eventNb,calibLineHWID) ){
          numPulsedLeg += 1;
          ATH_MSG_DEBUG("SC "<< chid << " constituent cell "<< cellLegHWID << " calib line "<< calibLineHWID<< " not pulsed");
        }else{
          if ( digit->isPulsed() ) ATH_MSG_WARNING("SC "<< chid << " constituent cell "<< cellLegHWID << " calib line "<< calibLineHWID<< " not pulsed");}
      }//end calib line Leg loop
    }//end legacy cell loop
    if ( digit->isPulsed() && numPulsedLeg != numCL ){ //(int)(ccellIds.size()) ){
      ATH_MSG_WARNING("Number of pulsed legacy cells does not equal number of calibration lines "<<chid<<"!! LArParams counter = " << numPulsedLeg << ", SC2CCMappingTool = " << ccellIds.size() << ", num CLs = "<< numCL);
 
      if(m_keepFullyPulsedSC){ // && numPulsedLeg < (int)(ccellIds.size())){
        ATH_MSG_WARNING("Discarding this SC ("<<chid<<") as it is not fully pulsed");
        continue;
      }
    }
    ATH_MSG_DEBUG("SC "<<chid<<" pulsed cells "<< numPulsedLeg <<" or "<< ccellIds.size()<<", "<<numCL<<" calibration lines");
      } // end m_isSC

 
      // BELOW: DIRTY HACK BECAUSE THERE SEEMS TO BE A BUG IN THE CABLINGSVC CONCERNING THE CALIBLINES.
      // get calibration settings
      const std::vector<HWIdentifier>& calibLineID = m_isSC ? clcablingSC->calibSlotLine(chid) :  clcabling->calibSlotLine(chid);
      HWIdentifier calibModuleID;
      if(!calibLineID.empty()){
    calibModuleID=m_onlineHelper->calib_module_Id(calibLineID[0]);
    nTriggerPerStep[febhash] = calibParams->NTrigger(calibModuleID);
    ATH_MSG_DEBUG( "Ntrigger per step = " << nTriggerPerStep[febhash] );
    if(nTriggerPerStep[febhash] > 1000) nTriggerPerStep[febhash]=100; // very dirty !!! 
      }else{
 
    nTriggerPerStep[febhash] = 100; // very dirty !! 
      }
 
      // cell is pulsed ? 
      bool isPulsed = digit->isPulsed();
      
      //First cell to be processed, set delay
      if (m_delay==-1) { 
    m_delay=digit->delay();
      }
      else{
    // next cells: should be the same delay
    if (m_delay!=digit->delay()) {
      ATH_MSG_DEBUG( "Delay is changing to " << digit->delay() << " from " << m_delay << ": book a new LArAccumulatedCalibDigitContainer" );
      m_delay=digit->delay();
    }
      }
      
      std::string patternName = getPatternName(key, isPulsed, m_delay, digit->DAC());
 
      std::map<std::string, std::vector<LArAccumulated> >::iterator accIter=m_Accumulated_map.find(patternName);
      if(accIter==m_Accumulated_map.end()){
    accIter=m_Accumulated_map.insert(std::make_pair(patternName,std::vector<LArAccumulated>(m_onlineHelper->channelHashMax()))).first;
      }
 
      CaloGain::CaloGain gain=digit->gain();
      if (gain<0 || gain>CaloGain::LARNGAIN)
    {ATH_MSG_ERROR( "Found not-matching gain number ("<< (int)gain <<")" );
          delete larAccuCalibDigitContainer;
      return StatusCode::FAILURE;
    }
      
      // object to be filled for each cell
      LArAccumulated& cellAccumulated = accIter->second[hashid];
      cellAccumulated.m_onlineId=chid.get_identifier32().get_compact();
 
      // trigger counter for each cell
      cellAccumulated.m_ntrigger++;
      ATH_MSG_DEBUG( "chid = " << chid << ", trigger = " << cellAccumulated.m_ntrigger << ", DAC = " << digit->DAC()<<", Delay = "<<digit->delay()<<", isPulsed? "<<digit->isPulsed() );
            
      // at first trigger, initialize vectors
      unsigned int sizeSamples = digit->samples().size();
      ATH_MSG_DEBUG( "sizeSteps = " << sizeSteps << ", # of samples = " << sizeSamples );
 
      if(cellAccumulated.m_ntrigger==1){
    cellAccumulated.m_sum.clear();
    cellAccumulated.m_sum2.clear();
    cellAccumulated.m_sum.resize(sizeSamples,0);
    cellAccumulated.m_sum2.resize(sizeSamples,0);
      }    

      for(unsigned int j=0;j<sizeSamples;j++){
    int digis;
    if(j-m_sampleShift >= sizeSamples){
      digis=digit->samples()[sizeSamples-1];
      cellAccumulated.m_sum[j] += digis;
      cellAccumulated.m_sum2[j] += digis*digis;
    }
    else if((int)j-m_sampleShift<0){
      digis=digit->samples()[0];
      cellAccumulated.m_sum[j] += digis;
      cellAccumulated.m_sum2[j] += digis*digis;
    } else{
      digis=digit->samples()[j-m_sampleShift];
      cellAccumulated.m_sum[j] += digis;
      cellAccumulated.m_sum2[j] += digis*digis;
    }
      }
     
      // when reached total number of triggers for this step, fill LArAccumulatedCalibDigit and reset number of triggers
      unsigned int ntrigUsed = nTriggerPerStep[febhash];
      if ( m_isSC && m_DropPercentTrig != 0 ){
    ntrigUsed -= ntrigUsed*(m_DropPercentTrig/100);
      }
 
      if(cellAccumulated.m_ntrigger==ntrigUsed){ 
    ATH_MSG_DEBUG( "filling LArAccumulatedCalibDigit " );
    ATH_MSG_DEBUG( "chid = " << chid << ", gain = " << gain << ", DAC = " << digit->DAC() << ", isPulsed = " << isPulsed << ", delay = " << m_delay << ", trigPerStep = " << nTriggerPerStep[febhash] << ", istep = " << iStepTrigger[febhash] );
 
 
    LArAccumulatedCalibDigit* accuCalibDigit;
    if ( m_isSC ){      
          ATH_MSG_DEBUG("Channel "<<chid<<" DAC "<< digit->DAC()<< " will multiply by "<<numPulsedLeg<< " = "<<digit->DAC()*numPulsedLeg<<" is pulsed??? "<<isPulsed);
          accuCalibDigit = new LArAccumulatedCalibDigit(chid,gain,sizeSamples,(int32_t)(digit->DAC()*numPulsedLeg),(uint16_t)m_delay,isPulsed,0,0);
        }else{
          accuCalibDigit = new LArAccumulatedCalibDigit(chid,gain,sizeSamples,(uint16_t)digit->DAC(),(uint16_t)m_delay,isPulsed,0,0);
        }
 
 
    accuCalibDigit->setAddSubStep(cellAccumulated.m_sum,cellAccumulated.m_sum2,ntrigUsed);
    iStepTrigger[febhash]++;
    
    std::vector<float> mean =  accuCalibDigit->mean();
    std::vector<float> RMS =  accuCalibDigit->RMS();
 
    for(unsigned int i=0;i<mean.size();i++){
      ATH_MSG_DEBUG( "mean["<<i<<"] = " << mean[i] );
      ATH_MSG_DEBUG( "RMS["<<i<<"] = " << RMS[i] );
    }
 
    larAccuCalibDigitContainer->push_back(accuCalibDigit);
 
    cellAccumulated.m_nused = cellAccumulated.m_ntrigger;
    cellAccumulated.m_ntrigger = 0;
      }
      
    }// loop over cells in container
 
 
    larAccuCalibDigitContainer->setDelayScale(m_delayScale);
    sc = evtStore()->record(larAccuCalibDigitContainer,key);
    if (sc!=StatusCode::SUCCESS)
      {ATH_MSG_WARNING( "Unable to record LArAccumulatedCalibDigitContainer with key " << key << " from DetectorStore. " );
      } 
    else
      ATH_MSG_DEBUG( "Recorded succesfully LArAccumulatedCalibDigitContainer with key " << key  << " with size " << larAccuCalibDigitContainer->size());
    
    sc = evtStore()->setConst(larAccuCalibDigitContainer);
    if (sc.isFailure()) {
      ATH_MSG_ERROR( " Cannot lock LArAccumulatedCalibDigitContainer " );
      return(StatusCode::FAILURE);
    }
 
 
  } // loop over key container
  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 LArCalibDigitsAccumulator::finalize

(

)

assuming 100 per step

Definition at line 373 of file LArCalibDigitsAccumulator.cxx.

                                              {
 
  if ( !m_isSC ) return StatusCode::SUCCESS;
  int ntrigUsed = 100 - 100*(m_DropPercentTrig/100); 
  for(auto &acc : m_Accumulated_map){
    std::string pattern=acc.first;
    for(auto &sc : acc.second){
      if(sc.m_onlineId && sc.m_nused != ntrigUsed){
    ATH_MSG_WARNING("Not enough triggers for pattern " << pattern << " channel OnlineID " << sc.m_onlineId << " ntriggers " << sc.m_ntrigger );
      }
    }
  }
 
  return StatusCode::SUCCESS;
 
}

getPatternName()

std::string LArCalibDigitsAccumulator::getPatternName ( const std::string & gain, bool isPulsed, int delay, int dac )

staticprivate

Definition at line 366 of file LArCalibDigitsAccumulator.cxx.

                                                                                                           {
  std::ostringstream ss;
  ss<<gain<<"_"<<isPulsed<<"_"<<delay<<"_"<<dac;
  return ss.str();
}

initialize()

StatusCode LArCalibDigitsAccumulator::initialize

(

)

Definition at line 35 of file LArCalibDigitsAccumulator.cxx.

                                                {
  
  m_eventNb=0;
  // retrieve online ID helper
  StatusCode sc;
  ATH_CHECK( m_cablingKey.initialize() );
  ATH_CHECK( m_calibMapKey.initialize() );
 
  if(m_isSC){
     const LArOnline_SuperCellID *scid;
     sc = detStore()->retrieve(scid, "LArOnline_SuperCellID");
     if (sc.isFailure()) {
        ATH_MSG_ERROR( "Could not get LArOnline_SuperCellID helper !" );
        return sc;
     } else {
        m_onlineHelper = static_cast<const LArOnlineID_Base*>(scid);
        ATH_MSG_DEBUG("Found the LArOnlineID helper");
     }
     ATH_CHECK( m_sc2ccMappingTool.retrieve() );
     ATH_CHECK( m_cablingKeySC.initialize() );
     ATH_CHECK( m_calibMapSCKey.initialize() );
  } else { 
     const LArOnlineID* ll;
     sc = detStore()->retrieve(ll, "LArOnlineID");
     if (sc.isFailure()) {
        ATH_MSG_ERROR( "Could not get LArOnlineID helper !" );
        return sc;
     } else {
        m_onlineHelper = static_cast<const LArOnlineID_Base*>(ll);
        ATH_MSG_DEBUG(" Found the LArOnlineID helper. ");
     }
  } //m_isSC
 
  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.

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_Accumulated_map

std::map<std::string, std::vector<LArAccumulated> > LArCalibDigitsAccumulator::m_Accumulated_map

private

Vector (index=hash ID) of accumulation quantities.

Definition at line 123 of file LArCalibDigitsAccumulator.h.

m_cablingKey

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

private

Definition at line 70 of file LArCalibDigitsAccumulator.h.

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

m_cablingKeySC

SG::ReadCondHandleKey<LArOnOffIdMapping> LArCalibDigitsAccumulator::m_cablingKeySC {this,"ScCablingKey","LArOnOffIdMapSC","SG Key of SC LArOnOffIdMapping object"}

private

Definition at line 71 of file LArCalibDigitsAccumulator.h.

{this,"ScCablingKey","LArOnOffIdMapSC","SG Key of SC LArOnOffIdMapping object"};

m_calibAccuDigitContainerName

std::string LArCalibDigitsAccumulator::m_calibAccuDigitContainerName

private

LArAccumulatedCalibDigitContainer name.

Definition at line 83 of file LArCalibDigitsAccumulator.h.

m_calibMapKey

SG::ReadCondHandleKey<LArCalibLineMapping> LArCalibDigitsAccumulator::m_calibMapKey {this,"CalibCablingKey","LArCalibLineMap","SG Key of LArCalibLineMapping object"}

private

Definition at line 64 of file LArCalibDigitsAccumulator.h.

{this,"CalibCablingKey","LArCalibLineMap","SG Key of LArCalibLineMapping object"};

m_calibMapSCKey

SG::ReadCondHandleKey<LArCalibLineMapping> LArCalibDigitsAccumulator::m_calibMapSCKey {this,"CalibMapSCKey","LArCalibIdMapSC","SG Key of calib line mapping object"}

private

Definition at line 67 of file LArCalibDigitsAccumulator.h.

{this,"CalibMapSCKey","LArCalibIdMapSC","SG Key of calib line mapping object"};

m_delay

int LArCalibDigitsAccumulator::m_delay

private

Store delay.

Definition at line 78 of file LArCalibDigitsAccumulator.h.

m_delayScale

double LArCalibDigitsAccumulator::m_delayScale

private

Set delay scale.

Definition at line 98 of file LArCalibDigitsAccumulator.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_DropPercentTrig

double LArCalibDigitsAccumulator::m_DropPercentTrig

private

Percentage of the used triggers that we will skip over at the end, in order ot ensure that the accumulation is done, even if there are lots of missing events from SC.

Definition at line 118 of file LArCalibDigitsAccumulator.h.

m_event_counter

unsigned int LArCalibDigitsAccumulator::m_event_counter

private

Event counter.

Definition at line 128 of file LArCalibDigitsAccumulator.h.

m_eventNb

unsigned int LArCalibDigitsAccumulator::m_eventNb = 0U

private

Definition at line 129 of file LArCalibDigitsAccumulator.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_isSC

bool LArCalibDigitsAccumulator::m_isSC

private

Tells you whether you run on SuperCells or Cells.

Definition at line 108 of file LArCalibDigitsAccumulator.h.

m_keepFullyPulsedSC

bool LArCalibDigitsAccumulator::m_keepFullyPulsedSC

private

Tells you whether you keep only fully pulsed supercells or all supercells.

Definition at line 113 of file LArCalibDigitsAccumulator.h.

m_keepPulsed

bool LArCalibDigitsAccumulator::m_keepPulsed

private

Tells you whether you keep only pulsed cells or all cells.

Definition at line 103 of file LArCalibDigitsAccumulator.h.

m_keylist

std::vector<std::string> LArCalibDigitsAccumulator::m_keylist

private

list of key for input digit container (=gain)

Definition at line 88 of file LArCalibDigitsAccumulator.h.

m_nStepTrigger

unsigned int LArCalibDigitsAccumulator::m_nStepTrigger

private

Number of intermediate accumulations (JO property)

Definition at line 93 of file LArCalibDigitsAccumulator.h.

m_onlineHelper

const LArOnlineID_Base* LArCalibDigitsAccumulator::m_onlineHelper

private

Definition at line 73 of file LArCalibDigitsAccumulator.h.

m_sampleShift

int LArCalibDigitsAccumulator::m_sampleShift

private

Samples to shift by, usually used in the case of SCs.

Definition at line 134 of file LArCalibDigitsAccumulator.h.

m_sc2ccMappingTool

ToolHandle<ICaloSuperCellIDTool> LArCalibDigitsAccumulator::m_sc2ccMappingTool

private

Definition at line 62 of file LArCalibDigitsAccumulator.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:

• LArCalibDigitsAccumulator.h
• LArCalibDigitsAccumulator.cxx