LArCaliWaveBuilderXtalk Class Reference

#include <LArCaliWaveBuilderXtalk.h>

Inheritance diagram for LArCaliWaveBuilderXtalk:

Collaboration diagram for LArCaliWaveBuilderXtalk:

Public Member Functions
	LArCaliWaveBuilderXtalk (const std::string &name, ISvcLocator *pSvcLocator)
	~LArCaliWaveBuilderXtalk ()
StatusCode	initialize ()
StatusCode	execute ()
StatusCode	stop ()
StatusCode	finalize ()
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

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

Private Types
typedef std::map< int, LArCaliWave >	WaveMap
typedef LArConditionsContainer< WaveMap >	WaveContainer
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	initializeCabling (const LArOnOffIdMapping *cabling, const LArCalibLineMapping *clCont)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::ReadCondHandleKey< LArOnOffIdMapping >	m_cablingKey {this, "OnOffMap", "LArOnOffIdMap", "SG key for mapping object"}
SG::ReadCondHandleKey< LArCalibLineMapping >	m_CLKey {this, "CalibLineKey", "LArCalibLineMap", "SG calib line key"}
std::vector< std::string >	m_keylist
std::vector< std::string >	m_keylistproperty
std::string	m_keyoutput
std::string	m_groupingType
WaveContainer	m_waves
const LArOnlineID *	m_onlineHelper
std::vector< HWIdentifier >	m_CalibLineHW
int	m_feedthroughNumber
int	m_posOrNeg
int	m_barrelEndcap
std::string	m_calibPattern
std::string	m_partition
bool	m_isSpecialCrate
std::string	m_emecSpecialRegion
bool	m_isInnerWheel
unsigned	m_event_counter
int	m_NStep
float	m_SamplingPeriod
float	m_dt
int	m_ADCsatur
int	m_cutOnSample
DataObjIDColl	m_extendedExtraObjects
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 68 of file LArCaliWaveBuilderXtalk.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

WaveContainer

typedef LArConditionsContainer<WaveMap> LArCaliWaveBuilderXtalk::WaveContainer

private

Definition at line 94 of file LArCaliWaveBuilderXtalk.h.

WaveMap

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

private

Definition at line 93 of file LArCaliWaveBuilderXtalk.h.

Constructor & Destructor Documentation

LArCaliWaveBuilderXtalk()

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

Definition at line 25 of file LArCaliWaveBuilderXtalk.cxx.

  : AthAlgorithm(name, pSvcLocator),
    m_groupingType("ExtendedFeedThrough"), // SubDetector, Single, FeedThrough
    m_onlineHelper(nullptr),
    m_posOrNeg(0),
    m_barrelEndcap(0),
    m_isInnerWheel(0),
    m_event_counter(0),
    m_dt(0)
//=========================================================================================================
{
  declareProperty("KeyList",     m_keylistproperty);
  declareProperty("KeyOutput",       m_keyoutput="LArCaliWave");
  declareProperty("SamplingPeriod",     m_SamplingPeriod=1./(40.08*megahertz));
  declareProperty("NSteps",      m_NStep=24);             //Number of DelaySteps. FIXME: Try to get this information for somewhere else  
  declareProperty("ADCsaturation",   m_ADCsatur=0); 
  declareProperty("GroupingType",       m_groupingType); 
 
  // Description of the required pulsed channel to have the caliwaves reconstructed
  // PartitionPulsed = "BarrelA", "EndcapA", "BarrelC", "EndcapC"
  declareProperty("PartitionPulsed", m_partition); 
 
  // For EMEC special crates
  declareProperty("SpecialCrate",    m_isSpecialCrate=false); 
  declareProperty("SpecialRegion",   m_emecSpecialRegion="OuterWheel");   // OuterWheel / InnerWheel
 
  // FeedthroughPul = [1-32] (Barrel) [1-24] (Endcap)
  // used to detect the right calibration pattern
  // please ensure that this FT has no bad channels / disconnected FEB
  declareProperty("FeedthroughPul",  m_feedthroughNumber=1);
 
  // CalibPattern = "StripSinglexx", "MiddleSinglexx", "BackSinglexx", 
  // EMB  : xx = [1-4] (Strip) xx = [1-8] (Middle) xx = [1-4] (Back) 
  // EMEC : xx = [1-4] (Strip) xx = [1-4] (Middle) xx = [1-4] (Back) 
  //                       and xx = [1-4] (Middle) xx = [1-4] (Back) for inner wheel
  declareProperty("CalibPattern",    m_calibPattern="StripSingle1");
  
  // Allow to cut waves
  // consider only the N=CutOnSample first samples to reduce needed memory (0 = no cut)
  declareProperty("CutOnSample", m_cutOnSample=0);
}

~LArCaliWaveBuilderXtalk()

LArCaliWaveBuilderXtalk::~LArCaliWaveBuilderXtalk ( )

default

Member Function Documentation

declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode LArCaliWaveBuilderXtalk::execute

(

)

Definition at line 357 of file LArCaliWaveBuilderXtalk.cxx.

{
  SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKey};
  const LArOnOffIdMapping* cabling{*cablingHdl};
  if(!cabling) {
     ATH_MSG_ERROR("Do not have mapping object " << m_cablingKey.key());
     return StatusCode::FAILURE;
  }
 
  SG::ReadCondHandle<LArCalibLineMapping> clHdl{m_CLKey};
  const LArCalibLineMapping *clCont {*clHdl};
  if(!clCont) {
     ATH_MSG_ERROR("Do not have calibration mapping object " << m_CLKey.key());
     return StatusCode::FAILURE;
  }
 
  if (m_event_counter==0) {
    ATH_CHECK ( initializeCabling(cabling, clCont) );
  }
 
  // Print progression
  if ( m_event_counter < 100 || ( m_event_counter < 1000 && m_event_counter%100==0 ) || m_event_counter%1000==0 ) 
    ATH_MSG_INFO ( "Processing event " << m_event_counter );
  m_event_counter++ ;
 
  if (m_keylist.empty()) {
    ATH_MSG_ERROR ( "Key list is empty! No containers to process!" );
    return StatusCode::FAILURE;
  } 
 
  const LArAccumulatedCalibDigitContainer* larAccumulatedCalibDigitContainer = nullptr;
 
  std::vector<std::string>::const_iterator key_it=m_keylist.begin();
  std::vector<std::string>::const_iterator key_it_e=m_keylist.end();
 
  for (;key_it!=key_it_e; ++key_it) { //Loop over all containers that are to be processed (e.g. different gains)
 
    StatusCode sc = evtStore()->retrieve(larAccumulatedCalibDigitContainer,*key_it);
    if (sc.isFailure()) {
      ATH_MSG_WARNING ( "Cannot read LArAccumulatedCalibDigitContainer from StoreGate! key=" << *key_it );
      continue; // Try next container
    }
 
    LArAccumulatedCalibDigitContainer::const_iterator it=larAccumulatedCalibDigitContainer->begin();
    LArAccumulatedCalibDigitContainer::const_iterator it_end=larAccumulatedCalibDigitContainer->end();
 
    if (it == it_end) {
      ATH_MSG_DEBUG ( "LArAccumulatedCalibDigitContainer with key=" << *key_it << " is empty " );
      continue; // at this event LArAccumulatedCalibDigitContainer is empty, do not even try to loop on it...
    }
   
    const float delayScale = larAccumulatedCalibDigitContainer->getDelayScale();
    const float deltaDelay = 25*ns/(delayScale*m_NStep);
 
    // Check whether this "event" (LArAccumulatedDigit) is relevant for our studies
    bool relevantForXtalk = false;
 
    // for print purpose
    std::vector<int> nbOfEventSlot;     // Number of 'events' per slot
    nbOfEventSlot.resize(15);
 
    std::vector<int> nbOfEventPart;     // Number of 'events' per Subdetector/layer
    nbOfEventPart.resize(8);
    int sideA=0;               // Number of 'events' in A side
    int sideC=0;               // Number of 'events' in C side
 
 
    // Loop over all cells as long as no interesting pulsed cell is found
    do{
 
      const std::vector<HWIdentifier>& calibLine = clCont->calibSlotLine((*it)->hardwareID());
      if (!calibLine.empty()) {
    std::vector<HWIdentifier>::iterator found=find(m_CalibLineHW.begin(),m_CalibLineHW.end(),calibLine[0]);
 
    if (((*it)->isPulsed()) && (found != m_CalibLineHW.end())) 
      relevantForXtalk = true;
 
//      if (m_onlineHelper->slot((*it)->hardwareID()) == 2 && m_onlineHelper->channel((*it)->hardwareID())<10)
//    log << MSG::DEBUG << "Relevant ? HW id ->" << m_onlineHelper->show_to_string((*it)->hardwareID()) << "Calib -> " << m_onlineHelper->show_to_string(calibLine[0]) << "Pulsed ?" << (*it)->isPulsed() << endmsg;
 
      } 
 
      if ((*it)->isPulsed()){
    int iSlot = m_onlineHelper->slot((*it)->hardwareID());
    int ibarrel_ec = m_onlineHelper->barrel_ec((*it)->hardwareID());
    int ipos_neg = m_onlineHelper->pos_neg((*it)->hardwareID());
 
    nbOfEventSlot[iSlot-1]++;
 
    if (ipos_neg==1) sideA++;
    else         sideC++;
 
    if (!m_onlineHelper->isEmEndcapSpecialOnline((*it)->hardwareID())){ // do not count EMEC Special entries
      if    (iSlot==1)          nbOfEventPart[4*ibarrel_ec]++;      // PS
      else if (iSlot <  9 - ibarrel_ec) nbOfEventPart[4*ibarrel_ec + 1]++;  // Front
      else if (iSlot > 10 - ibarrel_ec) nbOfEventPart[4*ibarrel_ec + 2]++;  // Middle
      else                  nbOfEventPart[4*ibarrel_ec + 3]++;  // Back
    }
      }
 
      ++it;
    }
    while ((!relevantForXtalk) && (it != it_end));// End of loop on cell to determine whether this event is relevant for xtalk study
 
    // Debug : print number of events per slot
    /*
      log << MSG::DEBUG << "[Slot-Nevents]: ";
      for (int jj=0; jj<15; jj++){
      log << MSG::DEBUG << "[" << jj << "-" << nbOfEventSlot[jj] << "] ";
      }
      log << MSG::DEBUG << " - Shall I keep this? " << relevantForXtalk << endmsg;
    */
 
    // Debug : print number of events per detector region
    msg() << MSG::DEBUG << "Event nb " << m_event_counter - 1<< " - " ;
    msg() << MSG::DEBUG << "Entries : EMB PS/F/M/B=" << nbOfEventPart[0] << "/" << nbOfEventPart[1] << "/" << nbOfEventPart[2] << "/" << nbOfEventPart[3];
    msg() << MSG::DEBUG << "  -  EMEC Std PS/F/M/B=" << nbOfEventPart[4] << "/" << nbOfEventPart[5] << "/" << nbOfEventPart[6] << "/" << nbOfEventPart[7];
    msg() << MSG::DEBUG << " - A/(A+C)=" << (sideA+sideC==0 ? -1 : float(sideA)/float(sideA+sideC));
    if (!relevantForXtalk) 
      msg() << MSG::DEBUG << " - don't keep (partition/pattern)" << endmsg;
    else 
      msg() << MSG::DEBUG << " - KEEP THIS EVENT" << endmsg;
 
 
    // Process relevant events
    if (relevantForXtalk){
      bool hasbeenprinted = false;
      for (it=larAccumulatedCalibDigitContainer->begin();it!=it_end; ++it) { // Loop over all cells
     
    HWIdentifier chid=(*it)->hardwareID(); 
 
    // FT selection for EMEC
        if (m_barrelEndcap==1) {
      int iFT = m_onlineHelper->feedthrough(chid);
      if (m_isSpecialCrate)
        if (m_isInnerWheel)   {if (iFT!=3 && iFT!=10 && iFT!=16 && iFT!=22) continue;}
        else        {if (iFT!=2 && iFT!=9  && iFT!=15 && iFT!=21) continue;}
      else if (iFT==2 || iFT==9 || iFT==15 || iFT==21 || iFT==3 || iFT==10 || iFT==16 || iFT==22 || iFT==6)
        continue;
    }
 
    // Process only channels that are in the studied partition
    if ( (m_barrelEndcap == m_onlineHelper->barrel_ec(chid)) && (m_posOrNeg == m_onlineHelper->pos_neg(chid)) ){ 
 
      if (!hasbeenprinted){
        ATH_MSG_DEBUG ( "This event is relevant for the studied partition" );
        hasbeenprinted = true;
      }
 
      CaloGain::CaloGain gain=(*it)->gain();
     
      if (gain<0 || gain>CaloGain::LARNGAIN) {
        ATH_MSG_ERROR ( "Found not-matching gain number ("<< (int)gain <<")" );
        return StatusCode::FAILURE;
      }
     
      // transform sampleSum vector from uint32_t to double
      // Allow to cut waves :  consider only first samples to reduce needed memory (0 = no cut)
      std::vector<double> samplesum;     
      std::vector < uint64_t >::const_iterator samplesum_it=(*it)->sampleSum().begin();
      std::vector < uint64_t >::const_iterator samplesum_it_e=(*it)->sampleSum().end();
      int nSample=m_cutOnSample;
      do {
        samplesum.push_back((double)(*samplesum_it));     
        ++samplesum_it;
        --nSample;
      }
      while ( (samplesum_it!=samplesum_it_e) && (nSample!=0) );
 
      // transform sample2Sum vector from uint32_t to double
      // Allow to cut waves :  consider only first samples to reduce needed memory (0 = no cut)
      std::vector<double> sample2sum;     
      std::vector < uint64_t >::const_iterator sample2sum_it=(*it)->sample2Sum().begin();
      std::vector < uint64_t >::const_iterator sample2sum_it_e=(*it)->sample2Sum().end();
      nSample=m_cutOnSample;
      do {
        sample2sum.push_back((double)(*sample2sum_it));     
        ++sample2sum_it;
        --nSample;
      }
      while ( (sample2sum_it!=sample2sum_it_e) && (nSample!=0) );
     
      WaveMap& waveMap = m_waves.get(chid,gain);
      WaveMap::iterator itm = waveMap.find((*it)->DAC());
 
      if ( itm == waveMap.end() ) { // A new LArCaliWave is booked
        LArCaliWave wave(samplesum.size()*m_NStep, m_dt, (*it)->DAC(), 0x1, LArWave::meas ) ;
 
        // Be careful! Don't call addAccumulatedEvent() twice!!!
        // cf. LArCaliwaveBuilder ref. 1.38
        //wave.addAccumulatedEvent((int)roundf((*it)->delay()/deltaDelay), m_NStep, 
        //               samplesum, sample2sum, (*it)->nTriggers());
 
        itm = (waveMap.insert(WaveMap::value_type((*it)->DAC(), wave))).first;
      }//else { // A LArCaliWave for this channel/DAC is already existing
 
      (*itm).second.addAccumulatedEvent((int)roundf((*it)->delay()/deltaDelay), m_NStep, 
                        samplesum, sample2sum, (*it)->nTriggers());
    } // End of test on studied partition
      } //End loop over all cells
    } // End of relevantForXtalk test
  } //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 LArCaliWaveBuilderXtalk::finalize ( )

inline

Definition at line 78 of file LArCaliWaveBuilderXtalk.h.

{ return StatusCode::SUCCESS;}

initialize()

StatusCode LArCaliWaveBuilderXtalk::initialize

(

)

Definition at line 73 of file LArCaliWaveBuilderXtalk.cxx.

{ 
 
  MsgStream log(msgSvc(), name());
  log << MSG::INFO << "Initialize LArCaliWaveBuilderXtalk" << endmsg;
 
  // Set barrel_ec and pos_neg from PartitionPulsed
  m_barrelEndcap = 0; m_posOrNeg = 0;
  if      (m_partition == "BarrelC") {m_barrelEndcap = 0; m_posOrNeg = 0;}
  else if (m_partition == "BarrelA") {m_barrelEndcap = 0; m_posOrNeg = 1;}
  else if (m_partition == "EndcapC") {m_barrelEndcap = 1; m_posOrNeg = 0;}
  else if (m_partition == "EndcapA") {m_barrelEndcap = 1; m_posOrNeg = 1;}
  else {
    ATH_MSG_ERROR ( "Can't find partition " << m_partition << " ! Use BarrelC instead." );
  }
  ATH_MSG_INFO ( "Partition : " << m_partition << " (barrel_ec=" << m_barrelEndcap << " ; pos_neg=" << m_posOrNeg << ")" );
    
  // Test m_isSpecialCrate, set m_isInnerWheel, and check FT number for EMEC
  if (m_barrelEndcap==1) {
 
    // EMEC special crates
    if (m_isSpecialCrate){
 
      TString emecSpecialRegion_test = TString(m_emecSpecialRegion.c_str());
      emecSpecialRegion_test.ToLower();
      if (emecSpecialRegion_test.Contains("inner"))
    m_isInnerWheel = true;
      else {
    m_isInnerWheel = false;
    if (! emecSpecialRegion_test.Contains("outer"))
      ATH_MSG_WARNING ( "Can't read EMEC special region (Inner/Outer Wheel) - set SpecialRegion to OuterWheel." );
      }
 
      if (!m_isInnerWheel){   // EMEC outer wheel special crates
    if ( m_feedthroughNumber!=2 && m_feedthroughNumber!=9 && m_feedthroughNumber!=15 && m_feedthroughNumber!=21 ){
      ATH_MSG_WARNING ( "FeedthroughPul=" << m_feedthroughNumber << ". For EMEC outer wheel special crates studies one should use FT = 2, 9, 15 or 21." );
      ATH_MSG_WARNING ( "Set FeedthroughPul to 2.");
      m_feedthroughNumber = 2;
    }
    ATH_MSG_INFO ( "Look at EM end-cap outer wheel special crates. Check calibration patterns with FT number " << m_feedthroughNumber );
      }
      else {                // EMEC inner wheel (special crates)
    if ( m_feedthroughNumber!=3 && m_feedthroughNumber!=10 && m_feedthroughNumber!=16 && m_feedthroughNumber!=22 ){
      ATH_MSG_WARNING ( "FeedthroughPul=" << m_feedthroughNumber << ". For EMEC inner wheel studies one should use FT = 3, 10, 16 or 22." );
      ATH_MSG_WARNING ( "Set FeedthroughPul to 3.");
      m_feedthroughNumber = 3;
    }
    ATH_MSG_INFO ( "Look at EM end-cap inner wheel (special crates). Check calibration patterns with FT number " << m_feedthroughNumber );
      }
 
    }
 
    // EMEC standard crates
    else {
      if (m_feedthroughNumber==6
      || m_feedthroughNumber==2 || m_feedthroughNumber==9  || m_feedthroughNumber==15 || m_feedthroughNumber==21
      || m_feedthroughNumber==3 || m_feedthroughNumber==10 || m_feedthroughNumber==16 || m_feedthroughNumber==22
      || m_feedthroughNumber>24) {
    ATH_MSG_WARNING ( "FeedthroughPul=" << m_feedthroughNumber << " : not in EMEC standard crates." );
    ATH_MSG_WARNING ( "Set FeedthroughPul to 1.");
    m_feedthroughNumber = 1;
      }
      ATH_MSG_INFO ( "Look at EM end-cap standard crates. Check calibration patterns with FT number " << m_feedthroughNumber );
    }
  } else {
    // EM Barrel
    ATH_MSG_INFO ( "Look at EM barrel. Check calibration patterns with FT number " << m_feedthroughNumber );
  }
  
 
  if (m_keylistproperty.empty()) // Not key list given
    {
      m_keylistproperty.emplace_back("HIGH");
      m_keylistproperty.emplace_back("MEDIUM");
      m_keylistproperty.emplace_back("LOW");
    }
  m_keylist= m_keylistproperty;
 
  //FIXME probably useless because m_wave isn't written anywhere
  ATH_CHECK( m_waves.setGroupingType(m_groupingType,msg()) );
  ATH_CHECK( m_waves.initialize() );
 
  m_event_counter=0; 
 
  //m_dt=25*ns/m_NStep;
  m_dt = m_SamplingPeriod/m_NStep;
 
  ATH_CHECK( detStore()->retrieve(m_onlineHelper, "LArOnlineID") );
  ATH_CHECK( m_cablingKey.initialize() );
  ATH_CHECK( m_CLKey.initialize() );
  
  return StatusCode::SUCCESS;
}

initializeCabling()

StatusCode LArCaliWaveBuilderXtalk::initializeCabling ( const LArOnOffIdMapping * cabling, const LArCalibLineMapping * clCont )

private

Definition at line 169 of file LArCaliWaveBuilderXtalk.cxx.

{ 
  // bug in LArTools, on-off map doesn't work at initialization stage
 
  ATH_MSG_INFO ( "Consider only partition " <<  m_partition );
 
  // Temporary solution to create onoff map as long as it is not done in calibSlotLine()
  // WAITING FOR A FIX in LArTools
  Identifier cellId = cabling->cnvToIdentifier(m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,1,4));
  ATH_MSG_INFO ( "Dummy ids - TEMPORARY " << m_onlineHelper->show_to_string(cellId) );
 
 
  // Fill the m_CalibLineHW vector,containing all the calib line HW id 
  // that are required to be pulsed
  // The m_calibPattern string is given in the job option  
 
 
  //--------------------------------------------------
  //    EM BARREL
  
  if (m_partition == "BarrelA"  || m_partition == "BarrelC") {  
 
    // StripSingle pattern  
    if( m_calibPattern.find("StripSingle",0) != std::string::npos ){
      HWIdentifier theConsidChannel;
      int pulsedSlot = 2;
      if (m_calibPattern.find('1',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,1);
      if (m_calibPattern.find('2',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,2);
      if (m_calibPattern.find('3',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,3);
      if (m_calibPattern.find('4',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,4);
      
      const std::vector<HWIdentifier>& calibLine = clCont->calibSlotLine(theConsidChannel);
      
      ATH_MSG_INFO ( "Considered Online Channel " << m_onlineHelper->show_to_string(theConsidChannel) );
      ATH_MSG_DEBUG ( "Number of associated calib line " << calibLine.size() );
      if (!calibLine.empty()) {
    m_CalibLineHW.push_back(calibLine[0]);
    ATH_MSG_INFO ( "Calib line" << m_onlineHelper->show_to_string(calibLine[0]) );
      }
    }
    
    // MiddleSingle pattern
    if( m_calibPattern.find("MiddleSingle",0) != std::string::npos ){
      HWIdentifier theConsidChannel;
      int pulsedSlot = 11;
      if (m_calibPattern.find('1',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,3);
      if (m_calibPattern.find('2',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,2);
      if (m_calibPattern.find('3',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,7);
      if (m_calibPattern.find('4',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,6);
      if (m_calibPattern.find('5',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,67);
      if (m_calibPattern.find('6',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,66);
      if (m_calibPattern.find('7',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,71);
      if (m_calibPattern.find('8',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,70);
      
      const std::vector<HWIdentifier>& calibLine = clCont->calibSlotLine(theConsidChannel);
      ATH_MSG_INFO ( "Considered Channel " << m_onlineHelper->show_to_string(theConsidChannel) );
      if (!calibLine.empty()) {
    m_CalibLineHW.push_back(calibLine[0]);
    ATH_MSG_INFO ( "Calib Line " << m_onlineHelper->show_to_string(calibLine[0]) );
      }
    }
    
    // BackSingle pattern
    if ( m_calibPattern.find("BackSingle",0) != std::string::npos){
      HWIdentifier theConsidChannel;
      int pulsedSlot = 9;
      if (m_calibPattern.find('1',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,3);
      if (m_calibPattern.find('2',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,2);
      if (m_calibPattern.find('3',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,7);
      if (m_calibPattern.find('4',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,6);
      
      const std::vector<HWIdentifier>& calibLine = clCont->calibSlotLine(theConsidChannel);
      ATH_MSG_INFO ( "Considered Channel " << m_onlineHelper->show_to_string(theConsidChannel) );
      if (!calibLine.empty()) {
    m_CalibLineHW.push_back(calibLine[0]);
    ATH_MSG_INFO ( "Calib Line " << m_onlineHelper->show_to_string(calibLine[0]) );
      }
    }
 
  }             // End of barrel treatment
 
 
  //--------------------------------------------------
  //    EM ENDCAP
 
 
  else{
 
    // StripSingle pattern  
    if (m_isInnerWheel && m_isSpecialCrate && m_calibPattern.find("StripSingle",0) != std::string::npos )
      ATH_MSG_WARNING ( "There is no StripSingle pattern for EMEC inner wheel. You should try another pattern (MiddleSingle[1-4] or BackSingle[1-4])." );
    else if( m_calibPattern.find("StripSingle",0) != std::string::npos ){
      HWIdentifier theConsidChannel;
 
      int pulsedSlot = 2;           // EMEC outer wheel standard crates
      if (m_isSpecialCrate) pulsedSlot = 5; // EMEC outer wheel special crates
      
      if (m_calibPattern.find('1',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,1);
      if (m_calibPattern.find('2',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,2);
      if (m_calibPattern.find('3',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,3);
      if (m_calibPattern.find('4',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,4);
 
      const std::vector<HWIdentifier>& calibLine = clCont->calibSlotLine(theConsidChannel);
      
      ATH_MSG_INFO ( "Considered Online Channel " << m_onlineHelper->show_to_string(theConsidChannel) );
      ATH_MSG_DEBUG ( "Number of associated calib line " << calibLine.size() );
      if (!calibLine.empty()) {
    m_CalibLineHW.push_back(calibLine[0]);
    ATH_MSG_INFO ( "Calib line" << m_onlineHelper->show_to_string(calibLine[0]) );
      }
    }
 
    // MiddleSingle pattern
    if( m_calibPattern.find("MiddleSingle",0) != std::string::npos ){
      HWIdentifier theConsidChannel;
 
      int pulsedSlot = 10;          // EMEC outer wheel (standard and special crates)
      int pulsedCell1 = 1;
      int pulsedCell2 = 2;
      int pulsedCell3 = 7;
      int pulsedCell4 = 6;
      if (m_isInnerWheel && m_isSpecialCrate){    // EMEC inner wheel
    pulsedSlot = 1;
    pulsedCell1 = 1;
    pulsedCell2 = 0;
    pulsedCell3 = 2;
    pulsedCell4 = 3;
      }
 
      if (m_calibPattern.find('1',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,pulsedCell1);
      if (m_calibPattern.find('2',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,pulsedCell2);
      if (m_calibPattern.find('3',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,pulsedCell3);
      if (m_calibPattern.find('4',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,pulsedCell4);
      
      const std::vector<HWIdentifier>& calibLine = clCont->calibSlotLine(theConsidChannel);
      
      ATH_MSG_INFO ( "Considered Channel " << m_onlineHelper->show_to_string(theConsidChannel) );
      ATH_MSG_DEBUG ( "Number of associated calib line " << calibLine.size() );
      if (!calibLine.empty()) {
    m_CalibLineHW.push_back(calibLine[0]);
    ATH_MSG_INFO ( "Calib Line " << m_onlineHelper->show_to_string(calibLine[0]) );
      }
    }// End of MiddleSingle pattern
 
    // BackSingle pattern
    if ( m_calibPattern.find("BackSingle",0) != std::string::npos){
      HWIdentifier theConsidChannel;
 
      int pulsedSlot = 8;           // EMEC standard crates
      int pulsedCell1 = 1;
      int pulsedCell2 = 2;
      int pulsedCell3 = 33;
      int pulsedCell4 = 34;
      if (m_isInnerWheel && m_isSpecialCrate){    // EMEC inner wheel
    pulsedSlot = 2;
    pulsedCell1 = 1;
    pulsedCell2 = 0;
    pulsedCell3 = 2;
    pulsedCell4 = 3;
      }
      else if (m_isSpecialCrate) {      // EMEC outer wheel special crates
        pulsedSlot = 9;
        pulsedCell1 = 2;
        pulsedCell2 = 1;
        pulsedCell3 = 17;
        pulsedCell4 = 18;
      }
 
      if (m_calibPattern.find('1',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,pulsedCell1);
      if (m_calibPattern.find('2',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,pulsedCell2);
      if (m_calibPattern.find('3',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,pulsedCell3);
      if (m_calibPattern.find('4',0) != std::string::npos )theConsidChannel = m_onlineHelper->channel_Id(m_barrelEndcap,m_posOrNeg,m_feedthroughNumber,pulsedSlot,pulsedCell4);
      
      const std::vector<HWIdentifier>& calibLine = clCont->calibSlotLine(theConsidChannel);
      ATH_MSG_INFO ( "Considered Channel " << m_onlineHelper->show_to_string(theConsidChannel) );
      if (!calibLine.empty()) {
    m_CalibLineHW.push_back(calibLine[0]);
    ATH_MSG_INFO ( "Calib Line " << m_onlineHelper->show_to_string(calibLine[0]) );
      }
    }// End of BackSingle pattern     
 
  };// End of endcap treatment
 
  return StatusCode::SUCCESS;
}

inputHandles()

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

overridevirtualinherited

Return this algorithm's input handles.

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

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

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

overridevirtualinherited

Return this algorithm's output handles.

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

renounce()

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

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

stop()

StatusCode LArCaliWaveBuilderXtalk::stop

(

)

get iterator for all channels for a gain

Definition at line 565 of file LArCaliWaveBuilderXtalk.cxx.

{
  // Create wave container using feedthru grouping and initialize
  auto caliWaveContainer = std::make_unique<LArCaliWaveContainer>();
  
  ATH_CHECK( caliWaveContainer->setGroupingType(m_groupingType,msg()) );
  ATH_MSG_DEBUG ( "Set groupingType for LArCaliWaveContainer object" );
 
  ATH_CHECK( caliWaveContainer->initialize() );
  ATH_MSG_DEBUG ( "Initialized LArCaliWaveContainer object" );
 
  // Note : sometimes a Segmentation fault happen at this stage
  // not yet solved
  // 
  // Extract of the thread :
  //  > Caught signal 11(Segmentation fault). Details: 
  //  >   errno = 0, code = 1 (address not mapped to object)
  //  > #10 <signal handler called>                                                                                                                                
  //  > #11 cpp_alloc (size=52, nothrow=false) at src/tcmalloc.cc:354                                                                                              
  //  > #12 0xf7fd7a69 in operator new (size=52) at src/tcmalloc.cc:3104                                                                                           
  //  > #13 0xf775a306 in std::vector<unsigned int, std::allocator<unsigned int> >::operator= ()                                                                   
  //  > #14 0xee8b63d7 in LArCondFEBIdChanMap::addFEBIdVector ()                                                                                                   
  //  > #15 0xee8b03c4 in LArConditionsContainerBase::initGrouping ()                                                                                              
  //  > #16 0xee8b2c82 in LArConditionsContainerBase::initializeBase ()                                                                                            
  //  > #17 0xeed5f872 in LArConditionsContainer<LArCaliWaveVec>::initialize ()                                                                                    
 
  SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKey};
  const LArOnOffIdMapping* cabling{*cablingHdl};
  if(!cabling) {
     ATH_MSG_ERROR("Do not have mapping object " << m_cablingKey.key());
     return StatusCode::FAILURE;
  }
 
 
  LArWaveHelper wHelper;
  int NCaliWave=0;
 
  // Loop over all gains
  for (unsigned k=0;k<(int)CaloGain::LARNGAIN;k++) {
   
    CaloGain::CaloGain gain=(CaloGain::CaloGain)k;

    WaveContainer::ConditionsMapIterator cell_it   = m_waves.begin(gain); 
    WaveContainer::ConditionsMapIterator cell_it_e = m_waves.end(gain);
 
    HWIdentifier lastId;
    
    for (; cell_it!=cell_it_e; ++cell_it) {
   
      // Get id of this cell - use id from first cell in map
      //
      //   Some accumulations may be empty and we must skip this
      //   cell. WaveContainer has all 128 channels for each FEB
      //   with at least ONE being read out.
      //
 
      const HWIdentifier hwId = cell_it.channelId();
      if (!cabling->isOnlineConnected(hwId)) continue; //Ignore disconnected channels
          
      const WaveMap& waveMap = (*cell_it);
      if (waveMap.empty()) {
    ATH_MSG_INFO ( "Empty accumulated wave. Last id: " << MSG::hex 
                       << lastId << MSG::dec );
    continue;
      }
 
      lastId = hwId; // save previous id for debug printout
 
      // FT selection for EMEC
      if (m_barrelEndcap==1) {
    int iFT = m_onlineHelper->feedthrough(hwId);
    if (m_isSpecialCrate)
      if (m_isInnerWheel) {if (iFT!=3 && iFT!=10 && iFT!=16 && iFT!=22) continue;}
      else          {if (iFT!=2 && iFT!=9  && iFT!=15 && iFT!=21) continue;}
    else if (iFT==2 || iFT==9 || iFT==15 || iFT==21 || iFT==3 || iFT==10 || iFT==16 || iFT==22 || iFT==6)
      continue;
      }
 
      // Get the vector of waves for this chid,gain
      LArCaliWaveContainer::LArCaliWaves& dacWaves = caliWaveContainer->get(hwId, gain);
 
      std::map<int, LArCaliWave>::const_iterator dac_it   = cell_it->begin();
      std::map<int, LArCaliWave>::const_iterator dac_it_e = cell_it->end();
     
      for (; dac_it != dac_it_e; ++dac_it) {
       
    const LArCaliWave& thisWave = dac_it->second ;
    float pedAve = 0.;
           
    double waveMax = thisWave.getSample( wHelper.getMax(thisWave) ) ;
    if ( m_ADCsatur>0 && waveMax>m_ADCsatur ) { 
      ATH_MSG_INFO ( "Absolute ADC saturation at DAC = " << thisWave.getDAC() << " ... skip!" );
      continue ;
    } else {
 
      LArCaliWave newWave( ((thisWave)+(-pedAve)).getWave() ,
                   thisWave.getErrors(),
                   thisWave.getTriggers(),
                   thisWave.getDt(), 
                   thisWave.getDAC(),
                   thisWave.getIsPulsedInt(), 
                   thisWave.getFlag() );
       
      dacWaves.push_back(newWave);
      NCaliWave++;
    }
      } // end of loop DACs     
 
      // intermediate map cleanup (save memory)
      cell_it->clear();
 
    } //end loop cells
 
  } //end loop over m_keyList
 
  ATH_MSG_INFO ( "Summary : Number of cells with a CaliWave  reconstructed : " << NCaliWave  );
  ATH_MSG_INFO ( "Size of LAr calibration waves container : " << caliWaveContainer->size()  );
 
  // Record in detector store with key (m_keyoutput)
  ATH_CHECK( detStore()->record(std::move(caliWaveContainer), m_keyoutput) );
 
  ATH_MSG_INFO ( "LArCaliWaveBuilderXtalk has finished." );
  return StatusCode::SUCCESS;
}

sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, and PyAthena::Alg.

Definition at line 66 of file AthAlgorithm.cxx.

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

sysStart()

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

overridevirtualinherited

Handle START transition.

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

updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

m_ADCsatur

int LArCaliWaveBuilderXtalk::m_ADCsatur

private

Definition at line 116 of file LArCaliWaveBuilderXtalk.h.

m_barrelEndcap

int LArCaliWaveBuilderXtalk::m_barrelEndcap

private

Definition at line 103 of file LArCaliWaveBuilderXtalk.h.

m_cablingKey

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

private

Definition at line 82 of file LArCaliWaveBuilderXtalk.h.

{this, "OnOffMap", "LArOnOffIdMap", "SG key for mapping object"};

m_CalibLineHW

std::vector<HWIdentifier> LArCaliWaveBuilderXtalk::m_CalibLineHW

private

Definition at line 99 of file LArCaliWaveBuilderXtalk.h.

m_calibPattern

std::string LArCaliWaveBuilderXtalk::m_calibPattern

private

Definition at line 105 of file LArCaliWaveBuilderXtalk.h.

m_CLKey

SG::ReadCondHandleKey<LArCalibLineMapping> LArCaliWaveBuilderXtalk::m_CLKey {this, "CalibLineKey", "LArCalibLineMap", "SG calib line key"}

private

Definition at line 83 of file LArCaliWaveBuilderXtalk.h.

{this, "CalibLineKey", "LArCalibLineMap", "SG calib line key"};

m_cutOnSample

int LArCaliWaveBuilderXtalk::m_cutOnSample

private

Definition at line 118 of file LArCaliWaveBuilderXtalk.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_dt

float LArCaliWaveBuilderXtalk::m_dt

private

Definition at line 115 of file LArCaliWaveBuilderXtalk.h.

m_emecSpecialRegion

std::string LArCaliWaveBuilderXtalk::m_emecSpecialRegion

private

Definition at line 109 of file LArCaliWaveBuilderXtalk.h.

m_event_counter

unsigned LArCaliWaveBuilderXtalk::m_event_counter

private

Definition at line 112 of file LArCaliWaveBuilderXtalk.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_feedthroughNumber

int LArCaliWaveBuilderXtalk::m_feedthroughNumber

private

Definition at line 101 of file LArCaliWaveBuilderXtalk.h.

m_groupingType

std::string LArCaliWaveBuilderXtalk::m_groupingType

private

Definition at line 90 of file LArCaliWaveBuilderXtalk.h.

m_isInnerWheel

bool LArCaliWaveBuilderXtalk::m_isInnerWheel

private

Definition at line 110 of file LArCaliWaveBuilderXtalk.h.

m_isSpecialCrate

bool LArCaliWaveBuilderXtalk::m_isSpecialCrate

private

Definition at line 108 of file LArCaliWaveBuilderXtalk.h.

m_keylist

std::vector<std::string> LArCaliWaveBuilderXtalk::m_keylist

private

Definition at line 87 of file LArCaliWaveBuilderXtalk.h.

m_keylistproperty

std::vector<std::string> LArCaliWaveBuilderXtalk::m_keylistproperty

private

Definition at line 88 of file LArCaliWaveBuilderXtalk.h.

m_keyoutput

std::string LArCaliWaveBuilderXtalk::m_keyoutput

private

Definition at line 89 of file LArCaliWaveBuilderXtalk.h.

m_NStep

int LArCaliWaveBuilderXtalk::m_NStep

private

Definition at line 113 of file LArCaliWaveBuilderXtalk.h.

m_onlineHelper

const LArOnlineID* LArCaliWaveBuilderXtalk::m_onlineHelper

private

Definition at line 97 of file LArCaliWaveBuilderXtalk.h.

m_partition

std::string LArCaliWaveBuilderXtalk::m_partition

private

Definition at line 106 of file LArCaliWaveBuilderXtalk.h.

m_posOrNeg

int LArCaliWaveBuilderXtalk::m_posOrNeg

private

Definition at line 102 of file LArCaliWaveBuilderXtalk.h.

m_SamplingPeriod

float LArCaliWaveBuilderXtalk::m_SamplingPeriod

private

Definition at line 114 of file LArCaliWaveBuilderXtalk.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_waves

WaveContainer LArCaliWaveBuilderXtalk::m_waves

private

Definition at line 95 of file LArCaliWaveBuilderXtalk.h.

---

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

• LArCaliWaveBuilderXtalk.h
• LArCaliWaveBuilderXtalk.cxx