LArCaliWaveBuilder Class Reference

#include <LArCaliWaveBuilder.h>

Inheritance diagram for LArCaliWaveBuilder:

Collaboration diagram for LArCaliWaveBuilder:

Public Member Functions
	LArCaliWaveBuilder (const std::string &name, ISvcLocator *pSvcLocator)
	~LArCaliWaveBuilder ()
StatusCode	initialize ()
StatusCode	execute ()
virtual StatusCode	stop ()
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 std::map< int, LArCaliWave >	WaveMap
typedef LArConditionsContainer< WaveMap >	WaveContainer
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	executeWithAccumulatedDigits (const LArCalibParams *calibParams, const LArCalibLineMapping *clcabling)
StatusCode	executeWithStandardDigits (const LArCalibParams *calibParams, const LArCalibLineMapping *clcabling)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::ReadCondHandleKey< LArOnOffIdMapping >	m_cablingKey {this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"}
SG::ReadCondHandleKey< LArOnOffIdMapping >	m_cablingKeySC {this,"ScCablingKey","LArOnOffIdMapSC","SG Key of SC LArOnOffIdMapping object"}
SG::ReadCondHandleKey< LArCalibLineMapping >	m_calibMapKey {this,"CalibLineKey","LArCalibLineMap","SG Key of calib. line mapping object"}
SG::ReadCondHandleKey< ILArPedestal >	m_pedKey {this,"PedestalKey","Pedestal","SG Key of pedestal object"}
bool	m_useAccumulatedDigits
std::vector< std::string >	m_keylist
std::vector< std::string >	m_keylistproperty
std::string	m_keyoutput
std::string	m_groupingType
WaveContainer	m_waves
bool	m_pedSub
unsigned	m_baseline
bool	m_recAll
bool	m_isSC
bool	m_useDacAndIsPulsedIndex
int	m_ADCsatur
bool	m_checkEmptyPhases
const LArOnlineID_Base *	m_onlineID
unsigned	m_event_counter
int	m_NStep
float	m_SamplingPeriod
float	m_dt
uint16_t	m_fatalFebErrorPattern
int	m_usePatt
bool	m_useParams
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

Definition at line 28 of file LArCaliWaveBuilder.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

WaveContainer

typedef LArConditionsContainer<WaveMap> LArCaliWaveBuilder::WaveContainer

private

Definition at line 57 of file LArCaliWaveBuilder.h.

WaveMap

typedef std::map<int, LArCaliWave> LArCaliWaveBuilder::WaveMap

private

Definition at line 56 of file LArCaliWaveBuilder.h.

Constructor & Destructor Documentation

LArCaliWaveBuilder()

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

Definition at line 25 of file LArCaliWaveBuilder.cxx.

 : AthAlgorithm(name, pSvcLocator),
   m_groupingType("ExtendedFeedThrough"), // SubDetector, Single, FeedThrough
   m_onlineID(nullptr),
   m_event_counter(0)
{
 declareProperty("UseAccumulatedDigits",   m_useAccumulatedDigits=true);
 declareProperty("KeyList",                m_keylistproperty);
 declareProperty("KeyOutput",              m_keyoutput="LArCaliWave");
 declareProperty("SubtractPed",            m_pedSub=true);
 declareProperty("NBaseline",              m_baseline=1);
 declareProperty("SamplingPeriod",         m_SamplingPeriod=1./(40.08*megahertz));
 declareProperty("NSteps",                 m_NStep=24); // Number of Delay Steps. FIXME: Try to get this information for somewhere else  
 declareProperty("ADCsaturation",          m_ADCsatur=0) ; 
 declareProperty("GroupingType",           m_groupingType); 
 declareProperty("UseDacAndIsPulsedIndex", m_useDacAndIsPulsedIndex=false);
 declareProperty("CheckEmptyPhases",       m_checkEmptyPhases=false);
 declareProperty("RecAllCells",            m_recAll=false);
 declareProperty("UsePattern",             m_usePatt=-1);
 declareProperty("UseParams",              m_useParams=false); // Read LArCalibParams from DetStore ?
 declareProperty("isSC",                   m_isSC=false);
 
 
 m_dt = m_SamplingPeriod/m_NStep;
 
 m_fatalFebErrorPattern=0xffff;
 
}

~LArCaliWaveBuilder()

LArCaliWaveBuilder::~LArCaliWaveBuilder ( )

default

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

(

)

Definition at line 117 of file LArCaliWaveBuilder.cxx.

{
 // using EvtId
 const EventContext& ctx = getContext();
 m_event_counter=ctx.eventID().event_number();
 
 const LArCalibParams* calibParams = nullptr;
 const LArCalibLineMapping *clcabling=nullptr;
 if(m_useParams) { // we have to check in which event we are, reading only ones corresponding
                      // to our pattern
    ATH_CHECK(detStore()->retrieve(calibParams,"LArCalibParams"));
    unsigned numPatt=calibParams->getNumberPatterns(HWIdentifier(0));
 
    int counter=m_event_counter;
    if(m_useAccumulatedDigits) counter /= calibParams->NTrigger(HWIdentifier(1007091712));
    if(m_usePatt >= 0 && numPatt > 0 && static_cast<int>(counter % numPatt) != m_usePatt) {
       return StatusCode::SUCCESS;
    }
    ATH_MSG_DEBUG("Good event "<<m_event_counter<<" for pattern " << m_usePatt << " out of " << numPatt << " patterns " << calibParams->NTrigger(HWIdentifier(1007091712)) <<" triggers ");
 
    const EventContext& ctx = Gaudi::Hive::currentContext();
    SG::ReadCondHandle<LArCalibLineMapping> clHdl{m_calibMapKey, ctx};
    clcabling =*clHdl;
    if(!clcabling) {
       ATH_MSG_WARNING( "Do not have calib line mapping from key " << m_calibMapKey.key() );
       return StatusCode::FAILURE;
    }
 
 }
 
 if ( m_event_counter < 100 || m_event_counter%100==0 ) 
    ATH_MSG_INFO( "Processing event " << m_event_counter );
 
 if (m_keylist.empty()) {
   ATH_MSG_ERROR( "Key list is empty! No containers to process!" );
   return StatusCode::FAILURE;
 } 
 
 
 // execute() method...
 if (m_useAccumulatedDigits)
   return executeWithAccumulatedDigits(calibParams, clcabling);
 else
   return executeWithStandardDigits(calibParams, clcabling);
}

executeWithAccumulatedDigits()

StatusCode LArCaliWaveBuilder::executeWithAccumulatedDigits ( const LArCalibParams * calibParams, const LArCalibLineMapping * clcabling )

private

Definition at line 163 of file LArCaliWaveBuilder.cxx.

{
 StatusCode sc;
 
 const LArAccumulatedCalibDigitContainer* larAccumulatedCalibDigitContainer = nullptr;
 
 std::vector<std::string>::const_iterator key_it=m_keylist.begin();
 std::vector<std::string>::const_iterator key_it_e=m_keylist.end();
 int foundkey = 0;
 for (;key_it!=key_it_e; ++key_it) { //Loop over all containers that are to be processed (e.g. different gains)
 
   sc = evtStore()->retrieve(larAccumulatedCalibDigitContainer,*key_it);
   if (sc.isFailure()) {
     ATH_MSG_WARNING( "Cannot read LArAccumulatedCalibDigitContainer from StoreGate! key=" << *key_it );
     if ( (std::next(key_it) == key_it_e) && foundkey==0 ){
       ATH_MSG_ERROR("None of the provided LArAccumulatedDigitContainer keys could be read");
       return StatusCode::FAILURE;
     }else{
       continue;
     }
   }
   foundkey+=1;
   
   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==0)
       ATH_MSG_WARNING( "No FebErrorSummaryObject found! Feb errors not checked!" );
 
   HWIdentifier  lastFailedFEB(0);
   LArAccumulatedCalibDigitContainer::const_iterator it=larAccumulatedCalibDigitContainer->begin();
   LArAccumulatedCalibDigitContainer::const_iterator it_end=larAccumulatedCalibDigitContainer->end();
 
   if (it == it_end) {
      ATH_MSG_DEBUG("LArAccumulatedCalibDigitContainer with key=" << *key_it << " is empty ");
      continue; // at this event LArAccumulatedCalibDigitContainer is empty, do not even try to loop on it...
   }
   
   const float delayScale = larAccumulatedCalibDigitContainer->getDelayScale();
   const float deltaDelay = 25*ns/(delayScale*m_NStep);
 
   for (;it!=it_end; ++it) { // Loop over all cells
 
     bool ispulsed=false;
     if(m_useParams && calibParams && clcabling) { // got LArCalibParams from DetStore
        const std::vector<HWIdentifier>& calibLineLeg = clcabling->calibSlotLine((*it)->hardwareID());
        for (const HWIdentifier &calibLineHWID : calibLineLeg) {// loop calib lines
            ispulsed |= calibParams->isPulsed(m_event_counter,calibLineHWID);
        }
     } else {
        ispulsed=(*it)->isPulsed();
     }
     if ( (!m_recAll) && !ispulsed ) {
        ATH_MSG_DEBUG( "Non pulsed cell " << m_onlineID->channel_name((*it)->hardwareID())<<" in evt. "<<m_event_counter ); 
        continue; // Check if cell is pulsed
     }
     HWIdentifier chid=(*it)->hardwareID();
     HWIdentifier febid=m_onlineID->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_onlineID->channel_name(febid) 
           << " reports error(s):" << febErrSum->error_to_string(febErrs) << ". Data ignored." );
     }
     continue;
       }
     }
     CaloGain::CaloGain gain=(*it)->gain();
 
     if (gain<0 || gain>CaloGain::LARNGAIN) {
       ATH_MSG_ERROR( "Found not-matching gain number ("<< (int)gain <<")" );
       return StatusCode::FAILURE;
     }
     
     // transform sampleSum vector from uint32_t to double
     std::vector<double> samplesum;     
     std::vector < uint64_t >::const_iterator samplesum_it=(*it)->sampleSum().begin();
     std::vector < uint64_t >::const_iterator samplesum_it_e=(*it)->sampleSum().end();
     for (;samplesum_it!=samplesum_it_e; ++samplesum_it) 
       samplesum.push_back((double)(*samplesum_it));     
     
     // transform sample2Sum vector from uint32_t to double
     std::vector<double> sample2sum;     
     std::vector < uint64_t >::const_iterator sample2sum_it=(*it)->sample2Sum().begin();
     std::vector < uint64_t >::const_iterator sample2sum_it_e=(*it)->sample2Sum().end();
     for (;sample2sum_it!=sample2sum_it_e; ++sample2sum_it) 
       sample2sum.push_back((double)(*sample2sum_it));     
 
     WaveMap& waveMap = m_waves.get(chid,gain);
 
     //make dacPulsed which has dac and four bits of is pulsed info
     int dacPulsed;
     float delay = (*it)->delay();
     int dac=(*it)->DAC();
     int index;
     int pulsed=0;
     if(m_useParams && calibParams && clcabling) { // get LArCalibParams from DetStore
        const std::vector<HWIdentifier>& calibLineLeg = clcabling->calibSlotLine((*it)->hardwareID());
        if(calibLineLeg.empty()) {
           ATH_MSG_WARNING("Why do not have calib lines for "<<(*it)->hardwareID()<<" ?");
           continue;
        }      
        dac=calibParams->DAC(m_event_counter,calibLineLeg[0]);
        dacPulsed=dac;
        delay = calibParams->Delay(m_event_counter,calibLineLeg[0]);
        for (unsigned i=0; i<calibLineLeg.size(); ++i) {// loop calib lines
           if(calibParams->isPulsed(m_event_counter,calibLineLeg[i])){
          ATH_MSG_DEBUG("GR: line pulsed true, line="<<i+1);
          dacPulsed=(dacPulsed | (0x1 << (15+i+1)));
              pulsed=(pulsed | (0x1 << (15+i+1)));
           }
 
        }
     } else {
        dacPulsed=(*it)->DAC();
        for(int iLine=1;iLine<5;iLine++){
           if((*it)->isPulsed(iLine)){
          ATH_MSG_DEBUG("GR: line pulsed true, line="<<iLine);
          dacPulsed=(dacPulsed | (0x1 << (15+iLine)));
              pulsed=(pulsed | (0x1 << (15+iLine)));
           }
        }
     }
 
     if(m_useDacAndIsPulsedIndex){//switch used to turn on the option to have indexs that are DAC and isPulsed info
       index = dacPulsed;
     } else {
       index = dac;
     } 
 
     ATH_MSG_DEBUG( "Pulsed cell " << m_onlineID->channel_name(chid) << " gain: "<<gain ); 
     ATH_MSG_DEBUG( "with " << (*it)->sampleSum().size() << " samples " << index << " DAC " << delay << " delay " << dacPulsed << " dacPulsed " ); 
 
     WaveMap::iterator itm = waveMap.find(index);
     
     if ( itm == waveMap.end() ) { // A new LArCaliWave is booked
       LArCaliWave wave(samplesum.size()*m_NStep, m_dt, dac, pulsed, LArWave::meas);
       itm = (waveMap.insert(WaveMap::value_type(index,wave))).first;
       ATH_MSG_DEBUG("index: "<<index<<" new wave inserted");
     }
     (*itm).second.addAccumulatedEvent(int(std::roundf(delay/deltaDelay)), m_NStep, 
                                    samplesum, sample2sum, (*it)->nTriggers());
     
   } //End loop over all cells
 } //End loop over all containers
 
 return StatusCode::SUCCESS;
}

executeWithStandardDigits()

StatusCode LArCaliWaveBuilder::executeWithStandardDigits ( const LArCalibParams * calibParams, const LArCalibLineMapping * clcabling )

private

Definition at line 321 of file LArCaliWaveBuilder.cxx.

{
 StatusCode sc;
 
 const LArCalibDigitContainer* larCalibDigitContainer = nullptr;
 
 std::vector<std::string>::const_iterator key_it=m_keylist.begin();
 std::vector<std::string>::const_iterator key_it_e=m_keylist.end();
 
 for (;key_it!=key_it_e; ++key_it) { //Loop over all containers that are to be processed (e.g. different gains)
 
   sc = evtStore()->retrieve(larCalibDigitContainer,*key_it);
   if (sc.isFailure()) {
     ATH_MSG_WARNING( "Cannot read LArCalibDigitContainer from StoreGate! key=" << *key_it );
     continue; // Try next container
   }
 
   LArCalibDigitContainer::const_iterator it=larCalibDigitContainer->begin();
   LArCalibDigitContainer::const_iterator it_end=larCalibDigitContainer->end();
 
   if (it == it_end) {
      ATH_MSG_INFO( "LArCalibDigitContainer with key=" << *key_it << " is empty " );
      continue; // at this event LArCalibDigitContainer is empty, do not even try to loop on it...
   }
   
   const float delayScale = larCalibDigitContainer->getDelayScale();
   const float deltaDelay = 25*ns/(delayScale*m_NStep);
   
   for (;it!=it_end; ++it) { // Loop over all cells
 
     bool pulsed=false;
     int dac = (*it)->DAC();
     float delay= (*it)->delay();
     if(m_useParams && calibParams && clcabling) { // get LArCalibParams from DetStore
        const std::vector<HWIdentifier>& calibLineLeg = clcabling->calibSlotLine((*it)->hardwareID());
        dac=calibParams->DAC(m_event_counter,calibLineLeg[0]); // assuming all calib. boards configured equally
        delay = calibParams->Delay(m_event_counter,calibLineLeg[0]);
        for (const HWIdentifier &calibLineHWID : calibLineLeg) {// loop calib lines
            pulsed |= calibParams->isPulsed(m_event_counter,calibLineHWID);
        }
     } else {
        pulsed=(*it)->isPulsed();
     }
     if ((!m_recAll) &&  !pulsed ) continue ; // Check if cell is pulsed
        
     HWIdentifier chid=(*it)->hardwareID(); 
     CaloGain::CaloGain gain=(*it)->gain();
 
     if (gain<0 || gain>CaloGain::LARNGAIN) {
       ATH_MSG_ERROR( "Found not-matching gain number ("<< (int)gain <<")" );
       return StatusCode::FAILURE;
     }
 
     // transform samples vector from uint32_t to double
     std::vector<double> samples;
     for (short sample : (*it)->samples())
       samples.push_back((double)(sample));
 
     WaveMap& waveMap = m_waves.get(chid,gain);
     WaveMap::iterator itm = waveMap.find(dac);
     
     if ( itm == waveMap.end() ) { // A new LArCaliWave is booked     
       LArCaliWave wave(samples.size()*m_NStep, m_dt, (*it)->DAC(), 0x1, LArWave::meas );
       itm = (waveMap.insert(WaveMap::value_type((*it)->DAC(),wave))).first;
     }
     
     (*itm).second.addEvent((int)roundf(delay/deltaDelay), m_NStep, samples);
     
   } //End loop over all cells
 } //End loop over all containers
 
 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 LArCaliWaveBuilder::finalize ( )

inline

Definition at line 37 of file LArCaliWaveBuilder.h.

{return StatusCode::SUCCESS;}

initialize()

StatusCode LArCaliWaveBuilder::initialize

(

)

Definition at line 57 of file LArCaliWaveBuilder.cxx.

{ 
  if (m_keylistproperty.empty()) {
     m_keylistproperty.emplace_back("HIGH");
     m_keylistproperty.emplace_back("MEDIUM");
     m_keylistproperty.emplace_back("LOW");
  }
  m_keylist = m_keylistproperty;
 
  //FIXME probably useless because m_wave isn't written anywhere
  StatusCode sc=m_waves.setGroupingType(m_groupingType,msg());
  if (sc.isFailure()) {
    ATH_MSG_ERROR( "Failed to set groupingType for LArCaliWave intermediate object" );
    return sc;
  }
 
  ATH_MSG_INFO( "Initialize intermediate Wave object" );
  sc=m_waves.initialize(); 
  if (sc.isFailure()) {
    ATH_MSG_ERROR( "Failed initialize LArCaliWave intermediate object" );
    return sc;
  }
 
  m_event_counter=0; 
  m_dt = m_SamplingPeriod/m_NStep;
 
 
  if (m_checkEmptyPhases)
    ATH_MSG_INFO( "Empty phases check selected." );  
 
  //Get pedestal from CondStore
  ATH_CHECK( m_pedKey.initialize(m_pedSub) );
  
  //Get Online helper from DetStore
  if ( m_isSC ) {
    const LArOnline_SuperCellID* ll;
    ATH_CHECK( detStore()->retrieve(ll, "LArOnline_SuperCellID") );
    m_onlineID = static_cast<const LArOnlineID_Base*>(ll);
    ATH_MSG_DEBUG(" Found the LArOnline_SuperCellID helper. ");
  } else { // m_isSC
    const LArOnlineID* ll;
    ATH_CHECK( detStore()->retrieve(ll, "LArOnlineID") );
    m_onlineID = static_cast<const LArOnlineID_Base*>(ll);
    ATH_MSG_DEBUG(" Found the LArOnlineID helper. ");
  }
 
  ATH_CHECK( m_cablingKey.initialize() );
  ATH_CHECK( m_cablingKeySC.initialize(m_isSC) );
 
  if(m_usePatt >= 0 && !m_useParams) {
     ATH_MSG_ERROR("Inconsistent configuration, for UsePattern > 0 the  UseParams must be true");
     return StatusCode::FAILURE;
  }
  
  ATH_CHECK( m_calibMapKey.initialize(m_useParams) );
 
  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();
  }

stop()

StatusCode LArCaliWaveBuilder::stop ( )

virtual

get iterator for all channels for a gain

Definition at line 397 of file LArCaliWaveBuilder.cxx.

{
    // Create wave container using feedthru grouping and initialize
    auto caliWaveContainer = std::make_unique<LArCaliWaveContainer>();
  
    StatusCode sc=caliWaveContainer->setGroupingType(m_groupingType,msg());
    if (sc.isFailure()) {
      ATH_MSG_ERROR( "Failed to set groupingType for LArCaliWaveContainer object" );
      return sc;
    }
 
    ATH_MSG_INFO( "Initialize final Wave object" );
    sc=caliWaveContainer->initialize(); 
    if (sc.isFailure()) {
      ATH_MSG_ERROR( "Failed initialize LArCaliWaveContainer object" );
      return sc;
    }
    
    const EventContext& ctx = Gaudi::Hive::currentContext();
    const LArOnOffIdMapping* cabling(nullptr);
    if( m_isSC ){
      SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKeySC, ctx};
      cabling = {*cablingHdl};
      if(!cabling) {
    ATH_MSG_ERROR("Do not have mapping object " << m_cablingKeySC.key());
    return StatusCode::FAILURE;
      }
      
    }else{
      SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKey, ctx};
      cabling = {*cablingHdl};
      if(!cabling) {
    ATH_MSG_ERROR("Do not have mapping object " << m_cablingKey.key());
    return StatusCode::FAILURE;
      }
    }
    SG::ReadCondHandle<ILArPedestal> pedHdl{m_pedKey, ctx};
    const ILArPedestal* larPedestal{*pedHdl};
    if(m_pedSub && !larPedestal) {
        ATH_MSG_DEBUG("No pedestal(s) found ");
        ATH_MSG_INFO( "Using fake (baseline) pedestal subtraction..." );  
    }
 
    LArWaveHelper wHelper;
    int NCaliWave=0;
 
    // Loop over all gains
    for (unsigned k=0;k<(int)CaloGain::LARNGAIN;k++) {
   
    CaloGain::CaloGain gain=(CaloGain::CaloGain)k;

    WaveContainer::ConditionsMapIterator cell_it   = m_waves.begin(gain) ; 
    WaveContainer::ConditionsMapIterator cell_it_e = m_waves.end(gain);
 
    HWIdentifier lastId;
    
    for (; cell_it!=cell_it_e; ++cell_it) {
 
   
        // Get id of this cell - use id from first cell in map
        //
        //   Some accumulations may be empty and we must skip this
        //   cell. WaveContainer has all 128 channels for each FEB
        //   with at least ONE being read out.
        //
 
        const HWIdentifier hwId = cell_it.channelId();
        if ((!m_recAll) && (!cabling->isOnlineConnected(hwId))) {
               
                //ATH_MSG_INFO( "Skipping disconnected channel: "<<MSG::hex<<hwId<<MSG::dec );
               continue; //Ignore disconnected channels
            }
          
        const WaveMap& waveMap = (*cell_it);
        if (waveMap.empty()) {
          ATH_MSG_INFO( "Empty accumulated wave. Last id: " << MSG::hex 
        //<< lastId << " " << emId->show_to_string(lastId) );
          << lastId << " this id: "<<hwId<<MSG::dec );
          continue;
        }
 
        lastId = hwId; // save previous id for debug printout
        
        // Get the vector of waves for this chid,gain
        LArCaliWaveContainer::LArCaliWaves& dacWaves = caliWaveContainer->get(hwId, gain);
 
        std::map<int, LArCaliWave>::const_iterator dac_it   = cell_it->begin();
        std::map<int, LArCaliWave>::const_iterator dac_it_e = cell_it->end();
        
        HWIdentifier chid = cell_it.channelId();
        
        for (; dac_it != dac_it_e; ++dac_it) {
       
        const LArCaliWave& thisWave = dac_it->second ;
 
        if (m_checkEmptyPhases) {
          const std::vector<int>& thisTriggers = thisWave.getTriggers();
          for (unsigned i=0;i<thisTriggers.size();++i) {
            if (thisTriggers[i]==0) {
              ATH_MSG_FATAL( "Empty phase found in channel 0x" << MSG::hex << chid << MSG::dec 
                      << "., aborting reconstruction. Sorry." );
              return StatusCode::FAILURE;
            }
          }
        }
 
        float pedAve = 0.;
       
        if ( m_pedSub ) {
            if ( larPedestal ) {          
            float pedestal = larPedestal->pedestal(chid,gain);
            if (pedestal <= (1.0+LArElecCalib::ERRORCODE)) {
              ATH_MSG_DEBUG("No pedestal(s) found for channel 0x" << MSG::hex << chid << MSG::dec);
              ATH_MSG_INFO( "Using fake (baseline) pedestal subtraction..." );  
              pedAve = wHelper.getBaseline(thisWave,m_baseline) ;
            } else {
                pedAve = pedestal;
            }
            } else {
              pedAve = wHelper.getBaseline(thisWave,m_baseline) ;  
            }
            ATH_MSG_DEBUG("Pedestal for channel 0x" << MSG::hex << chid << MSG::dec << " is = " << pedAve << " ADC");
        }
 
        double waveMax = thisWave.getSample( wHelper.getMax(thisWave) ) ;
        if ( (!m_recAll) && m_ADCsatur>0 && waveMax>=m_ADCsatur ) { 
            ATH_MSG_INFO( "Absolute ADC saturation at DAC = " << thisWave.getDAC() << " ... skip!" ) ;
            continue ;
        } else {
                    dacWaves.emplace_back(((thisWave)+(-pedAve)).getWave() ,
                      thisWave.getErrors(),
                      thisWave.getTriggers(),
                      thisWave.getDt(), 
                      thisWave.getDAC(), 
                      thisWave.getIsPulsedInt(),
                      thisWave.getFlag() );
       
            NCaliWave++;
        }
        
        } // end of loop DACs                 
 
        // intermediate map cleanup (save memory)
            cell_it->clear();
 
    } //end loop cells
 
    } //end loop over m_keyList
 
    ATH_MSG_INFO( " Summary : Number of cells with a CaliWave  reconstructed : " << NCaliWave  );    
    ATH_MSG_INFO( " Summary : Number of Barrel PS cells side A or C (connected+unconnected):   3904+ 192 =  4096 " );
    ATH_MSG_INFO( " Summary : Number of Barrel    cells side A or C (connected+unconnected):  50944+2304 = 53248 " );
    ATH_MSG_INFO( " Summary : Number of EMEC      cells side A or C (connected+unconnected):  31872+3456 = 35328 " );
    ATH_MSG_INFO( " Summary : Number of HEC       cells side A or C (connected+unconnected):   2816+ 256 =  3072 " );
    ATH_MSG_INFO( " Summary : Number of FCAL      cells side A or C (connected+unconnected):   1762+  30 =  1792 " );
 
    // Record in detector store with key (m_keyoutput)
    ATH_CHECK( detStore()->record(std::move(caliWaveContainer), m_keyoutput) );
 
    ATH_MSG_INFO( "LArCaliWaveBuilder has finished." );
    return StatusCode::SUCCESS;
}

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_ADCsatur

int LArCaliWaveBuilder::m_ADCsatur

private

Definition at line 74 of file LArCaliWaveBuilder.h.

m_baseline

unsigned LArCaliWaveBuilder::m_baseline

private

Definition at line 62 of file LArCaliWaveBuilder.h.

m_cablingKey

SG::ReadCondHandleKey<LArOnOffIdMapping> LArCaliWaveBuilder::m_cablingKey {this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"}

private

Definition at line 41 of file LArCaliWaveBuilder.h.

{this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"};

m_cablingKeySC

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

private

Definition at line 42 of file LArCaliWaveBuilder.h.

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

m_calibMapKey

SG::ReadCondHandleKey<LArCalibLineMapping> LArCaliWaveBuilder::m_calibMapKey {this,"CalibLineKey","LArCalibLineMap","SG Key of calib. line mapping object"}

private

Definition at line 43 of file LArCaliWaveBuilder.h.

{this,"CalibLineKey","LArCalibLineMap","SG Key of calib. line mapping object"};

m_checkEmptyPhases

bool LArCaliWaveBuilder::m_checkEmptyPhases

private

Definition at line 77 of file LArCaliWaveBuilder.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_dt

float LArCaliWaveBuilder::m_dt

private

Definition at line 84 of file LArCaliWaveBuilder.h.

m_event_counter

unsigned LArCaliWaveBuilder::m_event_counter

private

Definition at line 81 of file LArCaliWaveBuilder.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 LArCaliWaveBuilder::m_fatalFebErrorPattern

private

Definition at line 86 of file LArCaliWaveBuilder.h.

m_groupingType

std::string LArCaliWaveBuilder::m_groupingType

private

Definition at line 53 of file LArCaliWaveBuilder.h.

m_isSC

bool LArCaliWaveBuilder::m_isSC

private

Definition at line 68 of file LArCaliWaveBuilder.h.

m_keylist

std::vector<std::string> LArCaliWaveBuilder::m_keylist

private

Definition at line 50 of file LArCaliWaveBuilder.h.

m_keylistproperty

std::vector<std::string> LArCaliWaveBuilder::m_keylistproperty

private

Definition at line 51 of file LArCaliWaveBuilder.h.

m_keyoutput

std::string LArCaliWaveBuilder::m_keyoutput

private

Definition at line 52 of file LArCaliWaveBuilder.h.

m_NStep

int LArCaliWaveBuilder::m_NStep

private

Definition at line 82 of file LArCaliWaveBuilder.h.

m_onlineID

const LArOnlineID_Base* LArCaliWaveBuilder::m_onlineID

private

Definition at line 79 of file LArCaliWaveBuilder.h.

m_pedKey

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

private

Definition at line 44 of file LArCaliWaveBuilder.h.

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

m_pedSub

bool LArCaliWaveBuilder::m_pedSub

private

Definition at line 61 of file LArCaliWaveBuilder.h.

m_recAll

bool LArCaliWaveBuilder::m_recAll

private

Definition at line 65 of file LArCaliWaveBuilder.h.

m_SamplingPeriod

float LArCaliWaveBuilder::m_SamplingPeriod

private

Definition at line 83 of file LArCaliWaveBuilder.h.

m_useAccumulatedDigits

bool LArCaliWaveBuilder::m_useAccumulatedDigits

private

Definition at line 46 of file LArCaliWaveBuilder.h.

m_useDacAndIsPulsedIndex

bool LArCaliWaveBuilder::m_useDacAndIsPulsedIndex

private

Definition at line 71 of file LArCaliWaveBuilder.h.

m_useParams

bool LArCaliWaveBuilder::m_useParams

private

Definition at line 89 of file LArCaliWaveBuilder.h.

m_usePatt

int LArCaliWaveBuilder::m_usePatt

private

Definition at line 88 of file LArCaliWaveBuilder.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.

m_waves

WaveContainer LArCaliWaveBuilder::m_waves

private

Definition at line 58 of file LArCaliWaveBuilder.h.

---

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

• LArCaliWaveBuilder.h
• LArCaliWaveBuilder.cxx