LArRampBuilder Class Reference

#include <LArRampBuilder.h>

Inheritance 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:
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
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, 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< 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)
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 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.

{PARABOLA,SHAPE,OF};  

Constructor & Destructor Documentation

~LArRampBuilder()

LArRampBuilder::~LArRampBuilder ( )

inline

Definition at line 66 of file LArRampBuilder.h.

{};

Member Function Documentation

AthAlgorithm()

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

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

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

{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 = static_cast<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 = static_cast<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()

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.

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_isSC && 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, 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_bcContKey

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

private

Definition at line 136 of file LArRampBuilder.h.

{this, "BadChanKey", "LArBadChannel", "SG key for LArBadChan object"};

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.

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

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.

{this,"ScCablingKey","LArOnOffIdMapSC","SG Key of SC LArOnOffIdMapping object"};

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.

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

m_DAC0

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

private

Definition at line 123 of file LArRampBuilder.h.

{this,"DAC0",0,"DAC value considered DAC0"};

m_dac0sub

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

private

Definition at line 122 of file LArRampBuilder.h.

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

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.

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

m_degree

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

private

Definition at line 120 of file LArRampBuilder.h.

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

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.

{this,"DelayShift",23};  //Only for OF peak reco

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.

{this,"IgnoreBadChannels",true,"Don't complain about known bad channels"};

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.

{this,"GroupingType","ExtendedFeedThrough","Grouping of the output conditions-container"};

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.

{this,"HECKey","","SG Key of injection-resistor obj used for HEC Ramps"};

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.

{this,"isHEC",false,"Processing HEC data yes/no"};

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.

{this,"isSC",false,"Processing SC data yes/no"};

m_iterate

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

private

Definition at line 146 of file LArRampBuilder.h.

{this,"Iterate",false,"Iterative OF peak reco"};

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.

{this, "KeyList",{},"List if input SG keys"};

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.

{this,"KeyOutput","LArRamp","SG Key of output object"};

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.

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

m_minDAC

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

private

Definition at line 127 of file LArRampBuilder.h.

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

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.

{this,"PeakOFTool","LArOFPeakRecoTool"};

m_peakParabolaTool

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

private

Definition at line 93 of file LArRampBuilder.h.

{this,"LArParabolaPeakRecoTool","LArParabolaPeakRecoTool"};

m_peakShapeTool

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

private

Definition at line 94 of file LArRampBuilder.h.

{this,"LArShapePeakRecoTool","LArShapePeakRecoTool"};

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.

{this,"ProblemsToMask",{}, "Bad-Channel categories to mask"};

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.

{OF};

m_recoTypeProp

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

private

Definition at line 128 of file LArRampBuilder.h.

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

m_satSlope

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

private

Definition at line 126 of file LArRampBuilder.h.

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

m_saveRawRamp

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

private

Definition at line 124 of file LArRampBuilder.h.

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

m_saveRecRamp

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

private

Definition at line 125 of file LArRampBuilder.h.

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

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.

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

---

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

• LArRampBuilder.h
• LArRampBuilder.cxx