#include <LArOFCAlg.h>

Inheritance diagram for LArOFCAlg:

Collaboration diagram for LArOFCAlg:

Classes
class	Looper

struct	perChannelData_t

Public Member Functions
	LArOFCAlg (const std::string &name, ISvcLocator *pSvcLocator)

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 ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	process (perChannelData_t &, const LArOnOffIdMapping *cabling) const

bool	verify (const HWIdentifier chid, const std::vector< float > &OFCa, const std::vector< float > &OFCb, const std::vector< float > &Shape, const char *ofcversion, const unsigned phase) const

StatusCode	initPhysWaveContainer (const LArOnOffIdMapping *cabling)

StatusCode	initCaliWaveContainer ()

Eigen::VectorXd	getDelta (std::vector< float > &samples, const HWIdentifier chid, unsigned nSamples) const

bool	useDelta (const HWIdentifier chid, const int jobOFlag, const LArOnOffIdMapping *cabling) const

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

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

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

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

Static Private Member Functions
static void	optFilt (const std::vector< float > &gWave_in, const std::vector< float > &gDerivWave_in, const Eigen::MatrixXd &autoCorrInv, std::vector< float > &OFCa, std::vector< float > &OFCb)

static void	optFiltDelta (const std::vector< float > &gWave_in, const std::vector< float > &gDerivWave_in, const Eigen::MatrixXd &autoCorrInv, const Eigen::VectorXd &delta, std::vector< float > &vecOFCa, std::vector< float > &vecOFCb)

static void	printOFCVec (const std::vector< float > &vec, MsgStream &mLog)

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< CaloDetDescrManager >	m_caloMgrKey

SG::ReadCondHandleKey< CaloSuperCellDetDescrManager >	m_caloSuperCellMgrKey

std::vector< perChannelData_t >	m_allChannelData

std::string	m_dumpOFCfile

std::vector< std::string >	m_keylist

bool	m_verify

bool	m_normalize

bool	m_timeShift

int	m_timeShiftByIndex

LArCaliWaveContainer *	m_waveCnt_nc =nullptr

unsigned int	m_nSamples

unsigned int	m_nPhases

unsigned int	m_dPhases

unsigned int	m_nDelays

unsigned int	m_nPoints

float	m_addOffset

ToolHandle< ILArAutoCorrDecoderTool >	m_AutoCorrDecoder {this,"DecoderTool",{} }

ToolHandle< ILArAutoCorrDecoderTool >	m_AutoCorrDecoderV2 {this,"DecoderToolV2", {} }

const CaloDetDescrManager_Base *	m_calo_dd_man

const LArOnlineID_Base *	m_onlineID

const LArOFCBinComplete *	m_larPhysWaveBin

double	m_errAmpl

double	m_errTime

bool	m_readCaliWave

bool	m_fillShape

std::string	m_ofcKey

std::string	m_ofcKeyV2

std::string	m_shapeKey

bool	m_storeMaxPhase

std::string	m_ofcBinKey

std::string	m_groupingType

std::string	m_larPhysWaveBinKey

int	m_useDelta

int	m_useDeltaV2

bool	m_computeV2

int	m_nThreads

bool	m_readDSPConfig

std::string	m_DSPConfigFolder

std::unique_ptr< LArDSPConfig >	m_DSPConfig

bool	m_forceShift

bool	m_isSC

DataObjIDColl	m_extendedExtraObjects

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

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

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

bool	m_varHandleArraysDeclared

Static Private Attributes
static const float	m_fcal3Delta [5] ={0.0790199937765, 0.0952000226825, 0.0790199937765, 0.0952000226825, 0.0790199937765}

static const float	m_fcal2Delta [5] ={-0.01589001104, -0.0740399733186, -0.01589001104, -0.0740399733186, -0.01589001104}

static const float	m_fcal1Delta [5] ={0.0679600232979, -0.139479996869, 0.0679600232979, -0.139479996869, 0.0679600232979}

Detailed Description

Definition at line 39 of file LArOFCAlg.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

◆ LArOFCAlg()

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

Definition at line 40 of file LArOFCAlg.cxx.

     : AthAlgorithm(name, pSvcLocator),
       m_calo_dd_man(nullptr),
           m_onlineID(nullptr),
       m_larPhysWaveBin(nullptr),
       m_groupingType("SubDetector") // SubDetector, Single, FeedThrough
 {
  
   declareProperty("Nsample",m_nSamples = 5);
   declareProperty("Nphase", m_nPhases  = 50);
   declareProperty("Dphase", m_dPhases  = 1);
   declareProperty("Ndelay", m_nDelays  = 24);
   
   declareProperty("KeyList",           m_keylist);
  
   declareProperty("ReadCaliWave",      m_readCaliWave=true); // false == PhysWave
   declareProperty("FillShape",         m_fillShape=false); 
   declareProperty("KeyOFC",            m_ofcKey="LArOFC"); 
   declareProperty("KeyOFCV2",          m_ofcKeyV2="LArOFCV2"); 
   declareProperty("KeyShape",          m_shapeKey="LArShape"); 
  
   declareProperty("Normalize",         m_normalize=false);
   declareProperty("TimeShift",         m_timeShift=false);
   declareProperty("TimeShiftByIndex",  m_timeShiftByIndex=-1);
   
   declareProperty("Verify",            m_verify=true);
   declareProperty("ErrAmplitude",      m_errAmpl=0.01);
   declareProperty("ErrTime",           m_errTime=0.01);
   
   declareProperty("DumpOFCfile",       m_dumpOFCfile=std::string(""));  
  
   declareProperty("GroupingType",      m_groupingType);
   declareProperty("StoreMaxPhase",     m_storeMaxPhase=false);
   declareProperty("LArOFCBinKey",      m_ofcBinKey="LArOFCPhase");
  
   declareProperty("LArPhysWaveBinKey", m_larPhysWaveBinKey="");
  
   declareProperty("AddTimeOffset",     m_addOffset=0.);
  
   declareProperty("ComputeOFCV2",      m_computeV2=false);
  
   declareProperty("UseDelta",          m_useDelta=0); // 0= not use Delta, 1=only EMECIW/HEC/FCAL, 2=all , 3 = only EMECIW/HEC/FCAL1+high eta FCAL2-3
   declareProperty("UseDeltaV2",        m_useDeltaV2=0); // 0= not use Delta, 1=only EMECIW/HEC/FCAL, 2=all , 3 = only EMECIW/HEC/FCAL1+high eta FCAL2-3
  
   declareProperty("nThreads",          m_nThreads=-1,"-1: No TBB, 0: Let TBB decide, >0 number of threads");
  
   declareProperty("ReadDSPConfig",     m_readDSPConfig=false);
   declareProperty("DSPConfigFolder",   m_DSPConfigFolder="/LAR/Configuration/DSPConfiguration");
  
   declareProperty("ForceShift",        m_forceShift=false);
   
   declareProperty("isSC",              m_isSC=false);
  
   m_nPoints = m_nDelays * ( m_nSamples-1 ) + m_nPhases * m_dPhases ;
 }

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 LArOFCAlg::execute ( )

inline

Definition at line 46 of file LArOFCAlg.h.

46 {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 LArOFCAlg::finalize ( )

inline

Definition at line 48 of file LArOFCAlg.h.

48 {return StatusCode::SUCCESS;}

◆ getDelta()

Eigen::VectorXd LArOFCAlg::getDelta	(	std::vector< float > &	samples,
		const HWIdentifier	chid,
		unsigned	nSamples
	)		const

private

Definition at line 850 of file LArOFCAlg.cxx.

                                                                                                             {
  
   if (nSamples>5) nSamples=5;
  
   Eigen::VectorXd delta(nSamples); //return value
  
   if (m_onlineID->isFCALchannel(chid) ){
     // FCAL use fixed delta from data. 
     const int slot = m_onlineID->slot(chid) ; 
     if ( slot <=9){ // FCAL 1
       for (unsigned i=0;i<nSamples;++i) {
     delta[i]=m_fcal1Delta[i];
       }
     }else
       if(slot <=13){ // FCAL 2
     for (unsigned i=0;i<nSamples;++i) {
       delta[i]=m_fcal2Delta[i];
     }
       }else {  //FCAL 3 
     for (unsigned i=0;i<nSamples;++i) {
       delta[i]=m_fcal3Delta[i];
     }
       }
  
   }else
     { // from Shape 
       float odd = 0.;
       float even = 0.;
       for (unsigned int i = 0;i<samples.size();++i) {
       if (i%2==0){
         even  += samples[i];
       }
       else {
         odd += samples[i];
       }
     }
  
       for (unsigned i=0;i<nSamples;++i) {
     if (i%2==0)
       delta[i]=even;
     else
       delta[i]=odd;
       }
     }
  
   return delta;
  
 }

◆ initCaliWaveContainer()

StatusCode LArOFCAlg::initCaliWaveContainer ( )

private

Definition at line 667 of file LArOFCAlg.cxx.

                                             {
  
   typedef LArCaliWaveContainer::ConstConditionsMapIterator WAVEIT;
   for (unsigned k=0 ; k<m_keylist.size() ; k++ ) { // Loop over all containers that are to be processed (e.g. different gains)
     ATH_MSG_INFO( "Processing WaveContainer from StoreGate! key = " << m_keylist[k] );
  
     //Input cali-wave might come from the same job. In this case we see a non-const container in SG probably w/o corrections applied.
     //Try non-const retrieve:
     const LArCaliWaveContainer* waveCnt = nullptr;
     m_waveCnt_nc=detStore()->tryRetrieve<LArCaliWaveContainer>(m_keylist[k]);
     if (m_waveCnt_nc) {
       waveCnt=m_waveCnt_nc; //Retain const pointer
       if (!m_waveCnt_nc->correctionsApplied()) {
     ATH_MSG_INFO( "LArCaliWaveContainer: Corrections not yet applied, applying them now..." );
     if (m_waveCnt_nc->applyCorrections().isFailure()) {
       ATH_MSG_ERROR( "Failed to apply corrections to LArCaliWaveContainer!" );
       return StatusCode::FAILURE;
     }
     else {
       ATH_MSG_INFO("Applied corrections to non-const Wave container");
     }
       }
     }
     else {
       waveCnt=detStore()->tryConstRetrieve<LArCaliWaveContainer>(m_keylist[k]);
       if (!waveCnt) {
     ATH_MSG_ERROR( "Failed to retrieve a LArCaliWaveContainer with key " << m_keylist[k] );
     return  StatusCode::FAILURE;
       }
     }   
    
  
     m_allChannelData.reserve(m_allChannelData.size()+128*waveCnt->size());// Size doesn't give the expected response on a CondtitionsContainer 
  
     for (unsigned gain = CaloGain::LARHIGHGAIN ; gain < CaloGain::LARNGAIN ; gain++ ) { // loop on possible gains
       WAVEIT it=waveCnt->begin(gain);
       WAVEIT it_e=waveCnt->end(gain);
       for (;it!=it_e;++it) {
     const LArCaliWaveVec& wVec=*it;
     for (const auto& cw : wVec) {
       const LArWaveCumul* wave= &(cw); //down-cast
       if (!wave->isEmpty()) {
         m_allChannelData.emplace_back(wave,it.channelId(),gain);
       }
     }
       } //end loop over channels
     }//end loop over gains
   }//end loop over SG keys
   return StatusCode::SUCCESS;
 }

◆ initialize()

StatusCode LArOFCAlg::initialize ( )

Definition at line 98 of file LArOFCAlg.cxx.

                                 {
  
   m_nPoints = m_nDelays * ( m_nSamples-1 ) + m_nPhases * m_dPhases ;
  
   if ( m_nSamples>32 ) {
     ATH_MSG_ERROR( "You are not allowed to compute OFC for Nsamples = " << m_nSamples ) ;
     return  StatusCode::FAILURE;
   } 
  
   StatusCode sc = m_AutoCorrDecoder.retrieve();
   if (sc.isFailure()) {
         ATH_MSG_FATAL( "Could not retrieve AutoCorrDecoder " << m_AutoCorrDecoder );
         return StatusCode::FAILURE;
   } else {
      ATH_MSG_INFO( "Retrieved Decoder Tool: "<< m_AutoCorrDecoder );
   }
  
  
   if (m_computeV2) {
     sc = m_AutoCorrDecoderV2.retrieve();
     if (sc.isFailure()) {
       ATH_MSG_FATAL( "Could not retrieve AutoCorrDecoderV2 " << m_AutoCorrDecoderV2 );
       return StatusCode::FAILURE;
     } else {
       ATH_MSG_INFO( "Retrieved Decoder Tool: "<< m_AutoCorrDecoderV2 );
     }
   }
  
   if ( m_isSC ) {
     const LArOnline_SuperCellID* ll;
     sc = detStore()->retrieve(ll, "LArOnline_SuperCellID");
     if (sc.isFailure()) {
       msg(MSG::ERROR) << "Could not get LArOnlineID helper !" << endmsg;
       return StatusCode::FAILURE;
     }
     else {
       m_onlineID = (const LArOnlineID_Base*)ll;
       ATH_MSG_DEBUG("Found the LArOnlineID helper");
     }
   } else { // m_isSC
     const LArOnlineID* ll;
     sc = detStore()->retrieve(ll, "LArOnlineID");
     if (sc.isFailure()) {
       msg(MSG::ERROR) << "Could not get LArOnlineID helper !" << endmsg;
       return StatusCode::FAILURE;
     }
     else {
       m_onlineID = (const LArOnlineID_Base*)ll;
       ATH_MSG_DEBUG(" Found the LArOnlineID helper. ");
     }
   }
   
   ATH_CHECK( m_cablingKeySC.initialize(m_isSC) );
   ATH_CHECK( m_caloSuperCellMgrKey.initialize(m_isSC) );
   ATH_CHECK( m_cablingKey.initialize(!m_isSC) );
   ATH_CHECK( m_caloMgrKey.initialize(!m_isSC) );
  
   ATH_MSG_INFO( "Number of wave points needed : " << m_nPoints  ) ;
   if (m_computeV2) {
     ATH_MSG_INFO( "Will compute two flavors of OFCs" );
     ATH_MSG_INFO( "Version 1: useDelta= " << m_useDelta <<", output key: " <<  m_ofcKey << " AutoCorrDecoder: " << m_AutoCorrDecoder.name() );
     ATH_MSG_INFO( "Version 2: useDelta= " << m_useDeltaV2 <<", output key: " <<  m_ofcKeyV2 << " AutoCorrDecoder: " << m_AutoCorrDecoderV2.name() );
   }
   return StatusCode::SUCCESS;
 }

◆ initPhysWaveContainer()

StatusCode LArOFCAlg::initPhysWaveContainer ( const LArOnOffIdMapping * cabling )

private

Definition at line 633 of file LArOFCAlg.cxx.

                                                                             {
  
   typedef LArPhysWaveContainer::ConstConditionsMapIterator WAVEIT;
  
   for (unsigned k=0 ; k<m_keylist.size() ; k++ ) { // Loop over all containers that are to be processed (e.g. different gains)
     ATH_MSG_INFO( "Processing WaveContainer from StoreGate! key = " << m_keylist[k] );
  
     const LArPhysWaveContainer* waveCnt;
     StatusCode sc=detStore()->retrieve(waveCnt,m_keylist[k]);
     if (sc.isFailure()) {
       ATH_MSG_ERROR( "Failed to retrieve a LArPhysWaveContainer with key " << m_keylist[k] );
       return sc;
     }
       
     m_allChannelData.reserve(m_allChannelData.size()+128*waveCnt->size());// Size doesn't give the expected response on a CondtitionsContainer 
  
     for (unsigned gain = CaloGain::LARHIGHGAIN ; gain < CaloGain::LARNGAIN ; gain++ ) { // loop on possible gains
       WAVEIT it=waveCnt->begin(gain);
       WAVEIT it_e=waveCnt->end(gain);
       for (;it!=it_e;++it) {
     const HWIdentifier chid=it.channelId();
     if (cabling->isOnlineConnected (chid)){
       const LArWaveCumul* wave= &(*it); //down-cast
       if (!wave->isEmpty()) {
         m_allChannelData.emplace_back(wave, chid,gain);
       }
     }
       } //end loop over channels
     }//end loop over gains
   }//end loop over SG keys
   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);
   }

◆ optFilt()

void LArOFCAlg::optFilt	(	const std::vector< float > &	gWave_in,
		const std::vector< float > &	gDerivWave_in,
		const Eigen::MatrixXd &	autoCorrInv,
		std::vector< float > &	OFCa,
		std::vector< float > &	OFCb
	)

staticprivate

Definition at line 719 of file LArOFCAlg.cxx.

                                                                    { // Output variables;
   assert(gWave.size()==gDerivWave.size());
   //assert autoCorr size ....
   const int optNpt = gWave.size();
   
   Eigen::VectorXd gResp(optNpt), gDerivResp(optNpt);
   for (int i=0;i<optNpt;i++) {
     gResp[i] = gWave[i];
     gDerivResp[i] = gDerivWave[i];
   }
  
   Eigen::Matrix2d isol;
   isol << 
     (gResp.transpose()*acInverse*gResp)[0],
     (gResp.transpose()*acInverse*gDerivResp)[0],
     (gDerivResp.transpose()*acInverse*gResp)[0],
     (gDerivResp.transpose()*acInverse*gDerivResp)[0];
  
   Eigen::Vector2d Amp; 
   Eigen::Vector2d Atau;
   Eigen::Vector2d Ktemp;
   Eigen::Matrix2d isolInv = isol.inverse();
  
   //  we solve for the lagrange multiplers
   Ktemp[0] = 1.;
   Ktemp[1] = 0.;
   Amp = isolInv*Ktemp;
   
   Ktemp[0] = 0.; 
   Ktemp[1] = -1.;
   Atau = isolInv*Ktemp;
  
   // we express the a and b vectors in terms of the lagrange multipliers
   Eigen::VectorXd OFCa = Amp[0]*acInverse*gResp + Amp[1]*acInverse*gDerivResp;
   Eigen::VectorXd OFCb = Atau[0]*acInverse*gResp + Atau[1]*acInverse*gDerivResp;
   
   //Convert back to std::vector
   vecOFCa.resize(optNpt);
   vecOFCb.resize(optNpt);
   for (int i=0;i<optNpt;i++) {
     vecOFCa[i]=OFCa[i];
     vecOFCb[i]=OFCb[i];
   }
   }

◆ optFiltDelta()

void LArOFCAlg::optFiltDelta	(	const std::vector< float > &	gWave_in,
		const std::vector< float > &	gDerivWave_in,
		const Eigen::MatrixXd &	autoCorrInv,
		const Eigen::VectorXd &	delta,
		std::vector< float > &	vecOFCa,
		std::vector< float > &	vecOFCb
	)

staticprivate

HepVector delta(5) ;

delta[0]=3.79198742146; delta[1]=-4.84165741965; delta[2]=3.20189843985; delta[3]=-5.90850592618; delta[4]=1.8260451328;

Definition at line 770 of file LArOFCAlg.cxx.

                                                                         { 
  
   
  
   assert(gWave.size()==gDerivWave.size());
   //assert autoCorr size ....
   const int optNpt = gWave.size();
   
   Eigen::VectorXd gResp(optNpt), gDerivResp(optNpt);
   for (int i=0;i<optNpt;i++) {
     gResp[i] = gWave[i];
     gDerivResp[i] = gDerivWave[i];
   }
  
   // try 3X3 matrix with offsets
  
   
   Eigen::Matrix3d isol;
   isol << 
     (gResp.transpose()*acInverse*gResp)[0],
     (gResp.transpose()*acInverse*gDerivResp),
     (gResp.transpose()*acInverse*delta)[0],
     
     (gDerivResp.transpose()*acInverse*gResp)[0],
     (gDerivResp.transpose()*acInverse*gDerivResp)[0],
     (gDerivResp.transpose()*acInverse*delta)[0],
     
     (delta.transpose()*acInverse*gResp)[0],
     (delta.transpose()*acInverse*gDerivResp)[0],
     (delta.transpose()*acInverse*delta)[0];
   
  
   Eigen::Vector3d Amp; 
   Eigen::Vector3d Atau;
   Eigen::Vector3d Ktemp;
   Eigen::Matrix3d isolInv = isol.inverse();
  
   //  we solve for the lagrange multiplers
  
   Ktemp[0] = 1.;
   Ktemp[1] = 0.;
   Ktemp[2] = 0.;
  
   Amp = isolInv*Ktemp;
     
   Ktemp[0] = 0.; 
   Ktemp[1] = -1.;
   Atau = isolInv*Ktemp;
  
   // we express the a and b vectors in terms of the lagrange multipliers
   Eigen::VectorXd OFCa = Amp[0]*acInverse*gResp + Amp[1]*acInverse*gDerivResp + Amp[2]*acInverse * delta;
   Eigen::VectorXd OFCb = Atau[0]*acInverse*gResp + Atau[1]*acInverse*gDerivResp + Atau[2]*acInverse * delta  ;
  
  
   //Convert back to std::vector
   vecOFCa.resize(optNpt);
   vecOFCb.resize(optNpt);
   for (int i=0;i<optNpt;i++) {
     vecOFCa[i]=OFCa[i];
     vecOFCb[i]=OFCb[i];
   }
   }

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

◆ printOFCVec()

void LArOFCAlg::printOFCVec	(	const std::vector< float > &	vec,
		MsgStream &	mLog
	)

staticprivate

Definition at line 989 of file LArOFCAlg.cxx.

                                                                         {
   mLog << MSG::WARNING << "OFCs";
     for(float v : vec) 
       mLog << " " << v;
   mLog << endmsg;
 }

◆ process()

void LArOFCAlg::process	(	perChannelData_t &	chanData,
		const LArOnOffIdMapping *	cabling
	)		const

private

Definition at line 447 of file LArOFCAlg.cxx.

                                                                                           {
  
   LArWaveHelper larWaveHelper;
   const LArWaveCumul* nextWave=chanData.inputWave;
   if (!nextWave) {
     ATH_MSG_ERROR( "input wave is 0" );
     return;
   }
  
   if ( nextWave->getFlag() == LArWave::dac0 ) return ; // skip dac0 waves
  
   const HWIdentifier ch_id=chanData.chid;
   const unsigned gain=chanData.gain;
   ATH_MSG_DEBUG( "Computing OFC for channel " << m_onlineID->channel_name(ch_id) << " in gain = " << gain);
       
       
   // check constistency of settings
   if ( m_nPoints > nextWave->getSize() ) {
     ATH_MSG_ERROR( "Channel " << m_onlineID->channel_name(ch_id) <<": Wave size (" << nextWave->getSize() 
             << ") is too small to fit your OFC request (" << m_nPoints << " points)" ) ;
     chanData.shortWave=true;
     return;
   }
  
   // the current waveform
   LArWave aWave = *nextWave; // Actually *copying* the Wave to get rid of the const: need to manipulate Wave to normalize...
  
   if (m_larPhysWaveBin) {
     const int bin = m_larPhysWaveBin->bin(ch_id,gain);
     if (bin>-998) { //>ERRORCODE
       ATH_MSG_VERBOSE("Channel " << m_onlineID->channel_name(ch_id) << ": shift by index " << bin);
       aWave=larWaveHelper.translate(aWave,-bin,0);
     }
     else
       ATH_MSG_VERBOSE("Channel 0x" << MSG::hex << ch_id.get_identifier32().get_compact() << MSG::dec << ": No valid index for shifting");
   }//end if larPhysWaveBin
  
  
   // normalize input wave, if requested      
   if (m_normalize) {
     const double peak = aWave.getSample( larWaveHelper.getMax(aWave) );
     if ( peak == 0 ) {
       ATH_MSG_ERROR( "Wave maximum is zero, skipping channel " << m_onlineID->channel_name(ch_id) ) ;
       return;
     }
  
     ATH_MSG_VERBOSE("Channel 0x" << m_onlineID->channel_name(ch_id) << " has amplitude = " << peak << ": normalizing...");
     aWave = aWave * (1./peak);
   } 
  
   ATH_MSG_VERBOSE("Channel " << m_onlineID->channel_name(ch_id) <<  " has now amplitude = " <<  aWave.getSample( larWaveHelper.getMax(aWave)));
   // compute tstart to shift input wave, if requested
   if ( m_timeShift ) {
     if( m_timeShiftByIndex == -1 ) {
       chanData.tstart = larWaveHelper.getStart(aWave) ;
     } else {
       chanData.tstart = m_timeShiftByIndex;
     }
   }
       
   ATH_MSG_DEBUG("Channel" << m_onlineID->channel_name(ch_id) << ", Tstart = " << chanData.tstart);
  
   //Calculate derivative for this wave
   LArWave aDerivedWave = larWaveHelper.derive_smooth(aWave);
  
   chanData.timeBinWidthOFC = m_dPhases*aWave.getDt();
  
   float maxSampleValAt3=-1;
       
   //prepare output vectors
   chanData.ofc_a.resize(m_nPhases);
   chanData.ofc_b.resize(m_nPhases);  
   chanData.shape.resize(m_nPhases);     
   chanData.shapeDer.resize(m_nPhases);  
  
   if (m_computeV2) {
      chanData.ofcV2_a.resize(m_nPhases);
      chanData.ofcV2_b.resize(m_nPhases);  
   }
  
  
   const Eigen::MatrixXd acInverse=m_AutoCorrDecoder->AutoCorr(chanData.chid,(CaloGain::CaloGain)chanData.gain,m_nSamples).inverse();
   Eigen::MatrixXd acInverseV2;
   if (m_computeV2)
     acInverseV2=m_AutoCorrDecoderV2->AutoCorr(chanData.chid,(CaloGain::CaloGain)chanData.gain,m_nSamples).inverse();
  
   unsigned tShift=0;
   if(m_readDSPConfig && m_DSPConfig){
      if(m_DSPConfig->peakSample(m_onlineID->feb_Id(ch_id)) < 2 ) { // 2 is canonical value for peak
         tShift = 2 - m_DSPConfig->peakSample(m_onlineID->feb_Id(ch_id));
      }
   }
   if(m_forceShift) tShift=1;
  
   ATH_MSG_DEBUG("Channel " << m_onlineID->channel_name(ch_id) << "shift: " << tShift);
  
   for (unsigned iPhase=0;iPhase<m_nPhases;iPhase++) { //Loop over all phases
         
     ATH_MSG_VERBOSE ("Channel " << m_onlineID->channel_name(ch_id) 
              << ", Gain = " << gain << ", Phase = " << iPhase << ":");
  
  
     //Reference to the samples and deriviative to be filled
     std::vector<float>& theSamples=chanData.shape[iPhase];
     std::vector<float>& theSamplesDer=chanData.shapeDer[iPhase];
  
     //Extract the points where we compute the OFCs from the wave and the derived wave
     //and fill the samples an derivative vector
     theSamples.reserve(m_nSamples);
     theSamplesDer.reserve(m_nSamples);
     for (unsigned iSample=0;iSample<m_nSamples;++iSample){ //Loop over all samples
       const unsigned tbin = chanData.tstart + iPhase*m_dPhases + (iSample+tShift)*m_nDelays ;     
       theSamples.push_back( aWave.getSample(tbin) );
       theSamplesDer.push_back( aDerivedWave.getSample(tbin) );
     } //End loop over samples
  
  
     if (m_storeMaxPhase && m_nSamples>2 && theSamples[2]>maxSampleValAt3) {
       maxSampleValAt3=theSamples[2];
       chanData.phasewMaxAt3=iPhase;
     }
  
     bool thisChanUseDelta=useDelta(ch_id,m_useDelta,cabling);
     bool thisChanUseDeltaV2=m_computeV2 && useDelta(ch_id,m_useDeltaV2,cabling);
     Eigen::VectorXd delta;
  
     if (thisChanUseDelta || thisChanUseDeltaV2) { // will need delta for at least one of the two versions
       std::vector<float> theSamples32;
       theSamples32.reserve(32);
       for (unsigned iSample=0;iSample<32 ;++iSample){ //Loop over all samples
     const unsigned tbin = chanData.tstart + iPhase*m_dPhases + (iSample+tShift)*m_nDelays ;   
     if (tbin>=aWave.getSize()) continue;
     theSamples32.push_back( aWave.getSample(tbin) );
       } //End loop over samples
       delta=getDelta(theSamples32,ch_id,m_nSamples);
     }
  
     //OFC V1 computiation (i.e. not pileup-optimized)
     //Reference to the OFCa and OFCb to be filled
     std::vector<float>& vOFC_a= chanData.ofc_a[iPhase];
     std::vector<float>& vOFC_b= chanData.ofc_b[iPhase];
  
     if (thisChanUseDelta) {      
       optFiltDelta(theSamples,theSamplesDer,acInverse,delta,vOFC_a,vOFC_b);  
     } 
     else { //don't use Delta
       optFilt(theSamples,theSamplesDer,acInverse,vOFC_a,vOFC_b);
     }
     
     // verify OFC consistency
     if (m_verify) {
       chanData.faultyOFC |= verify(chanData.chid,vOFC_a,vOFC_b,theSamples,"OFC",iPhase);
     } 
     
  
     if (m_computeV2) {
       //OFC V2 computiation (i.e. pileup-optimized)
       //Reference to the OFCa and OFCb to be filled
       std::vector<float>& vOFCV2_a= chanData.ofcV2_a[iPhase];
       std::vector<float>& vOFCV2_b= chanData.ofcV2_b[iPhase];
       
       if (thisChanUseDeltaV2) {
     optFiltDelta(theSamples,theSamplesDer,acInverseV2,delta,vOFCV2_a,vOFCV2_b);
       } 
       else { //don't use Delta
     optFilt(theSamples,theSamplesDer,acInverseV2,vOFCV2_a,vOFCV2_b);
       }
  
       // verify OFC consistency
       if (m_verify) {
     chanData.faultyOFC |= verify(chanData.chid,vOFCV2_a,vOFCV2_b,theSamples,"OFCV2",iPhase);
       } 
     }//end if computeV2
   } //End loop over all phases
  
   // in case we're dealing with a LArPhysWave, add any possible previous time shift
   if (!m_readCaliWave) {
     const LArPhysWave* pwave=dynamic_cast<const LArPhysWave*>(nextWave);
     if (pwave)
       chanData.tstart += pwave->getTimeOffset()+m_addOffset;
   }
   }

◆ 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 LArOFCAlg::stop ( )

virtual

TBB global control parameter

Definition at line 165 of file LArOFCAlg.cxx.

 {
  
   ATH_MSG_DEBUG( "In LArOFCAlg finalize()");
   
   ATH_MSG_INFO( "Number of samples            : " << m_nSamples ) ;
   ATH_MSG_INFO( "Number of delays acquired    : " << m_nDelays  ) ;
   ATH_MSG_INFO( "Number of phases in OFC      : " << m_nPhases  ) ;
   ATH_MSG_INFO( "Spacing between two phases   : " << m_dPhases  ) ;
  
   
   const LArOnOffIdMapping* cabling{nullptr};
   if(m_isSC) {
     SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKeySC};
     ATH_CHECK(cablingHdl.isValid());
     cabling = *cablingHdl;
  
     if (m_useDelta == 3 || m_useDeltaV2==3){
       SG::ReadCondHandle<CaloSuperCellDetDescrManager> caloSuperCellMgrHandle{m_caloSuperCellMgrKey};
       ATH_CHECK(caloSuperCellMgrHandle.isValid());
       m_calo_dd_man = *caloSuperCellMgrHandle;
     }
   }
   else {
     SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKey};
     ATH_CHECK(cablingHdl.isValid());
     cabling = *cablingHdl;
  
     if (m_useDelta == 3 || m_useDeltaV2==3){
       SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey};
       ATH_CHECK(caloMgrHandle.isValid());
       m_calo_dd_man = *caloMgrHandle;
     }
   }
  
   if ( m_timeShift ) {
     if( m_timeShiftByIndex == -1 ) {
       ATH_MSG_INFO( "    Will use helper class for start time." );
     } else {
       ATH_MSG_INFO( "    Manually shifting pulses by time index " << m_timeShiftByIndex );
     }
   }
   
   if (!m_larPhysWaveBinKey.empty()) {
     ATH_CHECK(detStore()->retrieve(m_larPhysWaveBin,m_larPhysWaveBinKey));
   }
  
   if (m_readCaliWave) {
     ATH_CHECK(this->initCaliWaveContainer());
   }
   else {
     ATH_CHECK(this->initPhysWaveContainer(cabling));
   }
  
   if (m_readDSPConfig) {
     const AthenaAttributeList* attrList=nullptr;
     ATH_CHECK(detStore()->retrieve(attrList, m_DSPConfigFolder));
     
     const coral::Blob& blob = (attrList->coralList())["febdata"].data<coral::Blob>();
     if (blob.size()<3) {
       ATH_MSG_INFO( "Found empty blob, nothing to do");
     } else {
       m_DSPConfig = std::make_unique<LArDSPConfig>(attrList);
     }
   }
  
   if (m_allChannelData.empty()) {
     ATH_MSG_ERROR( "No input waves found" );
     return StatusCode::FAILURE;
   }
  
   if (m_nThreads>-1) {
     //There are sone external tools, etc. that potentially cached stuff.
     //We need to call them at least once to make sure all caches are filled before we go multi-threaded
     perChannelData_t& chanData=m_allChannelData[0];
  
     m_AutoCorrDecoder->AutoCorr(chanData.chid,(CaloGain::CaloGain)chanData.gain,m_nSamples);
     if (m_computeV2)
       m_AutoCorrDecoderV2->AutoCorr(chanData.chid,(CaloGain::CaloGain)chanData.gain,m_nSamples);
       
     Identifier id=cabling->cnvToIdentifier(chanData.chid);
     if (m_useDelta==3 || m_useDeltaV2) {
       m_calo_dd_man->get_element(id);
     }
  
     std::ignore = m_onlineID->isFCALchannel(chanData.chid);
  
  
     if (!m_larPhysWaveBinKey.empty()) {
         m_larPhysWaveBin->bin(chanData.chid,(CaloGain::CaloGain)chanData.gain);
     }
     std::unique_ptr<tbb::global_control> tbbgc;
  
     if (m_nThreads>0) {
       tbbgc=std::make_unique<tbb::global_control>( tbb::global_control::max_allowed_parallelism, m_nThreads);
     }
  
     //Instanciated the functor and start parallel_for
     Looper looper(&m_allChannelData,cabling, this);
     tbb::blocked_range<size_t> range(0, m_allChannelData.size());
     ATH_MSG_INFO( "Starting parallel execution" );
     tbb::parallel_for(tbb::blocked_range<size_t>(0, m_allChannelData.size()),looper);
  
     ATH_MSG_INFO( "Done with parallel execution" );
  
   }
   else {
     ATH_MSG_INFO( "Single threaded execution" );
     for (perChannelData_t& chanData : m_allChannelData) {
       this->process(chanData,cabling);
     }
   }
  
  
   // OFC persistent object
   std::unique_ptr<LArOFCComplete> larOFCComplete=std::make_unique<LArOFCComplete>();
   StatusCode sc = larOFCComplete->setGroupingType(m_groupingType,msg());
   if (sc.isFailure()) {
     ATH_MSG_ERROR( "Failed to set groupingType for LArOFCComplete object" );
     return sc;
   }
   sc=larOFCComplete->initialize(); 
   if (sc.isFailure()) {
     ATH_MSG_ERROR( "Failed initialize LArOFCComplete object" );
     return sc;
   }
  
  
   std::unique_ptr<LArOFCComplete> larOFCCompleteV2=std::make_unique<LArOFCComplete>();
   sc = larOFCComplete->setGroupingType(m_groupingType,msg());
   if (sc.isFailure()) {
     ATH_MSG_ERROR( "Failed to set groupingType for LArOFCComplete object" );
     return sc;
   }
   sc=larOFCCompleteV2->initialize(); 
   if (sc.isFailure()) {
     ATH_MSG_ERROR( "Failed initialize LArOFCComplete object" );
     return sc;
   }
  
  
   std::unique_ptr<LArOFCBinComplete> larOFCBinComplete;
   if (m_storeMaxPhase) {
     larOFCBinComplete=std::make_unique<LArOFCBinComplete>();
     sc=larOFCBinComplete->setGroupingType(m_groupingType,msg());
     if (sc.isFailure()) {
       ATH_MSG_ERROR( "Failed to set groupingType for LArOFCBinComplete object" );
       return sc;
     }
     sc  = larOFCBinComplete->initialize(); 
     if ( sc.isFailure() ) {
       ATH_MSG_ERROR( "Could not initialize LArOFCComplete data object - exit!" ) ;
       return sc ;
     }
   }
  
   // LArShape persistent object
   std::unique_ptr<LArShapeComplete> larShapeComplete;
   if (m_fillShape) {
     larShapeComplete = std::make_unique<LArShapeComplete>();
     sc=larShapeComplete->setGroupingType(m_groupingType,msg());
     if (sc.isFailure()) {
       ATH_MSG_ERROR( "Failed to set groupingType for LArShapeComplete object" );
       return sc;
     }
     sc=larShapeComplete->initialize(); 
     if (sc.isFailure()) {
       ATH_MSG_ERROR( "Failed initialize LArShapeComplete object" );
       return sc;
     }
   }
  
  
   //Counters (for information only):
   unsigned nChannels=0;
   unsigned nFailed=0;
  
   for (const perChannelData_t& chanData : m_allChannelData) {
     ++nChannels;
     if (chanData.faultyOFC) ++nFailed;
     // register channel to LArOFCComplete
     const HWIdentifier ch_id=chanData.chid;
     const int gain=chanData.gain;
     ATH_MSG_DEBUG( "add to LArOFCComplete, channel " << m_onlineID->channel_name(ch_id) << ", gain=" << (int)gain);
     const std::vector<std::vector<float> > & allPhaseOFCa=chanData.ofc_a;
     const std::vector<std::vector<float> > & allPhaseOFCb=chanData.ofc_b;
     const std::vector<std::vector<float> > & allPhaseShape=chanData.shape;
     const std::vector<std::vector<float> > & allPhaseShapeDer=chanData.shapeDer;
     larOFCComplete->set(ch_id,gain,allPhaseOFCa,allPhaseOFCb,chanData.tstart,chanData.timeBinWidthOFC);
     if (larOFCBinComplete) larOFCBinComplete->set(ch_id,gain,chanData.phasewMaxAt3);      
     if ( m_fillShape ) larShapeComplete->set(ch_id,gain,allPhaseShape,allPhaseShapeDer,chanData.tstart,chanData.timeBinWidthOFC);      
     
     
     if (m_computeV2) {
       const std::vector<std::vector<float> > & allPhaseOFCV2a=chanData.ofcV2_a;
       const std::vector<std::vector<float> > & allPhaseOFCV2b=chanData.ofcV2_b;
       larOFCCompleteV2->set(ch_id,gain,allPhaseOFCV2a,allPhaseOFCV2b,chanData.tstart,chanData.timeBinWidthOFC);
     }
     
   } // end loop over m_allChannelData
  
   ATH_MSG_INFO( " Summary : Computed OFCs for " << nChannels << " channels * gains" );
   if (nFailed) 
     ATH_MSG_ERROR( "Number of channels * gains with failed OFC verification: " <<  nFailed );
  
   if ( !m_dumpOFCfile.empty()) {
     ATH_MSG_INFO( "Dumping OFCs to file " << m_dumpOFCfile ) ;
     larOFCComplete->dumpOFC(m_dumpOFCfile) ;
   }
  
   sc = detStore()->record(std::move(larOFCComplete),m_ofcKey);
   if (sc.isFailure()) {
       ATH_MSG_ERROR( "Could not record LArOFCComplete to DetStore with key " << m_ofcKey );
       return StatusCode::FAILURE;
   }
   ATH_MSG_INFO( "LArOFCComplete object recorded with key " << m_ofcKey ) ;
  
   sc=detStore()->symLink(ClassID_traits<LArOFCComplete>::ID(),m_ofcKey,ClassID_traits<ILArOFC>::ID());
   if (sc.isFailure()) {
       ATH_MSG_ERROR( "Could not symlink ILArOFC with LArOFCComplete." );
       return StatusCode::FAILURE;
   } 
   ATH_MSG_INFO( "Symlink with ILArOFC done" ) ;
   
  
   // record and symlink second version of LArOFCComplete object
   if (m_computeV2) {
     sc = detStore()->record(std::move(larOFCCompleteV2),m_ofcKeyV2);
     if (sc.isFailure()) {
       ATH_MSG_ERROR( "Could not record LArOFCComplete to DetStore with key " << m_ofcKeyV2 );
       return StatusCode::FAILURE;
     }
     ATH_MSG_INFO( "LArOFCComplete object recorded with key " << m_ofcKeyV2 ) ;
  
     sc=detStore()->symLink(ClassID_traits<LArOFCComplete>::ID(),m_ofcKeyV2,ClassID_traits<ILArOFC>::ID());
     if (sc.isFailure()) {
       ATH_MSG_ERROR( "Could not symlink ILArOFC with LArOFCComplete." );
       return StatusCode::FAILURE;
     } 
     ATH_MSG_INFO( "Symlink with ILArOFC done" ) ;
   }
  
   if (larOFCBinComplete) {
     sc = detStore()->record(std::move(larOFCBinComplete),m_ofcBinKey);
     if (sc.isFailure()) {
        ATH_MSG_ERROR( "Could not record LArOFCBinCompete object" );
        return StatusCode::FAILURE;
     }
   }
   
   // record and symlink LArShapeComplete object
   if ( m_fillShape ) {
     ATH_MSG_DEBUG( "Trying to record LArShapeComplete object to detector store, key = " << m_shapeKey);
     sc = detStore()->record(std::move(larShapeComplete),m_shapeKey);
     if (sc.isFailure()) {
        ATH_MSG_ERROR( "Could not record LArShapeComplete to DetStore with key " << m_shapeKey );
        return StatusCode::FAILURE;
     }
     ATH_MSG_INFO( "LArShapeComplete object recorded to DetStore successfully with key " << m_shapeKey ) ;
     ATH_MSG_DEBUG( "Trying to symlink ILArShape with LArShapeComplete");
     sc=detStore()->symLink(ClassID_traits<LArShapeComplete>::ID(),m_shapeKey,ClassID_traits<ILArShape>::ID());
     if (sc.isFailure()) {
       ATH_MSG_ERROR( "Could not symlink ILArShape with LArShapeComplete." );
       return StatusCode::FAILURE;
     } 
     ATH_MSG_INFO( "ILArShape symlink with LArShapeComplete successfully" ) ;
   }  
  
  
   //Undo corrections, if they are applied by this algo:
   if (m_waveCnt_nc) {
     ATH_CHECK(m_waveCnt_nc->undoCorrections());
     ATH_MSG_INFO("Reverted corrections of non-cost wave container");
   }
  
   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);
       }
     }
   }

◆ useDelta()

bool LArOFCAlg::useDelta	(	const HWIdentifier	chid,
		const int	jobOFlag,
		const LArOnOffIdMapping *	cabling
	)		const

private

Definition at line 899 of file LArOFCAlg.cxx.

                                                                                                             {
  
   if (jobOFlag==2){
       return true;
     }
  
   if(jobOFlag==1) { // only HEC/EMECIW/FCAL
     if (m_onlineID->isEMECIW(chid) || m_onlineID->isFCALchannel(chid) || m_onlineID->isHECchannel(chid)) {
       return true;
     }
   }
  
   if(jobOFlag==3) { // only HEC/EMECIW/FCAL1 and high eta FCAL2-3 
     if (m_onlineID->isEMECIW(chid) ||  m_onlineID->isHECchannel(chid)) {
       return true;
     }
     else if (m_onlineID->isFCALchannel(chid) ){
  
       if (cabling->isOnlineConnected (chid)){
     Identifier ofl_id = cabling->cnvToIdentifier(chid);
     const CaloDetDescrElement* dde = m_calo_dd_man->get_element(ofl_id);
     if (! dde) {
       ATH_MSG_ERROR( " dde = 0 , onl_id, ofl_id= "<< chid<<" "<<ofl_id );
       return false; // Exception better? 
     }
     if ( m_isSC ) {
       CaloCell_SuperCell_ID::CaloSample sampling = dde->getSampling();
       if (sampling==CaloCell_ID::FCAL0){
         return true;
       }
       else {
         if (fabs(dde->eta())>4.0){
          return true;
         }
       }
     } else {
       CaloCell_ID::CaloSample sampling = dde->getSampling();
       if (sampling==CaloCell_ID::FCAL0){
         return true;
       }
       else {
         if (fabs(dde->eta())>4.0){
          return true;
         }
       }
     }
     
       }//end if connected
     }//end if isFCALchannel
  
   }//else if jobOFlag=3
  
   return false;
 }

◆ verify()

bool LArOFCAlg::verify	(	const HWIdentifier	chid,
		const std::vector< float > &	OFCa,
		const std::vector< float > &	OFCb,
		const std::vector< float > &	Shape,
		const char *	ofcversion,
		const unsigned	phase
	)		const

private

Definition at line 955 of file LArOFCAlg.cxx.

                                                                                                   {
  
   bool result=false;
   float recAmpl=0, recTime=0;
   for (unsigned iSample=0;iSample<m_nSamples;++iSample){
  
 #ifdef LAROFCALG_DEBUGOUTPUT
     ATH_MSG_VERBOSE("a["<<iSample<<"]="<<vOFC_a[iSample] << " b["<<iSample<<"]="<<vOFC_b[iSample] 
             << " Sample=" << aWave.getSample(tbin));
 #endif
     recAmpl += OFCa[iSample] * Shape[iSample];
     recTime += OFCb[iSample] * Shape[iSample];
   } //End loop over samples
  
   recTime /= recAmpl ;
  
   // At this point the reconstructed amplitude must be = 1 by definition, whatever the initial normalisation!
   ATH_MSG_VERBOSE("recAmp=" << recAmpl << " ; recTime=" << recTime);
   if ( fabs(1.-recAmpl) > m_errAmpl ) {
     ATH_MSG_WARNING( "Applying phase " << phase << " of " << ofcversion << " to original wave yields an Amplitude of "<< recAmpl 
               << " instead of 1. -> Wrong OFCs? channel " << m_onlineID->channel_name(chid) );
     LArOFCAlg::printOFCVec(OFCa,msg());
     result=true;
   }
   if ( fabs(recTime) > m_errTime ) {
     ATH_MSG_WARNING( "Applying  phase " << phase << " of " << ofcversion << " to original wave yields a time offset of " << recTime 
                << " -> Wrong OFCs? channel " << m_onlineID->channel_name(chid) );
     LArOFCAlg::printOFCVec(OFCb,msg());
     result=true; 
   }
   return result;
 }

Member Data Documentation

◆ m_addOffset

float LArOFCAlg::m_addOffset

private

Definition at line 133 of file LArOFCAlg.h.

◆ m_allChannelData

std::vector<perChannelData_t> LArOFCAlg::m_allChannelData

private

Definition at line 94 of file LArOFCAlg.h.

◆ m_AutoCorrDecoder

ToolHandle<ILArAutoCorrDecoderTool> LArOFCAlg::m_AutoCorrDecoder {this,"DecoderTool",{} }

private

Definition at line 135 of file LArOFCAlg.h.

◆ m_AutoCorrDecoderV2

ToolHandle<ILArAutoCorrDecoderTool> LArOFCAlg::m_AutoCorrDecoderV2 {this,"DecoderToolV2", {} }

private

Definition at line 136 of file LArOFCAlg.h.

◆ m_cablingKey

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

private

Definition at line 52 of file LArOFCAlg.h.

◆ m_cablingKeySC

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

private

Definition at line 53 of file LArOFCAlg.h.

◆ m_calo_dd_man

const CaloDetDescrManager_Base* LArOFCAlg::m_calo_dd_man

private

Definition at line 138 of file LArOFCAlg.h.

◆ m_caloMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> LArOFCAlg::m_caloMgrKey

private

Initial value:

{ this
      , "CaloDetDescrManager"
      , "CaloDetDescrManager"
      , "SG Key for CaloDetDescrManager in the Condition Store" }

Definition at line 55 of file LArOFCAlg.h.

◆ m_caloSuperCellMgrKey

SG::ReadCondHandleKey<CaloSuperCellDetDescrManager> LArOFCAlg::m_caloSuperCellMgrKey

private

Initial value:

{ this
      , "CaloSuperCellDetDescrManager"
      , "CaloSuperCellDetDescrManager"
      , "SG Key for CaloSuperCellDetDescrManager in the Condition Store" }

Definition at line 60 of file LArOFCAlg.h.

◆ m_computeV2

bool LArOFCAlg::m_computeV2

private

Definition at line 159 of file LArOFCAlg.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_dPhases

unsigned int LArOFCAlg::m_dPhases

private

Definition at line 130 of file LArOFCAlg.h.

◆ m_DSPConfig

std::unique_ptr<LArDSPConfig> LArOFCAlg::m_DSPConfig

private

Definition at line 164 of file LArOFCAlg.h.

◆ m_DSPConfigFolder

std::string LArOFCAlg::m_DSPConfigFolder

private

Definition at line 163 of file LArOFCAlg.h.

◆ m_dumpOFCfile

std::string LArOFCAlg::m_dumpOFCfile

private

Definition at line 118 of file LArOFCAlg.h.

◆ m_errAmpl

double LArOFCAlg::m_errAmpl

private

Definition at line 142 of file LArOFCAlg.h.

◆ m_errTime

double LArOFCAlg::m_errTime

private

Definition at line 143 of file LArOFCAlg.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_fcal1Delta

const float LArOFCAlg::m_fcal1Delta ={0.0679600232979, -0.139479996869, 0.0679600232979, -0.139479996869, 0.0679600232979}

staticprivate

Definition at line 176 of file LArOFCAlg.h.

◆ m_fcal2Delta

const float LArOFCAlg::m_fcal2Delta ={-0.01589001104, -0.0740399733186, -0.01589001104, -0.0740399733186, -0.01589001104}

staticprivate

Definition at line 175 of file LArOFCAlg.h.

◆ m_fcal3Delta

const float LArOFCAlg::m_fcal3Delta ={0.0790199937765, 0.0952000226825, 0.0790199937765, 0.0952000226825, 0.0790199937765}

staticprivate

Definition at line 174 of file LArOFCAlg.h.

◆ m_fillShape

bool LArOFCAlg::m_fillShape

private

Definition at line 146 of file LArOFCAlg.h.

◆ m_forceShift

bool LArOFCAlg::m_forceShift

private

Definition at line 166 of file LArOFCAlg.h.

◆ m_groupingType

std::string LArOFCAlg::m_groupingType

private

Definition at line 154 of file LArOFCAlg.h.

◆ m_isSC

bool LArOFCAlg::m_isSC

private

Definition at line 196 of file LArOFCAlg.h.

◆ m_keylist

std::vector<std::string> LArOFCAlg::m_keylist

private

Definition at line 119 of file LArOFCAlg.h.

◆ m_larPhysWaveBin

const LArOFCBinComplete* LArOFCAlg::m_larPhysWaveBin

private

Definition at line 140 of file LArOFCAlg.h.

◆ m_larPhysWaveBinKey

std::string LArOFCAlg::m_larPhysWaveBinKey

private

Definition at line 155 of file LArOFCAlg.h.

◆ m_nDelays

unsigned int LArOFCAlg::m_nDelays

private

Definition at line 131 of file LArOFCAlg.h.

◆ m_normalize

bool LArOFCAlg::m_normalize

private

Definition at line 121 of file LArOFCAlg.h.

◆ m_nPhases

unsigned int LArOFCAlg::m_nPhases

private

Definition at line 129 of file LArOFCAlg.h.

◆ m_nPoints

unsigned int LArOFCAlg::m_nPoints

private

Definition at line 132 of file LArOFCAlg.h.

◆ m_nSamples

unsigned int LArOFCAlg::m_nSamples

private

Definition at line 128 of file LArOFCAlg.h.

◆ m_nThreads

int LArOFCAlg::m_nThreads

private

Definition at line 160 of file LArOFCAlg.h.

◆ m_ofcBinKey

std::string LArOFCAlg::m_ofcBinKey

private

Definition at line 151 of file LArOFCAlg.h.

◆ m_ofcKey

std::string LArOFCAlg::m_ofcKey

private

Definition at line 147 of file LArOFCAlg.h.

◆ m_ofcKeyV2

std::string LArOFCAlg::m_ofcKeyV2

private

Definition at line 148 of file LArOFCAlg.h.

◆ m_onlineID

const LArOnlineID_Base* LArOFCAlg::m_onlineID

private

Definition at line 139 of file LArOFCAlg.h.

◆ m_readCaliWave

bool LArOFCAlg::m_readCaliWave

private

Definition at line 145 of file LArOFCAlg.h.

◆ m_readDSPConfig

bool LArOFCAlg::m_readDSPConfig

private

Definition at line 162 of file LArOFCAlg.h.

◆ m_shapeKey

std::string LArOFCAlg::m_shapeKey

private

Definition at line 149 of file LArOFCAlg.h.

◆ m_storeMaxPhase

bool LArOFCAlg::m_storeMaxPhase

private

Definition at line 150 of file LArOFCAlg.h.

◆ m_timeShift

bool LArOFCAlg::m_timeShift

private

Definition at line 122 of file LArOFCAlg.h.

◆ m_timeShiftByIndex

int LArOFCAlg::m_timeShiftByIndex

private

Definition at line 123 of file LArOFCAlg.h.

◆ m_useDelta

int LArOFCAlg::m_useDelta

private

Definition at line 157 of file LArOFCAlg.h.

◆ m_useDeltaV2

int LArOFCAlg::m_useDeltaV2

private

Definition at line 158 of file LArOFCAlg.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_verify

bool LArOFCAlg::m_verify

private

Definition at line 120 of file LArOFCAlg.h.

◆ m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_waveCnt_nc

LArCaliWaveContainer* LArOFCAlg::m_waveCnt_nc =nullptr

private

Definition at line 126 of file LArOFCAlg.h.

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

Classes

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ LArOFCAlg()

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

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ finalize()

◆ getDelta()

◆ initCaliWaveContainer()

◆ initialize()

◆ initPhysWaveContainer()

◆ inputHandles()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ optFilt()

◆ optFiltDelta()

◆ outputHandles()

◆ printOFCVec()

◆ process()

◆ renounce()

◆ renounceArray()

◆ stop()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

◆ useDelta()

◆ verify()

Member Data Documentation

◆ m_addOffset

◆ m_allChannelData

◆ m_AutoCorrDecoder

◆ m_AutoCorrDecoderV2

◆ m_cablingKey

◆ m_cablingKeySC

◆ m_calo_dd_man

◆ m_caloMgrKey

◆ m_caloSuperCellMgrKey

◆ m_computeV2

◆ m_detStore

◆ m_dPhases

◆ m_DSPConfig

◆ m_DSPConfigFolder

◆ m_dumpOFCfile

◆ m_errAmpl

◆ m_errTime

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_fcal1Delta

◆ m_fcal2Delta

◆ m_fcal3Delta

◆ m_fillShape

◆ m_forceShift

◆ m_groupingType

◆ m_isSC

◆ m_keylist