#include <LArRampBuilder.h>

Inheritance diagram for LArRampBuilder:

Collaboration diagram for LArRampBuilder:

Public Types
typedef std::map< uint32_t, LArCalibTriggerAccumulator >	ACCRAMP

Public Member Functions
	~LArRampBuilder ()

StatusCode	initialize ()

StatusCode	execute ()

virtual StatusCode	stop ()

StatusCode	finalize ()

	AthAlgorithm (const std::string &name, ISvcLocator *pSvcLocator)
	Constructor with parameters: More...

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
enum	recoType { PARABOLA, SHAPE, OF }

typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	chooseRecoMode ()

StatusCode	rampfit (unsigned deg, const std::vector< LArRawRamp::RAMPPOINT_t > &data, std::vector< float > &rampCoeffs, std::vector< int > &vSat, const HWIdentifier chid, const LArOnOffIdMapping cabling, const LArBadChannelCont bcCont)

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, "OnOffMap", "LArOnOffIdMap", "SG key for mapping object"}

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

std::unique_ptr< LArConditionsContainer< ACCRAMP > >	m_ramps

PublicToolHandle< LArParabolaPeakRecoTool >	m_peakParabolaTool {this,"LArParabolaPeakRecoTool","LArParabolaPeakRecoTool"}

PublicToolHandle< LArShapePeakRecoTool >	m_peakShapeTool {this,"LArShapePeakRecoTool","LArShapePeakRecoTool"}

ToolHandle< LArOFPeakRecoTool >	m_peakOFTool {this,"PeakOFTool","LArOFPeakRecoTool"}

unsigned	m_event_counter =0

int	m_delay =-1

int	m_ipassShape =0

std::vector< std::vector< std::vector< std::vector< double > > > >	m_CaliWaves

std::vector< std::vector< std::vector< unsigned int > > >	m_CaliDACs

std::vector< std::vector< int > >	m_IndexDAC0

std::vector< std::vector< int > >	m_IndexHighestDAC

std::vector< float >	m_thePedestal

recoType	m_recoType {OF}

Gaudi::Property< std::vector< std::string > >	m_keylist {this, "KeyList",{},"List if input SG keys"}

Gaudi::Property< std::string >	m_keyoutput {this,"KeyOutput","LArRamp","SG Key of output object"}

IntegerProperty	m_degree {this,"Polynom",1,"Degree of ramp-polynom"}

IntegerProperty	m_maxADC {this,"RampRange",0,"Ignore ADC values higher than this (0: do nothing)"}

BooleanProperty	m_dac0sub {this,"SubtractDac0",true,"Take first DAC value as pedestal"}

UnsignedIntegerProperty	m_DAC0 {this,"DAC0",0,"DAC value considered DAC0"}

BooleanProperty	m_saveRawRamp {this,"StoreRawRamp",false,"Save raw ramp obj in SG"}

BooleanProperty	m_saveRecRamp {this,"StoreRecRamp",true,"Save reconstructed ramp obj in SG"}

BooleanProperty	m_satSlope {this,"doSatSlope",true,"Ignore points subject to saturation"}

UnsignedIntegerProperty	m_minDAC {this,"minDAC",0,"Ignore DAC values smaller that this"}

StringProperty	m_recoTypeProp {this,"RecoType","OF","One of 'Parabola', 'Shape' or 'OF'"}

IntegerProperty	m_deadChannelCut {this,"DeadChannelCut",1300,"Complain about channels with max-ADC below this value"}

BooleanProperty	m_correctBias {this,"correctBias",false,"For Parabola method: Correction yes/no"}

BooleanProperty	m_withIntercept {this,"WithIntercept",true,"False: Force fit to go through 0/0"}

FloatProperty	m_delayShift {this,"DelayShift",23}

Gaudi::Property< bool >	m_doBadChannelMask {this,"IgnoreBadChannels",true,"Don't complain about known bad channels"}

LArBadChannelMask	m_bcMask

SG::ReadCondHandleKey< LArBadChannelCont >	m_bcContKey {this, "BadChanKey", "LArBadChannel", "SG key for LArBadChan object"}

Gaudi::Property< std::vector< std::string > >	m_problemsToMask {this,"ProblemsToMask",{}, "Bad-Channel categories to mask"}

Gaudi::Property< std::string >	m_groupingType {this,"GroupingType","ExtendedFeedThrough","Grouping of the output conditions-container"}

Gaudi::Property< std::string >	m_hec_key {this,"HECKey","","SG Key of injection-resistor obj used for HEC Ramps"}

const LArOnlineID_Base *	m_onlineHelper =nullptr

const LArEM_Base_ID *	m_emId =nullptr

Gaudi::Property< bool >	m_isSC {this,"isSC",false,"Processing SC data yes/no"}

Gaudi::Property< bool >	m_ishec {this,"isHEC",false,"Processing HEC data yes/no"}

Gaudi::Property< bool >	m_iterate {this,"Iterate",false,"Iterative OF peak reco"}

uint16_t	m_fatalFebErrorPattern =0xffff

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 61 of file LArRampBuilder.h.

Member Typedef Documentation

◆ ACCRAMP

typedef std::map<uint32_t,LArCalibTriggerAccumulator> LArRampBuilder::ACCRAMP

Definition at line 74 of file LArRampBuilder.h.

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ recoType

enum LArRampBuilder::recoType

private

Enumerator
PARABOLA
SHAPE
OF

Definition at line 112 of file LArRampBuilder.h.

112 {PARABOLA,SHAPE,OF};

Constructor & Destructor Documentation

◆ ~LArRampBuilder()

LArRampBuilder::~LArRampBuilder ( )

inline

Definition at line 66 of file LArRampBuilder.h.

66 {};

Member Function Documentation

◆ AthAlgorithm()

AthAlgorithm::AthAlgorithm

Constructor with parameters:

Definition at line 51 of file AthAlgorithm.cxx.

                                                        :
   ::AthCommonDataStore<AthCommonMsg<Algorithm>>   ( name, pSvcLocator )
 {
   // Set up to run AthAlgorithmDHUpdate in sysInitialize before
   // merging dependency lists.  This extends the output dependency
   // list with any symlinks implied by inheritance relations.
   m_updateDataHandles =
     std::make_unique<AthenaBaseComps::AthAlgorithmDHUpdate>
     (m_extendedExtraObjects,
      std::move (m_updateDataHandles));
 }

◆ chooseRecoMode()

void LArRampBuilder::chooseRecoMode ( )

private

Definition at line 71 of file LArRampBuilder.cxx.

                                      {
   
   // choose reconstructiom mode
   if ( m_recoTypeProp == std::string("Parabola") ) {
     m_recoType=PARABOLA;
     StatusCode sc=m_peakParabolaTool.retrieve();
     if (sc!=StatusCode::SUCCESS) {
       ATH_MSG_ERROR( "Can't get LArParabolaPeakRecoTool" );
     return;
       }
     ATH_MSG_DEBUG("LArParabolaPeakRecoTool retrieved with success!");
     
     if(m_correctBias){
       // if using parabola, get offlineID helper to obtain the layer (needed for correction) 
       const CaloCell_ID* idHelper = nullptr;
       if ( detStore()->retrieve (idHelper, "CaloCell_ID").isSuccess() ) {
         m_emId = idHelper->em_idHelper();
       }
       if (!m_emId) {
     ATH_MSG_ERROR( "Could not access lar EM ID helper" );
     return ;
       }
       
     }
     m_peakShapeTool.disable();
     m_peakOFTool.disable();
     // Shape reconstruction
   } else if (m_recoTypeProp == std::string("Shape") ) {
     m_recoType=SHAPE;
     ATH_MSG_INFO( "ShapePeakReco mode is ON ! ");
     if (m_peakShapeTool.retrieve().isFailure()) {
       ATH_MSG_ERROR( "Can't get LArShapePeakRecoTool");
       return;
     }
     ATH_MSG_DEBUG("LArShapePeakRecoTool retrieved with success!");
     m_peakParabolaTool.disable();
     m_peakOFTool.disable();
     // OFC recontruction 
   } else if ( m_recoTypeProp == std::string("OF") ) {
     m_recoType=OF;
     if (m_peakOFTool.retrieve().isFailure()) {
       ATH_MSG_ERROR( "Can't get LArOFPeakRecoTool");
       return;
     }
     ATH_MSG_DEBUG("LArOFPeakRecoTool retrieved with success!");
     m_peakShapeTool.disable();
     m_peakParabolaTool.disable();
   }
 }

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

Definition at line 122 of file LArRampBuilder.cxx.

 { 
  
   StatusCode sc;
   if ( m_event_counter < 100 || m_event_counter%100==0 )
     ATH_MSG_INFO( "Processing event " << m_event_counter);
   ++m_event_counter;
   
   if (m_keylist.size()==0) {
     ATH_MSG_ERROR( "Key list is empty! No containers to process!");
     return StatusCode::FAILURE;
   }
   
   const LArFebErrorSummary* febErrSum=nullptr;
   if (evtStore()->contains<LArFebErrorSummary>("LArFebErrorSummary")) {
     sc=evtStore()->retrieve(febErrSum);
     if (sc.isFailure()) {
       ATH_MSG_ERROR( "Failed to retrieve FebErrorSummary object!");
       return sc;
     }
   }
   else
     if (m_event_counter==1)
       ATH_MSG_WARNING("No FebErrorSummaryObject found! Feb errors not checked!");
  
   const LArOnOffIdMapping* cabling(nullptr);
   if( m_isSC ){
     SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKeySC};
     cabling = {*cablingHdl};
     if(!cabling) {
     ATH_MSG_ERROR("Do not have mapping object " << m_cablingKeySC.key());
         return StatusCode::FAILURE;
     }
   }else{
     SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKey};
     cabling = {*cablingHdl};
     if(!cabling) {
        ATH_MSG_ERROR("Do not have mapping object " << m_cablingKey.key());
        return StatusCode::FAILURE;
     }
   }
   
  
   std::vector<std::string>::const_iterator key_it=m_keylist.begin();
   std::vector<std::string>::const_iterator key_it_e=m_keylist.end();
   
   const LArAccumulatedCalibDigitContainer* larAccumulatedCalibDigitContainer = nullptr;
   
   
   // if using Shape Reco method, retrieve caliWaveContainer (only once !)
   // FT remove the bitwise &&->&
   if ( m_recoType == SHAPE && m_ipassShape==0) {
     
     m_ipassShape = 1;
     
     // keep only 8 samples of wave - dont need all samples for pseudo-OF reco
     std::vector<double> tempWave;
     int NSamplesKeep = 8;
     tempWave.resize(24*NSamplesKeep);
     
     m_CaliWaves.resize(3);
     m_CaliDACs.resize(3);
     m_IndexDAC0.resize(3);
     m_IndexHighestDAC.resize(3);
     
     // retrieve cali wave container
     
     const LArCaliWaveContainer* caliWaveContainer = nullptr;
     ATH_MSG_WARNING("Will retrieve LArCaliWaveContainer ");
     sc= detStore()->retrieve(caliWaveContainer,"CaliWave");
     if (sc.isFailure()) {
       ATH_MSG_WARNING("Cannot read LArCaliWaveContainer from StoreGate for key 'CaliWave' ! ");
       return StatusCode::FAILURE;
     }
     ATH_MSG_DEBUG("Succefully retrieved LArCaliWaveContainer from StoreGate!");
     for (;key_it!=key_it_e;++key_it) { //Loop over all containers that are to be processed (e.g. different gains)
       
       // first, set reference DAC (dirty hardcoding for now...)
       CaloGain::CaloGain gainref = CaloGain::LARLOWGAIN;
       if(*key_it == "HIGH") {
     gainref=CaloGain::LARHIGHGAIN;
       }else if(*key_it == "MEDIUM") {
     gainref=CaloGain::LARMEDIUMGAIN;
       }else if(*key_it == "LOW") {
     gainref=CaloGain::LARLOWGAIN;
       }
       
       m_CaliWaves[gainref].resize(m_onlineHelper->channelHashMax());
       m_CaliDACs[gainref].resize(m_onlineHelper->channelHashMax());
       m_IndexDAC0[gainref].resize(m_onlineHelper->channelHashMax());
       m_IndexHighestDAC[gainref].resize(m_onlineHelper->channelHashMax());
       
       // Set gain from key value
       int gain = CaloGain::LARHIGHGAIN;
       if      ((*key_it) == "MEDIUM") gain = CaloGain::LARMEDIUMGAIN;
       else if ((*key_it) == "LOW")    gain = CaloGain::LARLOWGAIN;
       
       // extract from all the waves the ones we are interested in (a given DAC value)
       // and order them by hash ID in a vector
       typedef LArCaliWaveContainer::ConstConditionsMapIterator const_iterator;
       const_iterator itVec   = caliWaveContainer->begin(gain);
       const_iterator itVec_e = caliWaveContainer->end(gain);
       
       for (; itVec != itVec_e; ++itVec) {
     
     for (const LArCaliWave& larCaliWave : *itVec) {  //Loop over all cells
       unsigned int DAC = larCaliWave.getDAC(); 
       IdentifierHash chidwave_hash = m_onlineHelper->channel_Hash(itVec.channelId());
  
       bool IsBad = false;
       for(int i=0;i<24*NSamplesKeep;i++){
         tempWave[i] = larCaliWave.getSample(i);
         if(tempWave[i]<-500) { // check that this wave is not corrupted
           IsBad = true; 
           break;
         }
       }
       
       if(IsBad) continue; // if corrupted wave, skip it;
       
       m_CaliWaves[gainref][chidwave_hash].push_back(tempWave);
       m_CaliDACs[gainref][chidwave_hash].push_back(DAC);
       
       // remember index of highest DAC value for this cell (i.e. non-saturating)
       if(DAC > m_CaliDACs[gainref][chidwave_hash][m_IndexHighestDAC[gainref][chidwave_hash]]) m_IndexHighestDAC[gainref][chidwave_hash]=m_CaliDACs[gainref][chidwave_hash].size()-1;
       
       // remember which index corresponds to DAC0
       if(m_dac0sub && DAC == m_DAC0) {
         m_IndexDAC0[gainref][chidwave_hash] = m_CaliDACs[gainref][chidwave_hash].size()-1;
         ATH_MSG_DEBUG("Cell " << chidwave_hash << ": DAC0 is at index = " << m_IndexDAC0[gainref][chidwave_hash]);
       }
     } // loop over dac values
       } // loop over cells
     } // Loop over gains
  
     sc= detStore()->remove(caliWaveContainer);
     if (sc.isFailure()) {
       ATH_MSG_WARNING("Cannot remove LArCaliWaveContainer from StoreGate ! ");
       return StatusCode::FAILURE;
     }
     ATH_MSG_DEBUG("Successfully removed LArCaliWaveContainer from StoreGate ");
     
   } // m_ipassShape
   
  
  
   
   // now start to deal with digits   
   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;
     HWIdentifier  lastFailedFEB(0);
     
     if(larAccumulatedCalibDigitContainer->empty()) {
        ATH_MSG_DEBUG("LArAccumulatedCalibDigitContainer with key=" << *key_it << " is empty ");
     } else {
        ATH_MSG_DEBUG("LArAccumulatedCalibDigitContainer with key=" << *key_it << " has size " << larAccumulatedCalibDigitContainer->size());
     }
  
     for (const LArAccumulatedCalibDigit* digit : *larAccumulatedCalibDigitContainer) {  //Loop over all cells
     
       if (!(digit->isPulsed())){  //Check if cell is pulsed
     continue; //Cell not pulsed -> ignore
       }
  
       HWIdentifier chid=digit->hardwareID();
       HWIdentifier febid=m_onlineHelper->feb_Id(chid);
       if (febErrSum) {
     const uint16_t febErrs=febErrSum->feb_error(febid);
     if (febErrs & m_fatalFebErrorPattern) {
       if (febid!=lastFailedFEB) {
         lastFailedFEB=febid;
         ATH_MSG_ERROR( "Event " << m_event_counter << " Feb " <<  m_onlineHelper->channel_name(febid) 
                << " reports error(s):" << febErrSum->error_to_string(febErrs) << ". Data ignored.");
       }
       continue;
     }
       }
  
  
       if (m_delay==-1) { //First (pulsed) cell to be processed:
     m_delay=digit->delay();
       }
       else
     if (m_delay!=digit->delay()) {
       ATH_MSG_ERROR( "Delay does not match! Found " << digit->delay() << " expected: " << m_delay);
       continue; //Ignore this cell
     }
       
       CaloGain::CaloGain gain=digit->gain();
       if (gain<0 || gain>CaloGain::LARNGAIN)
     {ATH_MSG_ERROR( "Found not-matching gain number ("<< (int)gain <<")");
       return StatusCode::FAILURE;
     }
       
       // if using bias-corrected Parabola tool or OFC Tool, get the pedestal
       if ( (m_recoType == PARABOLA && m_correctBias )  || m_recoType == OF) {
  
     //GU, try to get only once the pedestal per channel...
         IdentifierHash chid_hash = m_onlineHelper->channel_Hash(chid);
         if (m_thePedestal[chid_hash] < 0) {
       
       //Pointer to conditions data objects 
       const ILArPedestal* larPedestal=nullptr;
       sc=detStore()->retrieve(larPedestal);
       if (sc.isFailure()) {
         ATH_MSG_FATAL( "No pedestals found in database. Aborting executiong." );
         return sc;
       }
       
       if (larPedestal) {
         float DBpedestal = larPedestal->pedestal(chid,gain);
         if (DBpedestal >= (1.0+LArElecCalib::ERRORCODE) ) {
           m_thePedestal[chid_hash]=DBpedestal;
         } else {
           ATH_MSG_WARNING("No pedestal value found for cell hash ID = " 
           << chid_hash << " " << m_onlineHelper->channel_name(chid) 
           << ".  Skipping channel." 
          );
           continue;
         }
       } else {
         ATH_MSG_WARNING("No pedestal value found for cell hash ID = " 
         << chid_hash << " " << m_onlineHelper->channel_name(chid) 
         << ".  Skipping channel." 
         );
         continue;
       }
  
       ATH_MSG_DEBUG(" channel,pedestal " <<  m_onlineHelper->channel_name(chid) << " " 
           << m_thePedestal[chid_hash]);
  
     } // m_ipassPedestal     
       }
       
       LArCalibTriggerAccumulator& accpoints=(m_ramps->get(chid,gain))[digit->DAC()];
       LArCalibTriggerAccumulator::ERRTYPE ec=accpoints.add(digit->sampleSum(),digit->sample2Sum(),digit->nTriggers());
       if (ec==LArCalibTriggerAccumulator::WrongNSamples) {
     ATH_MSG_ERROR( "Failed to accumulate sub-steps: Inconsistent number of ADC samples");
       }
       if (ec==LArCalibTriggerAccumulator::NumericOverflow) {
     ATH_MSG_ERROR( "Failed to accumulate sub-steps: Numeric Overflow");
       }
     }//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 LArRampBuilder::finalize ( )

inline

Definition at line 72 of file LArRampBuilder.h.

72 {return StatusCode::SUCCESS;}

◆ initialize()

StatusCode LArRampBuilder::initialize ( )

Definition at line 19 of file LArRampBuilder.cxx.

 {
   StatusCode sc;
   if ( m_isSC ) {
     ATH_MSG_DEBUG("==== LArRampBuilder - looking at SuperCells ====");
     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_onlineHelper = (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_onlineHelper = (const LArOnlineID_Base*)ll;
       ATH_MSG_DEBUG(" Found the LArOnlineID helper. ");
     }
     
   }
  
   ATH_CHECK( m_cablingKey.initialize() );
   ATH_CHECK( m_cablingKeySC.initialize(m_isSC) );
  
   ATH_CHECK(m_bcContKey.initialize(m_doBadChannelMask));
   if(m_isSC) m_bcMask.setSC();
   ATH_CHECK(m_bcMask.buildBitMask(m_problemsToMask,msg()));
  
   //Intermediate ramp object (DAC/ADC pairs)
   m_ramps=std::make_unique<LArConditionsContainer<ACCRAMP> >();
   ATH_CHECK(m_ramps->setGroupingType(m_groupingType,msg())); 
   ATH_CHECK(m_ramps->initialize()); 
   
   chooseRecoMode() ;
   m_event_counter=0;
   
   unsigned int online_id_max = m_onlineHelper->channelHashMax() ; 
   m_thePedestal.resize(online_id_max,-1); 
   
   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.

◆ rampfit()

StatusCode LArRampBuilder::rampfit	(	unsigned	deg,
		const std::vector< LArRawRamp::RAMPPOINT_t > &	data,
		std::vector< float > &	rampCoeffs,
		std::vector< int > &	vSat,
		const HWIdentifier	chid,
		const LArOnOffIdMapping *	cabling,
		const LArBadChannelCont *	bcCont
	)

private

Definition at line 755 of file LArRampBuilder.cxx.

                                                                     {
   unsigned linRange=data.size();
   if (linRange<2) {
     bool isgood=true;
     if(m_doBadChannelMask && m_bcMask.cellShouldBeMasked(bcCont,chid)) isgood=false; 
     if (cabling->isOnlineConnected(chid) && isgood ) {
       ATH_MSG_ERROR( "Not enough datapoints (" << linRange << ") to fit a polynom!" );
       return StatusCode::FAILURE;
     }
     else {
       ATH_MSG_DEBUG("Not enough datapoints (" << linRange << ") to fit a polynom for a disconnected or known bad channel!" );
       return StatusCode::FAILURE;
     }
   }
   int satpoint = -1;
   if (m_satSlope) {
   
     float thisslope = 0., meanslope = 0.;
     std::vector<float> accslope;
     accslope.push_back(0);
     for (unsigned int DACIndex=1;DACIndex<linRange;DACIndex++){
       thisslope = (data[DACIndex].ADC - data[DACIndex-1].ADC)/(data[DACIndex].DAC - data[DACIndex-1].DAC);
  
       float scut;
       if(m_onlineHelper->isHECchannel(chid) && DACIndex < 5) {
          scut = meanslope/4.;
       } else { scut = meanslope/10.;}
       if ( (satpoint == -1) && ((meanslope-thisslope) > scut) ) { 
          satpoint = DACIndex; 
          if (satpoint <= 4) {
             ATH_MSG_DEBUG("Only "<<satpoint<<" points to fit, chid: "<<std::hex<<chid.get_identifier32().get_compact()<<std::dec);
             ATH_MSG_DEBUG(meanslope<<" "<<thisslope<<" | "<<data[DACIndex-1].ADC<<" "<<data[DACIndex].ADC);
          }
       } // saturation was reached
  
       meanslope = ( thisslope + (DACIndex-1)*(accslope[DACIndex-1]) )/DACIndex;
       accslope.push_back(meanslope);
  
     }
   
     if (satpoint != -1) { linRange = satpoint; } // if a saturation was found, linRange becomes the saturation index
   
   }
   vSat.push_back(satpoint);
   
   if (!m_withIntercept) {
     deg--;
   }
   bool isgood=true;
   if(m_doBadChannelMask && m_bcMask.cellShouldBeMasked(bcCont,chid)) isgood=false;
   if (deg>linRange) {
     if (cabling->isOnlineConnected(chid) && isgood ) 
       ATH_MSG_ERROR( "Not enough datapoints before saturation (" << linRange << ") to fit a polynom of degree " << deg << "chid: "<<std::hex<<chid.get_identifier32().get_compact()<<std::dec);
     else
       ATH_MSG_DEBUG("Not enough datapoints before saturation (" << linRange << ") to fit a polynom of degree " << deg << "chid: "<<std::hex<<chid.get_identifier32().get_compact()<<std::dec
             << " (channel disconnected or known to be bad)");
     
     return StatusCode::FAILURE;
   }
   
   if (data[linRange-1].DAC>0 && data[linRange-1].ADC<m_deadChannelCut && data[linRange-1].ADC!=-999.) {
     ATH_MSG_ERROR( "DAC= " << data[linRange-1].DAC << " yields ADC= " << data[linRange-1].ADC 
        << ". Dead channel?" );
     return StatusCode::FAILURE;
   }
  
   int begin = 0;
   if(data[0].DAC == m_DAC0) begin = 1; // starts at 1 to skip DAC=0
  
   Eigen::MatrixXd alpha(deg,deg);
   Eigen::VectorXd beta(deg);
   float sigma2 = 1.;
   for (unsigned k=0;k<deg;k++)
     for (unsigned j=0;j<=k;j++)
       {
     alpha(k,j)=0;
     for (unsigned i=begin;i<linRange;i++) 
       {
         // we are not storing any error on the reconstructed
         // peaks, but we can simply use the error on the sample
         // means (RMS/sqrt(NTriggers)) to account for any
         // potential variation on the number of accumulated
         // triggers. BTW, this would be proportional to the ADC
         // uncertainly but used as *DAC* uncertainty: in the limit
         // in which the ramp is linear this is still correct, and
         // anyway better than nothing. -- M.D. 13/7/2009        
         sigma2 = 1.;
         if ( data[i].NTriggers ) {
           //float sigma2 = (data[i].RMS[0]*data[i].RMS[0])/data[i].NTriggers;
           sigma2 = 100./data[i].NTriggers;
         }
           // just use trigger number, assume RMS is constant for
           // all DAC points (same noise). The 100. scale factor is
           // there to guarantee the same results with respect to
           // previous fits withour errors (having usually 100
           // triggers), because of potential numerical
           // differences when inverting the fit matrix even if
           // errors are all the same.
         if (m_withIntercept) {    
           alpha(k,j)+=(std::pow(data[i].ADC,(int)k)*std::pow(data[i].ADC,(int)j))/sigma2;
         } else {
           alpha(k,j)+=(std::pow(data[i].ADC,(int)k+1)*std::pow(data[i].ADC,(int)j+1))/sigma2;
         }
         alpha(j,k)=alpha(k,j); //Use symmetry
       }
       }
   
   for (unsigned k=0;k<deg;k++)
     {
       beta[k]=0;
       for (unsigned i=begin;i<linRange;i++) {
     sigma2 = 1.;
     if ( data[i].NTriggers ) {
       sigma2 = 100./data[i].NTriggers;
     }
     if (m_withIntercept) {
       beta[k]+=(data[i].DAC*pow(data[i].ADC,(int)k))/sigma2; 
     } else {
       beta[k]+=(data[i].DAC*pow(data[i].ADC,(int)k+1))/sigma2;
     }
       }
     }
   
   //HepVector comp=solve(alpha,beta);
   const Eigen::VectorXd comp=alpha.colPivHouseholderQr().solve(beta);
  
   //Fill RampDB object
   if (!m_withIntercept)
     rampCoeffs.push_back(0);
     
   for (int l=0;l<comp.size() ;l++)
     rampCoeffs.push_back(comp[l]);
   
 #ifdef LARRAMPBUILDER_DEBUGOUTPUT
   // ****************************************
   // Output for Dugging:
   for (unsigned i=1;i<data.size();i++)
     std::cout << data[i].DAC << " " << data[i].ADC << " " << std::endl;
   std::cout << "LinRange= " << linRange << " satpoint= " << satpoint<<std::endl;
   for (unsigned k=0;k<deg;k++) {
      std::cout<<"Beta "<<k<<" "<<beta[k]<<std::endl;
      for (unsigned j=0;j<=k;j++) {
             std::cout<<"Alpha "<<j<<" "<<alpha(k,j)<<std::endl;
      }
   }
   
   //Calculate error:
   double sigma=0;
   for (unsigned k=0;k<linRange;k++) //Run over all data points
     {double DACcalc=comp[0];
       for (int i=1;i<comp.size();i++) //Apply polynom
     DACcalc+=comp[i]*pow(data[k].ADC,i);
       sigma+=(DACcalc-data[k].DAC)*(DACcalc-data[k].DAC);
     }
   sigma=sqrt(sigma);
   if (linRange>1)
     sigma=sigma/(linRange-1);
   
   std::cout << "Components: ";
   for (int i=0;i<comp.size();i++)
     std::cout << comp[i] << " ";
   std::cout << "sigma=" << sigma << std::endl;
 #undef LARRAMPBUILDER_DEBUGOUTPUT
 #endif 
   
   return StatusCode::SUCCESS;
 }

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

virtual

Definition at line 383 of file LArRampBuilder.cxx.

 { 
   ATH_MSG_INFO( "in stop."); 
  
   //retrieve BadChannel info:
   const LArBadChannelCont* bcCont=nullptr;
   if (m_doBadChannelMask) {
     SG::ReadCondHandle<LArBadChannelCont> bcContHdl{m_bcContKey};
     bcCont=(*bcContHdl);
   }
  
   StatusCode sc;
   //Create transient ramp object (to be filled later) (one object for all gains)
   std::unique_ptr<LArRampComplete> larRampComplete;
   if (m_saveRecRamp){
     larRampComplete=std::make_unique<LArRampComplete>();
     ATH_CHECK(larRampComplete->setGroupingType(m_groupingType,msg()));
     ATH_CHECK(larRampComplete->initialize());
   }
   
   const LArOnOffIdMapping* cabling(nullptr);
   if( m_isSC ){
     ATH_MSG_INFO("setting up SC cabling");
     SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKeySC};
     cabling = {*cablingHdl};
     if(!cabling) {
       ATH_MSG_ERROR("Do not have mapping object " << m_cablingKeySC.key());
       return StatusCode::FAILURE;
     }    
   }else{
     ATH_MSG_INFO("setting up calo cabling");
     SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKey};
     cabling = {*cablingHdl};
     if(!cabling) {
       ATH_MSG_ERROR("Do not have mapping object " << m_cablingKey.key());
       return StatusCode::FAILURE;
     }   
   }
  
   
   const ILArRinj* rinj=nullptr;
   if(m_ishec) {
     ATH_CHECK(detStore()->retrieve(rinj,m_hec_key));
   }
  
   int containerCounter=0;
  
   int NRamp=0;
  
   for (unsigned k=0;k<(int)CaloGain::LARNGAIN;k++) {
     CaloGain::CaloGain gain=(CaloGain::CaloGain)k;
     LArConditionsContainer<ACCRAMP>::ConditionsMapIterator cell_it=m_ramps->begin(gain);
     LArConditionsContainer<ACCRAMP>::ConditionsMapIterator cell_it_e=m_ramps->end(gain);
     if (cell_it==cell_it_e) {
       ATH_MSG_INFO( "No ramp points found for gain " << gain);
       continue; //No data for this gain
     }
     //Create transient object for raw ramp (one container per gain)
     std::unique_ptr<LArRawRampContainer> larRawRampContainer;
     if (m_saveRawRamp) {
       larRawRampContainer=std::make_unique<LArRawRampContainer>();
     }
     
     //Inner loop goes over the cells.
     for (;cell_it!=cell_it_e;cell_it++){
       
       const HWIdentifier chid = cell_it.channelId();
  
       ACCRAMP::const_iterator dac_it=cell_it->begin();
       ACCRAMP::const_iterator dac_it_e=cell_it->end();
       auto rawramp=std::make_unique<LArRawRamp>(chid,gain);
       
       std::vector<float> peak;
       float adcpeak, timepeak;
       std::vector<float> adc0v;
       bool isADCsat = false;
  
  
  
  
       for (;dac_it!=dac_it_e;++dac_it) {
  
         LArRawRamp::RAMPPOINT_t ramppoint;
  
     adcpeak  = -999.;
     timepeak = -999.;
     // prepare samples
     float MaxADC = 0;
     int iMaxADC = 0;
     // if DAC0, fill adc0v vector
     if(m_dac0sub && dac_it->first== m_DAC0){
       // check that DAC0 is the first DAC of list
           
       if(dac_it!=cell_it->begin()) 
         ATH_MSG_ERROR( "DAC0 is not the first DAC ? This might be a problem... " );
       adc0v = dac_it->second.mean();
       ramppoint.Samples   = adc0v;
       ramppoint.RMS       = dac_it->second.RMS();
       ramppoint.NTriggers = dac_it->second.nTriggers();
     }else{// if not DAC0, substract DAC0 to current DAC
       const size_t nS=dac_it->second.nsamples();
       adc0v.resize(nS,0.0);
       ramppoint.Samples.resize(nS);
       ramppoint.RMS.resize(nS);
       ramppoint.NTriggers = dac_it->second.nTriggers();
       for(size_t k=0;k<nS;++k){
         ramppoint.Samples[k]=dac_it->second.mean(k) - adc0v[k];
         ramppoint.RMS[k]=dac_it->second.RMS(k);
         // find sample max and its index
         if(ramppoint.Samples[k]>MaxADC){
           MaxADC = ramppoint.Samples[k];
           iMaxADC = k;
         }
       }
     }
       
     // reconstruct
     if ( m_recoType == OF) {
           if (!m_dac0sub) {
             IdentifierHash chid_hash = m_onlineHelper->channel_Hash(chid);
             for (size_t k=0;k<ramppoint.Samples.size();++k) {
               ramppoint.Samples[k] = ramppoint.Samples[k] - m_thePedestal[chid_hash];
             }
           }
  
       //The following lines have been moved here from LArOFPeakReco tool:
       float delay=m_delay;
       unsigned kMax = max_element(ramppoint.Samples.begin(),ramppoint.Samples.end()) - ramppoint.Samples.begin() ;
           unsigned kLow, kUp;
           //unsigned nIter=0;
           if(!m_iterate) { // No iteration, original code
        if ( kMax < 2 || kMax+2 >= ramppoint.Samples.size() ) {
         // probably wrong max for small signal = noise artifact 
         kMax=2;
             bool isgood=true;
             if(m_doBadChannelMask && m_bcMask.cellShouldBeMasked(bcCont,chid)) isgood=false;
         if (cabling->isOnlineConnected(chid) && isgood) {
           ATH_MSG_WARNING( "Not enough samples around the maximum! Use kMax=2 ("
                 << m_onlineHelper->channel_name(chid) <<", DAC=" << dac_it->first 
                 << ", Amp[2]=" << ramppoint.Samples[2] <<   " )" );
           if (msgLvl(MSG::VERBOSE)) {
         msg(MSG::VERBOSE) <<  " Samples: ";
         for (unsigned k=0;k<ramppoint.Samples.size();k++) 
           msg() << ramppoint.Samples[k] << " "; 
         msg() << endmsg;
           }//end if verbose message
         }//end if bad or disconnected channel
        }//end if kmax out-of-range
       
        // convention delay=0 OFC use samp 0-1-2-3-4
        //            delay=24 OFC use samp 1-2-3-4-5
        // => if kmax=2 : choose OFC with delay + delayShift
        //    if kmax=3 : choose OFC with delay+ delayShift+24
        //    if kmax=4 : stick to kmax=3 
        //GU temporary hardcoded number. To move to jobOptions
  
        if (kMax==4) kMax=3;
        if (kMax==3) delay += (m_delayShift+24);
        if (kMax==2) delay += m_delayShift;
        ATH_MSG_VERBOSE("kMax " << kMax << " delay " << delay);
        delay=(delay-0.5)*(25./24.);
        //Call OF peak reco tool with no iteration and peak-sample forced to kMax
            kLow = kUp = kMax;
           } else { // code with iteration
            kLow = kMax - 2;
            kUp = kMax + 2;
            delay = 0.;
            //nIter = 10;
           }
       const LArOFPeakRecoTool::Result results=m_peakOFTool->peak(ramppoint.Samples,chid,gain,delay,0,kMax,kLow,kUp);
       if (results.getValid()) {
         adcpeak  = results.getAmplitude();
         timepeak = results.getTau();
       }
       else 
         ATH_MSG_ERROR( "LArOFPeak reco tool returns invalid result.");
  
  
     } else if ( m_recoType == SHAPE) {
       
       IdentifierHash chid_hash = m_onlineHelper->channel_Hash(chid);
       
       // reconstruct for non-DAC0 values and non-saturating waves
       if(dac_it->first!= m_DAC0 && dac_it->first <= m_CaliDACs[gain][chid_hash][m_IndexHighestDAC[gain][chid_hash]]){
         
         // find appropriate wave
         unsigned int GoodIndex = 9999;
         for(unsigned int i=0;i<m_CaliDACs[gain][chid_hash].size();i++){
           if(dac_it->first == m_CaliDACs[gain][chid_hash][i]) GoodIndex=i;
         }
         if(GoodIndex == 9999) {
           ATH_MSG_WARNING("No wave found for cell = " << chid_hash << ", DAC = " << dac_it->first);
           float min = 9999999;
           for(unsigned int i=0;i<m_CaliDACs[gain][chid_hash].size();i++){
                 int dacdiff = dac_it->first - m_CaliDACs[gain][chid_hash][i]; 
         if(abs(dacdiff)<min) 
           {
             min=abs(dacdiff);
             GoodIndex=i;
           }
           } 
           ATH_MSG_WARNING("Replace with DAC = " << m_CaliDACs[gain][chid_hash][GoodIndex]);
         }
         // substract DAC0 wave
         for(unsigned int k=0;k<m_CaliWaves[gain][chid_hash][GoodIndex].size();k++){
           m_CaliWaves[gain][chid_hash][GoodIndex][k] -= m_CaliWaves[gain][chid_hash][m_IndexDAC0[gain][chid_hash]][k];
         }
         
         // apply reconstruction 
         if(!m_CaliWaves[gain][chid_hash][GoodIndex].empty()){
           peak=m_peakShapeTool->peak(ramppoint.Samples,m_CaliWaves[gain][chid_hash][GoodIndex]);  
           ATH_MSG_DEBUG("cell chid=" << chid.get_compact() << ",peak= " << peak[0]);
         }else{
           ATH_MSG_ERROR( "No wave for this cell chid=" << chid.get_compact() << ",hash= " << chid_hash);
           peak.push_back(-999);
           peak.push_back(-999);
         }
         
         if(peak.size()>1){
           adcpeak = peak[0];
           timepeak = peak[1];
         }
       }
         } else if ( m_recoType == PARABOLA ) {
       
       if(m_correctBias){
         
         IdentifierHash chid_hash = m_onlineHelper->channel_Hash(chid);
         
         // get layer for correction
         Identifier id=cabling->cnvToIdentifier(chid);
         int layer=m_emId->sampling(id);
         peak=m_peakParabolaTool->peak(ramppoint.Samples,layer,m_thePedestal[chid_hash]);
         
       }else{
         // call peak reco without layer --> no bias correction 
         peak=m_peakParabolaTool->peak(ramppoint.Samples);
       }
       adcpeak = peak[0];
       timepeak = peak[1];
       
       
     } else {
       ATH_MSG_ERROR( "Both OF and Parabola reconstruction modes not available!" ) ;
       return StatusCode::FAILURE ;
     } 
     
     ramppoint.ADC        = adcpeak;
     ramppoint.DAC        = dac_it->first; 
  
         if(m_ishec && m_onlineHelper->isHECchannel(chid)) {
            if(rinj) {
               const float rinjval = rinj->Rinj(chid);
               if(rinjval < 4) ramppoint.DAC /= 2;
            }
         }
  
     ramppoint.iMaxSample = iMaxADC;
     ramppoint.TimeMax    = timepeak;
     
     
     // only add to rawramp non saturing points (using rawdata information)
     
     if( (dac_it->first>= m_minDAC) &&  ramppoint.ADC > -998 
         && ((m_maxADC <= 0) || (MaxADC < m_maxADC)) ) {
       rawramp->add(ramppoint);
     }
     else if ((m_maxADC > 0)&&(MaxADC >= m_maxADC)) { 
       isADCsat = true; // if ADC saturated at least once, it should be notified
           if(ramppoint.DAC < 200){
              ATH_MSG_DEBUG("Saturated low DAC: "<<m_onlineHelper->channel_name(chid)<<" at DAC "<<dac_it->first<<" ADC "<< MaxADC);
           } else {
              ATH_MSG_DEBUG("Saturated: "<<m_onlineHelper->channel_name(chid)<<" at DAC "<<dac_it->first<<" ADC "<< MaxADC);
           }
     }else{
       ATH_MSG_DEBUG("Fail ramp selection: "<<chid<<" "<<dac_it->first<<" "<<m_minDAC<<" "<<ramppoint.ADC<<" "<<MaxADC<<" "<<m_maxADC);
     } 
       }
       
       //Build ramp object..........
       if (larRampComplete) {
     std::vector<LArRawRamp::RAMPPOINT_t>& data=rawramp->theRamp();
     sort(data.begin(),data.end()); //Sort vector of raw data (necessary to cut off nonlinar high ADC-values)
     std::vector<float> rampCoeffs;
     std::vector<int> vSat;
     StatusCode sc=rampfit(m_degree+1,data,rampCoeffs,vSat,chid,cabling,bcCont);
     if (sc!=StatusCode::SUCCESS){
       if (!cabling->isOnlineConnected(chid))
           ATH_MSG_DEBUG("Failed to produce ramp for disconnected channel " << m_onlineHelper->channel_name(chid));
       else if (m_doBadChannelMask && m_bcMask.cellShouldBeMasked(bcCont,chid))
         ATH_MSG_INFO( "Failed to produce ramp for known bad channel " << m_onlineHelper->channel_name(chid));
       else
         ATH_MSG_ERROR( "Failed to produce ramp for channel " << m_onlineHelper->channel_name(chid));
     }
     else{
       if(rampCoeffs[1]<0) 
         ATH_MSG_ERROR(  "Negative 1rst order coef for ramp = " << rampCoeffs[1] << " for channel " 
                  << m_onlineHelper->channel_name(chid) );
  
       if (vSat[0] != -1) { rawramp->setsat(vSat[0]); }  // if a saturation point was found in rampfit, record it 
       else {
         if (isADCsat) { rawramp->setsat(data.size()-1); }   // if no saturation point was found, and ADC saturation happened, record the last ramp point    
         if (!isADCsat) { rawramp->setsat(data.size()); }    // if no saturation point was found, and ADC saturation did not happen, record the ramp size
       }
        
           //Produce transient object
           larRampComplete->set(chid,(int)gain,rampCoeffs);
           NRamp++;
     }// end else (rampfitting suceeded)
       }// end if (build ramp object)
       //Save raw ramp for this cell, if requested by jobOpts
       if (larRawRampContainer){
     larRawRampContainer->push_back(std::move(rawramp));
       }
     }//end loop cells
  
     if (larRawRampContainer) {
       std::string key;
       switch (gain) {
       case CaloGain::LARHIGHGAIN:
     key="HIGH";
     break;
       case  CaloGain::LARMEDIUMGAIN:
     key="MEDIUM";
     break;
       case  CaloGain::LARLOWGAIN:
     key="LOW";
     break;
       default:
     key="UNKNOWN";
     break;
       }
       key = m_keyoutput + key;
       ATH_MSG_INFO( "Recording LArRawRampContainer for gain " << (int)gain << " key=" << key);
       sc=detStore()->record(std::move(larRawRampContainer),key);
       if (sc.isFailure()) {
     ATH_MSG_ERROR( "Failed to record LArRawRamp object");
       }
     }// end if larRawRampContainer
     ++containerCounter;
   }//end loop over containers
  
   if (containerCounter==0) {
     ATH_MSG_WARNING("No Ramps have been produced. No data found.");
     return StatusCode::FAILURE;
   }
  
   if (larRampComplete){  //Save the transient  Ramp object. 
  
     ATH_MSG_INFO( " Summary : Number of cells with a ramp value computed : " << NRamp );
     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 ");
  
  
     sc=detStore()->record(std::move(larRampComplete),m_keyoutput);
     if (sc.isFailure()) {
       ATH_MSG_ERROR( "Failed to record LArRampComplete object");
     }
     sc=detStore()->symLink(ClassID_traits<LArRampComplete>::ID(),m_keyoutput,ClassID_traits<ILArRamp>::ID());
     if (sc.isFailure()) {
       ATH_MSG_ERROR( "Failed to symlink LArRawRamp object");
     }
   }
   m_ramps.reset();//Not needed any more. Free memory.
   ATH_MSG_INFO( "LArRampBuilder has finished.");
   return StatusCode::SUCCESS;
 }// end finalize-method.

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

SG::ReadCondHandleKey<LArBadChannelCont> LArRampBuilder::m_bcContKey {this, "BadChanKey", "LArBadChannel", "SG key for LArBadChan object"}

private

Definition at line 136 of file LArRampBuilder.h.

◆ m_bcMask

LArBadChannelMask LArRampBuilder::m_bcMask

private

Definition at line 135 of file LArRampBuilder.h.

◆ m_cablingKey

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

private

Definition at line 78 of file LArRampBuilder.h.

◆ m_cablingKeySC

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

private

Definition at line 79 of file LArRampBuilder.h.

◆ m_CaliDACs

std::vector< std::vector< std::vector< unsigned int > > > LArRampBuilder::m_CaliDACs

private

Definition at line 103 of file LArRampBuilder.h.

◆ m_CaliWaves

std::vector< std::vector< std::vector< std::vector<double> > > > LArRampBuilder::m_CaliWaves

private

Definition at line 101 of file LArRampBuilder.h.

◆ m_correctBias

BooleanProperty LArRampBuilder::m_correctBias {this,"correctBias",false,"For Parabola method: Correction yes/no"}

private

Definition at line 130 of file LArRampBuilder.h.

◆ m_DAC0

UnsignedIntegerProperty LArRampBuilder::m_DAC0 {this,"DAC0",0,"DAC value considered DAC0"}

private

Definition at line 123 of file LArRampBuilder.h.

◆ m_dac0sub

BooleanProperty LArRampBuilder::m_dac0sub {this,"SubtractDac0",true,"Take first DAC value as pedestal"}

private

Definition at line 122 of file LArRampBuilder.h.

◆ m_deadChannelCut

IntegerProperty LArRampBuilder::m_deadChannelCut {this,"DeadChannelCut",1300,"Complain about channels with max-ADC below this value"}

private

Definition at line 129 of file LArRampBuilder.h.

◆ m_degree

IntegerProperty LArRampBuilder::m_degree {this,"Polynom",1,"Degree of ramp-polynom"}

private

Definition at line 120 of file LArRampBuilder.h.

◆ m_delay

int LArRampBuilder::m_delay =-1

private

Definition at line 98 of file LArRampBuilder.h.

◆ m_delayShift

FloatProperty LArRampBuilder::m_delayShift {this,"DelayShift",23}

private

Definition at line 132 of file LArRampBuilder.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_doBadChannelMask

Gaudi::Property<bool> LArRampBuilder::m_doBadChannelMask {this,"IgnoreBadChannels",true,"Don't complain about known bad channels"}

private

Definition at line 134 of file LArRampBuilder.h.

◆ m_emId

const LArEM_Base_ID* LArRampBuilder::m_emId =nullptr

private

Definition at line 142 of file LArRampBuilder.h.

◆ m_event_counter

unsigned LArRampBuilder::m_event_counter =0

private

Definition at line 97 of file LArRampBuilder.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 LArRampBuilder::m_fatalFebErrorPattern =0xffff

private

Definition at line 148 of file LArRampBuilder.h.

◆ m_groupingType

Gaudi::Property<std::string> LArRampBuilder::m_groupingType {this,"GroupingType","ExtendedFeedThrough","Grouping of the output conditions-container"}

private

Definition at line 138 of file LArRampBuilder.h.

◆ m_hec_key

Gaudi::Property<std::string> LArRampBuilder::m_hec_key {this,"HECKey","","SG Key of injection-resistor obj used for HEC Ramps"}

private

Definition at line 139 of file LArRampBuilder.h.

◆ m_IndexDAC0

std::vector< std::vector< int> > LArRampBuilder::m_IndexDAC0

private

Definition at line 105 of file LArRampBuilder.h.

◆ m_IndexHighestDAC

std::vector< std::vector< int> > LArRampBuilder::m_IndexHighestDAC

private

Definition at line 106 of file LArRampBuilder.h.

◆ m_ipassShape

int LArRampBuilder::m_ipassShape =0

private

Definition at line 99 of file LArRampBuilder.h.

◆ m_ishec

Gaudi::Property<bool> LArRampBuilder::m_ishec {this,"isHEC",false,"Processing HEC data yes/no"}

private

Definition at line 145 of file LArRampBuilder.h.

◆ m_isSC

Gaudi::Property<bool> LArRampBuilder::m_isSC {this,"isSC",false,"Processing SC data yes/no"}

private

Definition at line 144 of file LArRampBuilder.h.

◆ m_iterate

Gaudi::Property<bool> LArRampBuilder::m_iterate {this,"Iterate",false,"Iterative OF peak reco"}

private

Definition at line 146 of file LArRampBuilder.h.

◆ m_keylist

Gaudi::Property<std::vector<std::string> > LArRampBuilder::m_keylist {this, "KeyList",{},"List if input SG keys"}

private

Definition at line 117 of file LArRampBuilder.h.

◆ m_keyoutput

Gaudi::Property<std::string> LArRampBuilder::m_keyoutput {this,"KeyOutput","LArRamp","SG Key of output object"}

private

Definition at line 118 of file LArRampBuilder.h.

◆ m_maxADC

IntegerProperty LArRampBuilder::m_maxADC {this,"RampRange",0,"Ignore ADC values higher than this (0: do nothing)"}

private

Definition at line 121 of file LArRampBuilder.h.

◆ m_minDAC

UnsignedIntegerProperty LArRampBuilder::m_minDAC {this,"minDAC",0,"Ignore DAC values smaller that this"}

private

Definition at line 127 of file LArRampBuilder.h.

◆ m_onlineHelper

const LArOnlineID_Base* LArRampBuilder::m_onlineHelper =nullptr

private

Definition at line 141 of file LArRampBuilder.h.

◆ m_peakOFTool

ToolHandle<LArOFPeakRecoTool> LArRampBuilder::m_peakOFTool {this,"PeakOFTool","LArOFPeakRecoTool"}

private

Definition at line 95 of file LArRampBuilder.h.

◆ m_peakParabolaTool

PublicToolHandle<LArParabolaPeakRecoTool> LArRampBuilder::m_peakParabolaTool {this,"LArParabolaPeakRecoTool","LArParabolaPeakRecoTool"}

private

Definition at line 93 of file LArRampBuilder.h.

◆ m_peakShapeTool

PublicToolHandle<LArShapePeakRecoTool> LArRampBuilder::m_peakShapeTool {this,"LArShapePeakRecoTool","LArShapePeakRecoTool"}

private

Definition at line 94 of file LArRampBuilder.h.

◆ m_problemsToMask

Gaudi::Property<std::vector<std::string> > LArRampBuilder::m_problemsToMask {this,"ProblemsToMask",{}, "Bad-Channel categories to mask"}

private

Definition at line 137 of file LArRampBuilder.h.

◆ m_ramps

std::unique_ptr<LArConditionsContainer<ACCRAMP> > LArRampBuilder::m_ramps

private

Definition at line 90 of file LArRampBuilder.h.

◆ m_recoType

recoType LArRampBuilder::m_recoType {OF}

private

Definition at line 113 of file LArRampBuilder.h.

◆ m_recoTypeProp

StringProperty LArRampBuilder::m_recoTypeProp {this,"RecoType","OF","One of 'Parabola', 'Shape' or 'OF'"}

private

Definition at line 128 of file LArRampBuilder.h.

◆ m_satSlope

BooleanProperty LArRampBuilder::m_satSlope {this,"doSatSlope",true,"Ignore points subject to saturation"}

private

Definition at line 126 of file LArRampBuilder.h.

◆ m_saveRawRamp

BooleanProperty LArRampBuilder::m_saveRawRamp {this,"StoreRawRamp",false,"Save raw ramp obj in SG"}

private

Definition at line 124 of file LArRampBuilder.h.

◆ m_saveRecRamp

BooleanProperty LArRampBuilder::m_saveRecRamp {this,"StoreRecRamp",true,"Save reconstructed ramp obj in SG"}

private

Definition at line 125 of file LArRampBuilder.h.

◆ m_thePedestal

std::vector<float> LArRampBuilder::m_thePedestal

private

Definition at line 108 of file LArRampBuilder.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_withIntercept

BooleanProperty LArRampBuilder::m_withIntercept {this,"WithIntercept",true,"False: Force fit to go through 0/0"}

private

Definition at line 131 of file LArRampBuilder.h.

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

Public Types

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ ACCRAMP

◆ StoreGateSvc_t

Member Enumeration Documentation

◆ recoType

Constructor & Destructor Documentation

◆ ~LArRampBuilder()

Member Function Documentation

◆ AthAlgorithm()

◆ chooseRecoMode()

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

◆ initialize()

◆ inputHandles()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ rampfit()

◆ renounce()

◆ renounceArray()

◆ stop()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_bcContKey

◆ m_bcMask

◆ m_cablingKey

◆ m_cablingKeySC

◆ m_CaliDACs

◆ m_CaliWaves

◆ m_correctBias

◆ m_DAC0

◆ m_dac0sub

◆ m_deadChannelCut

◆ m_degree

◆ m_delay

◆ m_delayShift

◆ m_detStore

◆ m_doBadChannelMask

◆ m_emId

◆ m_event_counter

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_fatalFebErrorPattern

◆ m_groupingType

◆ m_hec_key

◆ m_IndexDAC0

◆ m_IndexHighestDAC

◆ m_ipassShape

◆ m_ishec

◆ m_isSC

◆ m_iterate

◆ m_keylist

◆ m_keyoutput

◆ m_maxADC

◆ m_minDAC