LArOFPeakRecoTool Class Reference

#include <LArOFPeakRecoTool.h>

Inheritance diagram for LArOFPeakRecoTool:

Collaboration diagram for LArOFPeakRecoTool:

Public Types
enum	{ ERROR = -99999999 }
typedef LArOFIterResults	Result

Public Member Functions
	LArOFPeakRecoTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~LArOFPeakRecoTool ()
LArOFIterResults	peak (const std::vector< short > &samples, HWIdentifier chID, CaloGain::CaloGain gain, int delay) const
LArOFIterResults	peak (const std::vector< float > &samples, const HWIdentifier chID, const CaloGain::CaloGain gain, const float delayIn, const unsigned nIter=0, const unsigned npeak=2, unsigned peak_low=2, unsigned peak_high=2) const
virtual StatusCode	initialize ()
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
bool	m_iterate
SG::ReadCondHandleKey< ILArOFC >	m_keyOFC {this, "OFCKey", "LArOFC", "SG key for OFC object"}
SG::ReadCondHandleKey< ILArShape >	m_keyShape {this, "ShapeKey", "LArShape", "SG key for Shape object"}
bool	m_useShape
bool	m_useShapeDer
int	m_delayShift
float	m_samplingPeriod
bool	m_forceHighGain
bool	m_isSC
const LArOnlineID_Base *	m_lar_on_id = nullptr
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 29 of file LArOFPeakRecoTool.h.

Member Typedef Documentation

Result

typedef LArOFIterResults LArOFPeakRecoTool::Result

Definition at line 34 of file LArOFPeakRecoTool.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
ERROR

Definition at line 61 of file LArOFPeakRecoTool.h.

{ ERROR = -99999999 } ;

Constructor & Destructor Documentation

LArOFPeakRecoTool()

LArOFPeakRecoTool::LArOFPeakRecoTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 21 of file LArOFPeakRecoTool.cxx.

                                               : 
  AthAlgTool(type, name, parent)
  //m_nSamples(0xFFFFFFFF) //shall compare false to any possible number of samples
{
  declareProperty("Iterate",m_iterate=false) ;
  declareProperty("UseShape",m_useShape=false,"Use the LArShape to compute quality factor");
  declareProperty("UseShapeDer",m_useShapeDer=true,"Use the shape derivative in the quality factor computation");
  declareProperty("isSuperCell",m_isSC=false,"switch to use SuperCells");
// DelayShift = different with delay run in 25/24 ns units
//   23 is the ad-hoc value for run 5640-5641
  declareProperty("DelayShift",m_delayShift=23);
  declareProperty("SamplingPeriod",m_samplingPeriod=1./(40.08*Gaudi::Units::megahertz));
  declareProperty("forceHighGain",m_forceHighGain=false,"Force use of high gain for all shapes and OFC (default=false)");
  declareInterface<LArOFPeakRecoTool>(this);
}

~LArOFPeakRecoTool()

LArOFPeakRecoTool::~LArOFPeakRecoTool ( )

virtual

Definition at line 40 of file LArOFPeakRecoTool.cxx.

                                      {
}

Member Function Documentation

declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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

initialize()

StatusCode LArOFPeakRecoTool::initialize ( )

virtual

Definition at line 43 of file LArOFPeakRecoTool.cxx.

                                         {
  ATH_MSG_DEBUG("initializing LArOFPeakRecoTool...");
  
  ATH_CHECK(  m_keyOFC.initialize() );
 
  ATH_CHECK(  m_keyShape.initialize(m_useShape) );
  if (!m_useShape) {
    ATH_MSG_WARNING( "jobOption 'UseShape' set to false. Will work without shape"  );
  }
 
  if(!m_isSC) {
     const LArOnlineID* laron;
     StatusCode sc = detStore()->retrieve(laron,"LArOnlineID");
     if (sc.isFailure()) {
         ATH_MSG_ERROR("Unable to retrieve  LArOnlineID from DetectorStore");
         return StatusCode::FAILURE;
      } else m_lar_on_id = static_cast<const LArOnlineID_Base*> (laron);
  } else {
       const LArOnline_SuperCellID* laron;
       StatusCode sc = detStore()->retrieve(laron,"LArOnline_SuperCellID");
       if (sc.isFailure()) {
           ATH_MSG_ERROR("Unable to retrieve  LArOnlineID from DetectorStore");
           return StatusCode::FAILURE;
       } else m_lar_on_id =static_cast<const LArOnlineID_Base*> (laron);
  }
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

interfaceID()

const InterfaceID & LArOFPeakRecoTool::interfaceID ( )

inlinestatic

Definition at line 44 of file LArOFPeakRecoTool.h.

{ return IID_LArOFPeakRecoTool;}

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::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< AlgTool > >::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.

peak() [1/2]

LArOFIterResults LArOFPeakRecoTool::peak	(	const std::vector< float > &	samples,
		const HWIdentifier	chID,
		const CaloGain::CaloGain	gain,
		const float	delayIn,
		const unsigned	nIter = 0,
		const unsigned	npeak = 2,
		unsigned	peak_low = 2,
		unsigned	peak_high = 2 ) const

Definition at line 88 of file LArOFPeakRecoTool.cxx.

                            {
 
  const float epsilon=0.001;
  LArOFIterResults result;
 
  //Fill m_result with default/input values, 
  //calculation will be done with this object
  result.m_valid=false;
  result.m_converged=false;
  result.m_amplitude= 0;
  result.m_tau     =  0;
  result.m_quality =  0;
  result.m_delay_final      = delayIn;
  result.m_peakSample_init  =  npeak; 
  result.m_peakSample_final =  npeak; //Assumed index of highest sample (may change in the process)
  result.m_chid = chID;
  //Set some reference to improve readablity of the code:
  unsigned& kMax =  result.m_peakSample_final; //Make reference just to have code more readable 
  float& delay = result.m_delay_final;
  float& q=result.m_quality;
  unsigned& delayIdx=result.m_ofcIndex;
  //Quantities used during iteration
  unsigned kIter=0;
  //Computation is done as double
  double At=0;
  double A=0;
 
  //Tying to avoid doing all checks for every event/channel/iteation step by assuming that
  //the number of OFC samples is the same for all delays of a certain cell/gain. 
  //Code will segfault if not the case. 
 
  const unsigned nSamples=samples.size();
  //if (samples.size()<5){ 
  //  msg() << MSG::WARNING << "Not enough ADC samples (" << nSamples << ") found for channel 0x"  
 //      << std::hex << chID.get_compact() << std::dec << endmsg;
 //   return result;
 // }
 
  // force uses of high gain if required for OFC and shape
  CaloGain::CaloGain usedGain = gain;
  if (m_forceHighGain) {
      if (m_lar_on_id->isHECchannel(chID)) usedGain = CaloGain::LARMEDIUMGAIN;
      else                                 usedGain = CaloGain::LARHIGHGAIN;
  }
 
  const ILArOFC* dd_ofc=nullptr;
  StatusCode sc=detStore()->retrieve(dd_ofc);
  if (sc.isFailure()){
     ATH_MSG_ERROR("Failed to retrieve LArOFC object " );
     return result;
  }
 
  // Quantities depending on this cell
  const unsigned nOFCPhase=dd_ofc->nTimeBins(chID,usedGain);
  float timeOffset = dd_ofc->timeOffset(chID,usedGain);
 
  // convert delay to internal OFC delay (from 0 to Nphases*timeBinWidth)
  delay = delay-timeOffset;
 
  float timeBinWidth;
  float timeMax;
  if (nOFCPhase<2) { //Only one time bin
    delayIdx=0;
    timeBinWidth=25.; //ns
    timeMax=(nOFCPhase-1)*timeBinWidth;
  } else { //Have more than one OFC bin
    timeBinWidth=dd_ofc->timeBinWidth(chID,usedGain);
    timeMax =  (nOFCPhase-1)*timeBinWidth;
    if (timeBinWidth==0.) {
      ATH_MSG_ERROR( "timeBinWidth is zero for channel " << m_lar_on_id->channel_name(chID)  );
      return result;
    }
    //Check if initial delay isn't too big
    if (delay>timeMax) delay=timeMax-epsilon;
    if (delay<0.) delay=0.;
    //Index of the in in the vector according to the delay
    delayIdx=(unsigned)std::floor(0.5+delay/timeBinWidth);
  }
 
  //Get first set of OFC's
  ILArOFC::OFCRef_t this_OFC_a = dd_ofc->OFC_a(chID,(int)usedGain,delayIdx);
  ILArOFC::OFCRef_t this_OFC_b = dd_ofc->OFC_b(chID,(int)usedGain,delayIdx);
  const unsigned ofcSize=this_OFC_a.size(); //Assumed to be the same of all delay-indices
 
  //some sanity check on the OFCs
  if ( ofcSize == 0 || this_OFC_b.size() == 0 ) {
    ATH_MSG_DEBUG("OFC not found for channel " << m_lar_on_id->channel_name(chID) << ", gain=" << usedGain << ", delayIdx=" << delayIdx);
    return result;
  }
 
  if ( this_OFC_a.size() != this_OFC_b.size() ) {
    ATH_MSG_ERROR( "OFC a (" << this_OFC_a.size() << 
                   ")and b (" << this_OFC_b.size() << ") are not the same size for channel 0x" 
                   << std::hex << chID.get_compact() << std::dec  );
    return result;
  }
 
  //Coerce kmax, peak_high and peak_low to someting that can work
  if (peak_low<2) peak_low=2; //By convention we expect at least 2 samples before the peak
  if (peak_high>(nSamples+2-ofcSize)) peak_high=(nSamples+2-ofcSize);
  if (peak_high<peak_low) {
    ATH_MSG_WARNING( "Channel 0x"  << std::hex << chID.get_compact() << std::dec 
                     << "Not enough ADC samples (" << nSamples << ") to apply " << ofcSize << " OFCs."  );
    return result;
  }
  if(kMax<peak_low)  kMax=peak_low; 
  if(kMax>peak_high) kMax=peak_high; 
 
  float amplitude_save=0.;
  float tau_save= 99999.;
  unsigned int kMax_save=0;
  float delay_save=0.;
  unsigned int delayIdx_save=0;
 
  unsigned int mynIter = nIter;
 
  do {
    
    // Uncomment the following if you suspect that the ofc are corrupt for some phases:
    /*  
    if ( this_OFC_a.size() == 0 || this_OFC_b.size() == 0 ) {
      ATH_MSG_DEBUG( "OFC not found for channel 0x"  << std::hex << chID.get_compact() << std::dec  );
      std::cout << "OFC not found for channel 0x"  << std::hex << chID.get_compact() << std::dec << std::endl;
      return result;
    }
 
    if ( this_OFC_a.size() != this_OFC_b.size() ) {
      ATH_MSG_ERROR( "OFC a (" << this_OFC_a.size() << 
    ")and b (" << this_OFC_b.size() << ") are not the same size for channel 0x" 
      << std::hex << chID.get_compact() << std::dec  );
      return result;
    }
    */
    
        
    //Apply Optimal Filtering coefficients
    A = At = 0 ;
    for ( unsigned k=0 ; (k<ofcSize); k++ ) {
      //for ( unsigned k=0 ; (k<ofcSize) && (kMax-2+k<nSamples); k++ ) {
      const float& this_sample = samples[kMax-2+k];
      A  += this_OFC_a.at(k) * this_sample ;
      At += this_OFC_b.at(k) * this_sample ;
    }
    //Validate the result
    result.m_valid = true; //Doesn't mean that the result is really good, but we have something
    if ( A == 0 ) {
      ATH_MSG_DEBUG("Null amplitude: " << A << "  for channel" << m_lar_on_id->channel_name(chID));
      result.m_amplitude=0;
      result.m_tau=0;
      return result;
    }
    result.m_amplitude=A; 
    result.m_tau = At / A ;
 
    //First iteration done, break loop if possible.... 
    if (mynIter<=1) {
        delay = delayIdx*timeBinWidth;
        break; //No iteration requested
    }
 
    // Nsamples=OFCsize and only one phase available, no point to iterate
    if (samples.size() == ofcSize && nOFCPhase<2) {
        delay = delayIdx*timeBinWidth;
        break;
    }
 
    // if we are within +-0.5*Dt of time bin, we have converged for sure
    if (std::abs(result.m_tau) <= (0.5*timeBinWidth)) { 
      result.m_converged=true;
      delay = delayIdx*timeBinWidth;
      break;
    }
 
    if (kIter>=mynIter) { //Max. number of iterations reached
      delay = delayIdx*timeBinWidth;
      if (result.m_converged) {
        if (std::abs(tau_save) < std::abs(result.m_tau)) {
            result.m_amplitude = amplitude_save;
            result.m_tau       = tau_save;
            kMax                 = kMax_save;
            delay                = delay_save;
            delayIdx             = delayIdx_save;
        }
      }
      if (std::abs(result.m_tau) <= timeBinWidth) result.m_converged=true;
      break;
    }
 
    // if we are within +-Dt of time bin, we consider that we have converged but we allow for one more
    // iteration to see if we can find a smaller tau, if not we keep the previous one
    if (std::abs(result.m_tau) <= timeBinWidth) {
       result.m_converged = true;
       mynIter = kIter+1;    // allow only for more iteration
       amplitude_save = result.m_amplitude;
       tau_save       = result.m_tau;
       kMax_save      = kMax;
       delay_save     =  delayIdx*timeBinWidth;
       delayIdx_save  = delayIdx;
    }
 
    delay = delay - result.m_tau;  // moved this line up so first iteration delay results treated like subsequent
 
    if(delay<(-0.5*timeBinWidth)) { 
      if(kMax<peak_high){ 
    kMax = kMax+1 ; 
    delay=delay+m_samplingPeriod;
    if( delay < 0 ) delay = 0;
        if (delay > timeMax ) delay = timeMax-epsilon;
      } else { // don't shift sample
    delay = 0 ; 
      } 
    }//else if delay<0
    else
      if( delay>(timeMax+0.5*timeBinWidth) ) {
    if(kMax>peak_low){
      kMax = kMax-1 ; 
      delay=delay-m_samplingPeriod;
          if (delay < 0 ) delay=0.;
      if( delay > timeMax ) delay = timeMax-epsilon;
    } else { 
      // don't shift sample
      delay = timeMax-epsilon;
    }   
      }//end if delay>nOFCPhase
    //Prepare next iteration step:
    kIter++;
    delayIdx=(unsigned)floor(0.5+delay/timeBinWidth);
    if (delayIdx>=nOFCPhase) delayIdx = nOFCPhase-1;
    //Get next set of OFC's
    this_OFC_a = dd_ofc->OFC_a(chID,(int)usedGain,delayIdx);
    this_OFC_b = dd_ofc->OFC_b(chID,(int)usedGain,delayIdx);
  }
  while(1);  // end for iteration loop 
 
  // go back to overal time
  delay = delay + timeOffset;  // sign to check
 
  // get shape
  if (m_useShape){
    const ILArShape* dd_shape=nullptr;
    StatusCode sc=detStore()->retrieve(dd_shape);
    if (sc.isFailure()){
       ATH_MSG_ERROR("Failed to retrieve LArShape object with " );
       return result;
    } 
    q = 0.; 
    ILArShape::ShapeRef_t thisShape    = dd_shape->Shape(chID,(int)usedGain,delayIdx) ;
    ILArShape::ShapeRef_t thisShapeDer;
    if (m_useShapeDer) thisShapeDer = dd_shape->ShapeDer(chID,(int)usedGain,delayIdx) ;
    if( thisShape.size() >= ofcSize ) {
      for ( unsigned k=0 ; k<ofcSize ; k++ ) {
    const float& this_sample = samples[kMax-2+k];
         if (m_useShapeDer && thisShapeDer.size() >= ofcSize) 
        q += std::pow((result.m_amplitude*(thisShape[k]-result.m_tau*thisShapeDer[k]) - this_sample),2); 
        else
            q += std::pow((result.m_amplitude*thisShape[k] - this_sample),2);
      }
    }
    else {
      ATH_MSG_DEBUG("No shape for this channel");
    } 
  }
 
  result.m_nIterPerf = kIter;
  result.m_valid    =    true;
  return result;
}

peak() [2/2]

LArOFIterResults LArOFPeakRecoTool::peak	(	const std::vector< short > &	samples,
		HWIdentifier	chID,
		CaloGain::CaloGain	gain,
		int	delay ) const

Definition at line 74 of file LArOFPeakRecoTool.cxx.

                                                             {
  
  std::vector<float> newsamples;
  for(unsigned int i=0;i<samples.size();i++)
    {
      newsamples.push_back((float)samples[i]);
    }
  return peak(newsamples,chID,gain,delay);
 
}

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< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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_delayShift

int LArOFPeakRecoTool::m_delayShift

private

Definition at line 69 of file LArOFPeakRecoTool.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_forceHighGain

bool LArOFPeakRecoTool::m_forceHighGain

private

Definition at line 71 of file LArOFPeakRecoTool.h.

m_isSC

bool LArOFPeakRecoTool::m_isSC

private

Definition at line 72 of file LArOFPeakRecoTool.h.

m_iterate

bool LArOFPeakRecoTool::m_iterate

private

Definition at line 64 of file LArOFPeakRecoTool.h.

m_keyOFC

SG::ReadCondHandleKey<ILArOFC> LArOFPeakRecoTool::m_keyOFC {this, "OFCKey", "LArOFC", "SG key for OFC object"}

private

Definition at line 65 of file LArOFPeakRecoTool.h.

{this, "OFCKey", "LArOFC", "SG key for OFC object"};

m_keyShape

SG::ReadCondHandleKey<ILArShape> LArOFPeakRecoTool::m_keyShape {this, "ShapeKey", "LArShape", "SG key for Shape object"}

private

Definition at line 66 of file LArOFPeakRecoTool.h.

{this, "ShapeKey", "LArShape", "SG key for Shape object"};

m_lar_on_id

const LArOnlineID_Base* LArOFPeakRecoTool::m_lar_on_id = nullptr

private

Definition at line 73 of file LArOFPeakRecoTool.h.

m_samplingPeriod

float LArOFPeakRecoTool::m_samplingPeriod

private

Definition at line 70 of file LArOFPeakRecoTool.h.

m_useShape

bool LArOFPeakRecoTool::m_useShape

private

Definition at line 67 of file LArOFPeakRecoTool.h.

m_useShapeDer

bool LArOFPeakRecoTool::m_useShapeDer

private

Definition at line 68 of file LArOFPeakRecoTool.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• LArOFPeakRecoTool.h
• LArOFPeakRecoTool.cxx