#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. More...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

MsgStream &	msg () const

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

bool	msgLvl (const MSG::Level lvl) const

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

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

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

Private Types
typedef std::map< int, LArCaliWave >	WaveMap

typedef LArConditionsContainer< WaveMap >	WaveContainer

typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	executeWithAccumulatedDigits (const LArCalibParams calibParams=nullptr, const LArCalibLineMapping clcabling=nullptr)

StatusCode	executeWithStandardDigits (const LArCalibParams calibParams=nullptr, const LArCalibLineMapping clcabling=nullptr)

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

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

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

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

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) More...

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

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() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

inlineprivateinherited

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

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

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

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

Definition at line 245 of file AthCommonDataStore.h.

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

◆ declareProperty() [2/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

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

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

Definition at line 221 of file AthCommonDataStore.h.

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

◆ declareProperty() [3/6]

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

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

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

◆ declareProperty() [4/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

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

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

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

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

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

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode 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 && 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 = `nullptr`,
		const LArCalibLineMapping *	clcabling = `nullptr`
	)

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) { // 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 = `nullptr`,
		const LArCalibLineMapping *	clcabling = `nullptr`
	)

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.

37 {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 = (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 = (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() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                                {
     return this->msgLevel(lvl);
   }

◆ outputHandles()

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

overridevirtualinherited

Return this algorithm's output handles.

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

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

Definition at line 66 of file AthAlgorithm.cxx.

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

◆ sysStart()

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

overridevirtualinherited

Handle START transition.

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

◆ updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

◆ m_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.

◆ 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.

◆ 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.

◆ 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.

◆ 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:

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

◆ WaveContainer

◆ WaveMap

Constructor & Destructor Documentation

◆ LArCaliWaveBuilder()

◆ ~LArCaliWaveBuilder()

Member Function Documentation

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ execute()

◆ executeWithAccumulatedDigits()

◆ executeWithStandardDigits()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ finalize()

◆ initialize()

◆ inputHandles()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ stop()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_ADCsatur

◆ m_baseline

◆ m_cablingKey

◆ m_cablingKeySC

◆ m_calibMapKey

◆ m_checkEmptyPhases

◆ m_detStore

◆ m_dt

◆ m_event_counter

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_fatalFebErrorPattern

◆ m_groupingType

◆ m_isSC

◆ m_keylist

◆ m_keylistproperty

◆ m_keyoutput

◆ m_NStep

◆ m_onlineID

◆ m_pedKey

◆ m_pedSub

◆ m_recAll

◆ m_SamplingPeriod

◆ m_useAccumulatedDigits

◆ m_useDacAndIsPulsedIndex

◆ m_useParams

◆ m_usePatt

◆ m_varHandleArraysDeclared

◆ m_vhka

◆ m_waves