L1CaloPprPhos4ShapeMaker Class Reference

#include <L1CaloPprPhos4ShapeMaker.h>

Inheritance diagram for L1CaloPprPhos4ShapeMaker:

Collaboration diagram for L1CaloPprPhos4ShapeMaker:

Public Member Functions
	L1CaloPprPhos4ShapeMaker (const std::string &name, ISvcLocator *pSvcLocator)
virtual StatusCode	initialize () override
virtual StatusCode	execute () override
virtual StatusCode finalize	ATLAS_NOT_THREAD_SAFE () override
virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

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

Private Types
typedef TriggerTowerCollection::const_iterator	Itr_tt
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
	L1CaloPprPhos4ShapeMaker ()
	L1CaloPprPhos4ShapeMaker (const L1CaloPprPhos4ShapeMaker &rhs)
void	operator= (const L1CaloPprPhos4ShapeMaker &rhs)
L1CaloCoolChannelId	GetCoolId (const double eta, const double phi, const unsigned int layer)
bool	IsCoolIdValid (const L1CaloCoolChannelId coolId)
StatusCode	loadAthenaObjects ()
StatusCode	GetTriggerTowers ()
StatusCode	GetRODHeader ()
StatusCode	GetDatabaseHandle (const std::string &folderName)
void	SetTimingRegime (const std::string &regime)
void	SetAtlasStyle (void)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
L1CaloPprPhos4ShapeCollection *	m_signalShapes
ToolHandle< LVL1::TrigT1CaloLWHistogramTool >	m_histTool
bool	m_currentDatabaseMapsFilled
std::string	m_fullDataDelayName
std::map< unsigned int, unsigned int >	m_currentFullDelayDataMap
std::string	m_pedValueName
std::map< unsigned int, unsigned int >	m_currentPedValueMap
std::string	m_l1aFadcSliceName
unsigned int	m_l1aFadcSlice
std::string	m_errorCodeName
std::string	m_timingRegimeName
std::string	m_timingRegime
std::string	m_ttcConfigurationName
std::string	m_ttcConfiguration
const TriggerTowerCollection *	m_triggerTowers
const DataVector< LVL1::RODHeader > *	m_rodHeader
unsigned int	m_runNumber
const CondAttrListCollection *	m_attrList
std::string	m_pprChanCalibFolderName
std::string	m_readoutConfigFolderName
std::string	m_ppmDeadChannelsFolderName
std::string	m_l1caloDerivedRunParsFolderName
std::string	m_l1caloRunParametersFolderName
ToolHandle< LVL1::IL1CaloTTIdTools >	m_l1CaloTTIdTools
const CaloIdManager *	m_caloMgr
CaloTriggerTowerService *	m_ttSvc
const TTOnlineID *	m_ttOnlineIdHelper
const CaloLVL1_ID *	m_lvl1Helper
std::map< unsigned int, TProfile * > *	m_signalProfiles
bool	m_firstEvent
std::string	m_outputDirectory
unsigned int	m_minSignalHeight
std::vector< unsigned int >	m_selectedCoolIds
std::map< unsigned int, TH2F * >	m_histosForSelectedCoolIds
bool	m_isTile
bool	m_isLAr
DataObjIDColl	m_extendedExtraObjects
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Static Private Attributes
static const unsigned short int	m_maxSelectedCoolIds = 50

Detailed Description

Definition at line 60 of file L1CaloPprPhos4ShapeMaker.h.

Member Typedef Documentation

Itr_tt

typedef TriggerTowerCollection::const_iterator L1CaloPprPhos4ShapeMaker::Itr_tt

private

Definition at line 107 of file L1CaloPprPhos4ShapeMaker.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

L1CaloPprPhos4ShapeMaker() [1/3]

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

Definition at line 11 of file L1CaloPprPhos4ShapeMaker.cxx.

                                                                                                  : AthAlgorithm(name, pSvcLocator),
   m_signalShapes(0),
   m_histTool("TrigT1CaloLWHistogramTool"),
   m_currentDatabaseMapsFilled(false),
   m_l1aFadcSlice(0),
   m_triggerTowers(0),
   m_rodHeader(0),
   m_runNumber(0),
   m_attrList(0),
   m_l1CaloTTIdTools("LVL1::L1CaloTTIdTools/L1CaloTTIdTools"),
   m_caloMgr(0),
   m_ttSvc(0),
   m_ttOnlineIdHelper(0),
   m_lvl1Helper(0),
   m_signalProfiles(0),
   m_firstEvent(true),
   m_minSignalHeight(0),
   m_isTile(false),
   m_isLAr(false)
{
   
//  declareProperty("UseTile",m_useTile = false);
   declareProperty("outputDirectory",m_outputDirectory = ".");
   declareProperty("minimumSignalSizeInAdcCounts",m_minSignalHeight = 30);
   declareProperty("selectedCoolIds",m_selectedCoolIds);
   
   SetAtlasStyle();
}

L1CaloPprPhos4ShapeMaker() [2/3]

L1CaloPprPhos4ShapeMaker::L1CaloPprPhos4ShapeMaker ( )

private

L1CaloPprPhos4ShapeMaker() [3/3]

L1CaloPprPhos4ShapeMaker::L1CaloPprPhos4ShapeMaker ( const L1CaloPprPhos4ShapeMaker &  rhs )

private

Member Function Documentation

ATLAS_NOT_THREAD_SAFE()

virtual StatusCode finalize L1CaloPprPhos4ShapeMaker::ATLAS_NOT_THREAD_SAFE ( )

overridevirtual

declareGaudiProperty() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

declareGaudiProperty() [2/4]

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  t, const SG::NotHandleType &    )

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleBase &  hndl, const std::string &  doc, const SG::VarHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleKey &  hndl, const std::string &  doc, const SG::VarHandleKeyType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleKeyArray &  hndArr, const std::string &  doc, const SG::VarHandleKeyArrayType &    )

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc, const SG::NotHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(name, property, doc);
  }

declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc = "none"  )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

  {
    typedef typename SG::HandleClassifier<T>::type htype;
    return declareProperty (name, property, doc, htype());
  }

declareProperty() [6/6]

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore() [1/2]

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode L1CaloPprPhos4ShapeMaker::execute ( )

overridevirtual

Definition at line 105 of file L1CaloPprPhos4ShapeMaker.cxx.

                                            {
   // This section is for code that is run for each event.
   
   ATH_MSG_INFO("In execute()");
   const EventContext& ctx = Gaudi::Hive::currentContext();
   
   if(m_runNumber == 0){
      m_runNumber = ctx.eventID().run_number();
      
      ATH_MSG_INFO("Run Number: " << m_runNumber );
      m_signalShapes->SetRunNumber(m_runNumber);
   }
   
   uint64_t eventNum = ctx.eventID().event_number();
   
   // Retrieve the Database parameters.
   // Only need to do this once because they do not change from event to event.
   if(!m_currentDatabaseMapsFilled){
      
      ATH_MSG_INFO( "Getting database handle for folder " << m_readoutConfigFolderName );
      
      
      
      // first  open the ReadoutConfig folder so I can see in which bunch
      // the peak should be located.
      
      StatusCode sc = GetDatabaseHandle(m_readoutConfigFolderName);
      if(sc.isFailure()){
         ATH_MSG_INFO( "Failed to retrieve database handle: " << m_readoutConfigFolderName );
         return sc;
      }
      
      // should really only be one entry, but still will catch everything
      CondAttrListCollection::const_iterator attrListCollItr = m_attrList->begin();
      
      for(;attrListCollItr != m_attrList->end();++attrListCollItr){
         const coral::AttributeList* attrList = &(attrListCollItr->second);
         
         m_l1aFadcSlice = (*attrList)[m_l1aFadcSliceName].data<unsigned int>();
         // look at the next loop to find where I fill this value into the
         // collection
         
      } // end for(attrList)
      
      // now retreive the timingRegime from the DerivedRunPars folder
      ATH_MSG_INFO( "Getting database handle for folder " << m_l1caloDerivedRunParsFolderName );
      
      sc = GetDatabaseHandle(m_l1caloDerivedRunParsFolderName);
      if(sc.isFailure()){
         ATH_MSG_INFO( "Failed to retrieve database handle: " << m_l1caloDerivedRunParsFolderName  );
         return sc;
      }
      
      // should really only be one entry, but still will catch everything
      attrListCollItr = m_attrList->begin();
      
      for(;attrListCollItr != m_attrList->end();++attrListCollItr){
         const coral::AttributeList* attrList = &(attrListCollItr->second);
         
         m_timingRegime = (*attrList)[m_timingRegimeName].data<std::string>();
         
      } // end for(attrList)
      // set timingRegime for SignalShapeCollection and databases
      SetTimingRegime(m_timingRegime);
      
      // now retreive the ttcConfiguration from the RunParameters folder
      // this allows to check if LAr or Tile is being used.
      ATH_MSG_INFO( "Getting database handle for folder " << m_l1caloRunParametersFolderName );
      
      sc = GetDatabaseHandle(m_l1caloRunParametersFolderName);
      if(sc.isFailure()){
         ATH_MSG_INFO( "Failed to retrieve database handle: " << m_l1caloRunParametersFolderName  );
         return sc;
      }
      
      // should really only be one entry, but still will catch everything
      attrListCollItr = m_attrList->begin();
      
      for(;attrListCollItr != m_attrList->end();++attrListCollItr){
         const coral::AttributeList* attrList = &(attrListCollItr->second);
            
         m_ttcConfiguration = (*attrList)[m_ttcConfigurationName].data<std::string>();
         
         if(m_ttcConfiguration.find("LAr") != std::string::npos){
            ATH_MSG_INFO( " This is a LAr run." );
            m_isLAr  = true;
            m_isTile = false;
            m_signalShapes->SetLArRun(true);
         }
         else if(m_ttcConfiguration.find("Tile") != std::string::npos){
            ATH_MSG_INFO( " This is a Tile run." );
            m_isLAr  = false;
            m_isTile = true;
            m_signalShapes->SetTileRun(true);
         }
         else{
            ATH_MSG_INFO( " Could not determine Tile or LAr so all channels will be processed." );
            m_isLAr  = false;
            m_isTile = false;
         }
         
      } // end for(attrList)
      
      
      
      ATH_MSG_INFO( "Getting database handle for folder " << m_pprChanCalibFolderName );
      // now retrieve the PprChanCalib folder so I can
      // get the FullDelayData and the pedestal value
      
      sc = GetDatabaseHandle(m_pprChanCalibFolderName);
      if(sc.isFailure()){
         ATH_MSG_INFO( "Failed to retrieve database handle." );
         return sc;
      }
      
      attrListCollItr = m_attrList->begin();
      
      for(;attrListCollItr != m_attrList->end();++attrListCollItr){
         
         const unsigned int coolId = attrListCollItr->first;
         
         const coral::AttributeList* attrList = &(attrListCollItr->second);
         
         unsigned int tempFullDelayData = (*attrList)[m_fullDataDelayName].data<unsigned int>();
         m_currentFullDelayDataMap[coolId] = tempFullDelayData;
         
         sc = m_signalShapes->SetCurrentFullDelayData(coolId,tempFullDelayData);
         if(sc.isFailure()){
            ATH_MSG_INFO( "Failed to set FullDelayData from database to channel 0x" << std::hex << coolId << std::dec );
         }
         
         unsigned int tempPedValue = (*attrList)[m_pedValueName].data<unsigned int>();
         m_currentPedValueMap[coolId] = tempPedValue;
         
         sc = m_signalShapes->SetPedValue(coolId,tempPedValue);
         if(sc.isFailure()){
            ATH_MSG_INFO( "Failed to set PedValue from database to channel 0x" << std::hex << coolId << std::dec );
         }
         
         // utilize this loop over the cool channel id's in order to set the l1aFadcSlice
         // which is the same for all channels.
         sc = m_signalShapes->SetL1aFadcSlice(coolId,m_l1aFadcSlice);
         if(sc.isFailure()){
            ATH_MSG_INFO( "Failed to set L1aFadcSlice from database to channel 0x" << std::hex << coolId << std::dec );
         }
         
         // want to check that this channel is a valid channel
         bool isValid = false;
         L1CaloCoolChannelId id(coolId);
         isValid = IsCoolIdValid(id);
         sc = m_signalShapes->SetValidChannel(coolId,isValid);
         if(sc.isFailure()){
            ATH_MSG_INFO( "Failed to set ValidChannel from database to channel 0x" << std::hex << coolId << std::dec );
         }
         
      } // end for(attrList)
      
      // now retrieve the PprDeadChannels folder
      // want to book the dead channels so I can add this info to the tree
      sc = GetDatabaseHandle(m_ppmDeadChannelsFolderName);
      if(sc.isFailure()){
         ATH_MSG_INFO( "Failed to retrieve database handle." );
         return sc;
      }
      
      attrListCollItr = m_attrList->begin();
      
      for(;attrListCollItr != m_attrList->end();++attrListCollItr){
         const unsigned int coolId = attrListCollItr->first;
         
         const coral::AttributeList* attrList = &(attrListCollItr->second);
         
         unsigned int tempErrorCode = (*attrList)[m_errorCodeName].data<unsigned int>();
         bool enabled = true;
         if(tempErrorCode & 0xf) enabled = false;
         
         sc = m_signalShapes->SetChannelEnabled(coolId,enabled);
         if(sc.isFailure()){
            ATH_MSG_INFO( "Failed to set ChannelEnabled from database to channel 0x" << std::hex << coolId << std::dec );
         }
         
      } // end for(attrList)
      
      
      ATH_MSG_INFO( "Finished database initialization." );
      m_currentDatabaseMapsFilled = true;
   }
   
   
   ATH_MSG_INFO("Event Number: " << eventNum );
   
   if (eventNum == 0 && m_isTile){
     return StatusCode::SUCCESS;
   }
   
   
   StatusCode sc = GetTriggerTowers();
   if(sc.isFailure()){
      ATH_MSG_FATAL( "Failed to get the trigger tower collection so stopping." );
      return StatusCode::FAILURE;
   }
   
   sc = GetRODHeader();
   if(sc.isFailure()){
      ATH_MSG_FATAL( "Failed to get the ROD Header so stopping." );
      return StatusCode::FAILURE;
   }
   
   ATH_MSG_INFO( "Filling trigger tower pusles." );
   
   Itr_tt towerItr = m_triggerTowers->begin();
   Itr_tt towerEnd = m_triggerTowers->end();
   
   ATH_MSG_INFO( "Trigger Tower Collection Size: " << m_triggerTowers->size() );
   
   // Loop over the trigger tower collection
   for(;towerItr != towerEnd;++towerItr){
      
      // need to read the scan step counter which counts the steps taken during
      // the run and can be used to determine the phos4 setting
      DataVector<LVL1::RODHeader>::const_iterator rodItr = m_rodHeader->begin();
      const unsigned int scanStepNumber = (unsigned int)(*rodItr)->stepNumber();
      // FYI: As of 27/10/2009 for historic reasons this value runs from 0 to 49
      // but we are only interested in the modulo of this step with respect to 
      // 25
      const unsigned int phos4step = scanStepNumber % 25; // 0 to 24
      
      
      // get the eta/phi
      double eta = (*towerItr)->eta();
      double phi = (*towerItr)->phi();
      
      // add the EM trigger tower to the collection
      {
         // get cool id
         unsigned int layer = 0; // 0 == EM Layer; 1 == HAD Layer
         L1CaloCoolChannelId coolId = GetCoolId(eta,phi,layer);
         
         const std::vector<int> adcs = (*towerItr)->emADC();
         
         sc = m_signalShapes->Fill(coolId.id(),phos4step,adcs);
         if(sc.isFailure()){
            ATH_MSG_WARNING( " [EM] Failed to fill signal shape collection." );
         }
         
         // fill selected channel histograms
         for(unsigned int i=0;i<m_selectedCoolIds.size();++i){
            if(m_selectedCoolIds[i] == coolId.id()){
               std::map<unsigned int,TH2F*>::iterator itr =  m_histosForSelectedCoolIds.find(m_selectedCoolIds[i]);
               if(itr == m_histosForSelectedCoolIds.end()) continue;
               
               for(unsigned int j=0;j<adcs.size();++j)
                  itr->second->Fill(phos4step+j*25,adcs[j]);
               break;
            }
         }
         
         
         // need to set the triggered time slice in the signal shapes:
         if(m_firstEvent){
            sc = m_signalShapes->SetL1aFadcSlice(coolId.id(),(*towerItr)->emADCPeak());
            if(sc.isFailure()){
               ATH_MSG_WARNING( "Failed to set L1aFadcSlice from Em data to channel 0x" << std::hex << coolId << std::dec );
            }
            if(!m_signalShapes->SetChannelEtaPhiLayer(coolId.id(),eta,phi,L1CaloPprPhos4Shape::EM)) {
               ATH_MSG_WARNING( "Failed to set ChannelEtaPhiLayer from Em data to channel 0x" << std::hex << coolId << std::dec );
            }
         }
         
      }
      
      // add the HAD trigger tower to the collection
      {
         // get cool id
         unsigned int layer = 1; // 0 == EM Layer; 1 == HAD Layer
         L1CaloCoolChannelId coolId = GetCoolId(eta,phi,layer);
         
         const std::vector<int> adcs = (*towerItr)->hadADC();
         
         sc = m_signalShapes->Fill(coolId.id(),phos4step,adcs);
         if(sc.isFailure()){
            ATH_MSG_WARNING( " [HAD] Failed to fill signal shape collection." );
         }
         
         
         // fill selected channel histograms
         for(unsigned int i=0;i<m_selectedCoolIds.size();++i){
            if(m_selectedCoolIds[i] == coolId.id()){
               std::map<unsigned int,TH2F*>::iterator itr =  m_histosForSelectedCoolIds.find(m_selectedCoolIds[i]);
               if(itr == m_histosForSelectedCoolIds.end()) continue;
               
               for(unsigned int j=0;j<adcs.size();++j){
                  itr->second->Fill(phos4step+j*25,adcs[j]);
               }
               
               break;
            }
         }
         
         
         // need to set the triggered time slice in the signal shapes:
         if(m_firstEvent){
            sc = m_signalShapes->SetL1aFadcSlice(coolId.id(),(*towerItr)->hadADCPeak());
            if(sc.isFailure()){
               ATH_MSG_WARNING( "Failed to set L1aFadcSlice from HAD data to channel 0x" << std::hex << coolId << std::dec );
            }
            if(!m_signalShapes->SetChannelEtaPhiLayer(coolId.id(),eta,phi,L1CaloPprPhos4Shape::HAD)) {
               ATH_MSG_WARNING( "Failed to set ChannelEtaPhiLayer from HAD data to channel 0x" << std::hex << coolId << std::dec );
            }
         }
      }
      
      if(m_firstEvent && m_l1aFadcSlice == 0)
         m_l1aFadcSlice = (*towerItr)->emADCPeak();
      
   }// end for(towerItr)
   
   m_firstEvent = false;
   
   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();
}

GetCoolId()

L1CaloCoolChannelId L1CaloPprPhos4ShapeMaker::GetCoolId ( const double  eta, const double  phi, const unsigned int  layer  )

private

Definition at line 568 of file L1CaloPprPhos4ShapeMaker.cxx.

                                                                                                                 {
   Identifier id = m_lvl1Helper->tower_id(m_l1CaloTTIdTools->pos_neg_z(eta),
                                          layer,
                                          m_l1CaloTTIdTools->regionIndex(eta),
                                          m_l1CaloTTIdTools->etaIndex(eta),
                                          m_l1CaloTTIdTools->phiIndex(eta,phi));
   HWIdentifier hwId = m_ttSvc->createTTChannelID(id);
   L1CaloCoolChannelId coolId = m_ttSvc->createL1CoolChannelId(hwId);
   return coolId;
}

GetDatabaseHandle()

StatusCode L1CaloPprPhos4ShapeMaker::GetDatabaseHandle ( const std::string &  folderName )

private

Definition at line 556 of file L1CaloPprPhos4ShapeMaker.cxx.

                                                                                 {
   
   StatusCode sc = evtStore()->retrieve(m_attrList,folderName.c_str());
   //ATH_MSG_INFO( detStore()->dump() );
   if(sc.isFailure()){
      ATH_MSG_INFO("Failed to retrieve database handle");
      return StatusCode::FAILURE;
   }
   return StatusCode::SUCCESS;
}

GetRODHeader()

StatusCode L1CaloPprPhos4ShapeMaker::GetRODHeader ( )

private

Definition at line 546 of file L1CaloPprPhos4ShapeMaker.cxx.

                                                 {
   
   StatusCode sc = evtStore()->retrieve(m_rodHeader, "RODHeaders");
   if(sc.isFailure()){
      ATH_MSG_INFO("Failed to load ROD Headers");
      return StatusCode::FAILURE;
   }
   return StatusCode::SUCCESS;
}

GetTriggerTowers()

StatusCode L1CaloPprPhos4ShapeMaker::GetTriggerTowers ( )

private

Definition at line 534 of file L1CaloPprPhos4ShapeMaker.cxx.

                                                         {
   
   // Load in Trigger Towers. I'm not going to comment the rest, should be obvious.
   StatusCode sc = evtStore()->retrieve(m_triggerTowers, "TriggerTowers");
   if(sc.isFailure()){
      ATH_MSG_INFO("Failed to load TriggerTowers");
      return StatusCode::FAILURE;
   }
   
   return StatusCode::SUCCESS;
}

initialize()

StatusCode L1CaloPprPhos4ShapeMaker::initialize ( )

overridevirtual

Definition at line 40 of file L1CaloPprPhos4ShapeMaker.cxx.

                                               {
   StatusCode sc;
   
   // The MsgStream is the athena replacement for std::cout and std::endl
   // You can specify the level of output in your python jobOptions.py file
   // Options are DEBUG, INFO, WARNING, ERROR, FATAL
   // You can still use std::cout and std::endl, but I guess it's considered bad form.
   ATH_MSG_INFO("In Initialize()");
   
   
   // create selected histograms
   for(unsigned int i=0;i<m_selectedCoolIds.size()&&i<m_maxSelectedCoolIds;++i){
      char name[500];
      sprintf(name,"selected_%08x",m_selectedCoolIds[i]);
      TH2F *histo = new TH2F(name,name,15*25,0,15*25,1024,0,1024);
      m_histosForSelectedCoolIds[m_selectedCoolIds[i]] = histo;
      ATH_MSG_INFO("creating select histogram for: "<< std::hex << m_selectedCoolIds[i] << std::dec );
   }
   
   
//    m_l1CaloTTIdTools = 0;
   m_caloMgr = 0;
   m_ttSvc = 0;
//    m_ttOnlineIdHelper = 0; 
   m_lvl1Helper = 0;
//    m_cells2tt = 0;
 
   m_runNumber = 0;
   m_attrList = 0;
   m_pprChanCalibFolderName = "/TRIGGER/L1Calo/V1/Calibration/Calib1/PprChanCalib";
   m_readoutConfigFolderName = "/TRIGGER/L1Calo/V1/Configuration/ReadoutConfig";
   m_ppmDeadChannelsFolderName = "/TRIGGER/L1Calo/V1/Calibration/PpmDeadChannels";
   m_l1caloDerivedRunParsFolderName = "/TRIGGER/L1Calo/V1/Conditions/DerivedRunPars";
   m_l1caloRunParametersFolderName = "/TRIGGER/L1Calo/V1/Conditions/RunParameters";
   
   m_currentDatabaseMapsFilled = false;
   m_fullDataDelayName = "FullDelayData";
   m_currentFullDelayDataMap.clear();
   m_pedValueName = "PedValue";
   m_currentPedValueMap.clear();
   m_l1aFadcSliceName = "l1aFadcSlice";
   m_l1aFadcSlice = 0;
   m_errorCodeName = "ErrorCode";
   m_timingRegimeName = "timingRegime";
   m_timingRegime.clear();
   m_ttcConfigurationName = "ttcConfiguration";
   m_ttcConfiguration.clear();
   
   m_signalShapes = new L1CaloPprPhos4ShapeCollection;
   
   m_signalShapes->SetOutputDirectoryName(m_outputDirectory);
   ATH_MSG_INFO( "outputdir: " << m_outputDirectory );
   m_signalShapes->SetMinimumSignalHeight(m_minSignalHeight);
   ATH_MSG_INFO( "min signal height: " << m_minSignalHeight );
   
   // Setup all the Athena Services
   sc = this->loadAthenaObjects();if(sc.isFailure()){return sc;}
   
   m_signalShapes->SetHistogramTool(m_histTool);
   
   m_firstEvent = true;
   
   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.

IsCoolIdValid()

bool L1CaloPprPhos4ShapeMaker::IsCoolIdValid ( const L1CaloCoolChannelId  coolId )

private

Definition at line 579 of file L1CaloPprPhos4ShapeMaker.cxx.

                                                                            {
   
   try{
      const unsigned int crate = coolId.crate();
      const unsigned int moduleSlot = coolId.module() + 5;
      const unsigned int subModule = coolId.subModule();
      const unsigned int channel = coolId.channel();
      m_ttOnlineIdHelper->channelId(crate,moduleSlot,subModule,channel);
   }
   catch(const CaloID_Exception&) {
      return false;
   }
   
   return true;
}

loadAthenaObjects()

StatusCode L1CaloPprPhos4ShapeMaker::loadAthenaObjects ( )

private

Definition at line 469 of file L1CaloPprPhos4ShapeMaker.cxx.

                                                      {
 
   StatusCode sc;
   sc = detStore()->retrieve(m_caloMgr);
   if (sc.isFailure()) {
      ATH_MSG_ERROR("Unable to retrieve CaloIdManager from DetectorStore");
      return StatusCode::FAILURE;
   }
   else
    ATH_MSG_INFO( "CaloIdManager retrieved successfully." );
   
   m_ttOnlineIdHelper = m_caloMgr->getTTOnlineID();
   if (!m_ttOnlineIdHelper) {
      ATH_MSG_ERROR( "Could not access TTOnlineId helper" );
      return StatusCode::FAILURE;
   }
   else
    ATH_MSG_INFO( "TTOnlineId retrieved successfully." );
    
   m_lvl1Helper = m_caloMgr->getLVL1_ID();
   if (!m_lvl1Helper) {
      ATH_MSG_ERROR( "Could not access CaloLVL1_ID helper" );
      return StatusCode::FAILURE;
   }
   else
    ATH_MSG_INFO( "CaloLVL1_ID retrieved successfully." );
   
   sc = m_histTool.retrieve();
   if (sc.isFailure()) {
      ATH_MSG_ERROR( "Could not retrieve TrigT1CaloLWHistogramTool" );
      return StatusCode::FAILURE;
   }
   else
    ATH_MSG_INFO( "TrigT1CaloLWHistogramTool retrieved successfully." );
   
 
   sc = m_l1CaloTTIdTools.retrieve();
   if(sc.isFailure()){
         ATH_MSG_WARNING( "Cannot get L1CaloTTIdTools !" );
      }
   
   IToolSvc* toolSvc;
   sc = service( "ToolSvc",toolSvc  );
   if(sc.isSuccess()){
//      IAlgTool *algtool;
      
//       sc = toolSvc->retrieveTool("L1CaloTTIdTools", algtool);
//       ATH_MSG_DEBUG("L1CaloTTIdTools retrieved");
//       if (sc.isFailure()) {
//          ATH_MSG_WARNING( " Cannot get L1CaloTTIdTools !" );
//       }
//       m_l1CaloTTIdTools = dynamic_cast<L1CaloTTIdTools*> (algtool);
      
      sc = toolSvc->retrieveTool("CaloTriggerTowerService",m_ttSvc);
      if(sc.isFailure()){
         ATH_MSG_WARNING( "Could not retrieve CaloTriggerTowerService Tool" );
      }
      
   } // End of IToolSvc initialization.
   
   
   
   return StatusCode::SUCCESS;
}

msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

operator=()

void L1CaloPprPhos4ShapeMaker::operator= ( const L1CaloPprPhos4ShapeMaker &  rhs )

private

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

SetAtlasStyle()

void L1CaloPprPhos4ShapeMaker::SetAtlasStyle ( void  )

private

Definition at line 617 of file L1CaloPprPhos4ShapeMaker.cxx.

                                                {
   TStyle* atlasStyle = new  TStyle("atlasStyle", "ATLAS Style");
 
// Colors
 
//set the background color to white
   atlasStyle->SetFillColor(10);
   atlasStyle->SetFrameFillColor(10);
   atlasStyle->SetFrameFillStyle(0);
   atlasStyle->SetFillStyle(0);
   atlasStyle->SetCanvasColor(10);
   atlasStyle->SetPadColor(10);
   atlasStyle->SetTitleFillColor(0);
   atlasStyle->SetStatColor(10);
 
//dont put a colored frame around the plots
   atlasStyle->SetFrameBorderMode(0);
   atlasStyle->SetCanvasBorderMode(0);
   atlasStyle->SetPadBorderMode(0);
 
//use the primary color palette
   atlasStyle->SetPalette(1,0);
 
//set the default line color for a histogram to be black
   atlasStyle->SetHistLineColor(kBlack);
 
//set the default line color for a fit function to be red
   atlasStyle->SetFuncColor(kRed);
 
//make the axis labels black
   atlasStyle->SetLabelColor(kBlack,"xyz");
 
//set the default title color to be black
   atlasStyle->SetTitleColor(kBlack);
 
// Sizes
 
//set the margins
//atlasStyle->SetPadBottomMargin(0.2);
//atlasStyle->SetPadTopMargin(0.075);
//atlasStyle->SetPadLeftMargin(0.15);
 
//set axis label and title text sizes
   atlasStyle->SetLabelSize(0.03,"xyz");
   atlasStyle->SetTitleSize(0.05,"xyz");
//atlasStyle->SetTitleOffset(0.9,"x");
   atlasStyle->SetTitleOffset(1.0,"xyz");
//atlasStyle->SetStatFontSize(0.07);
//atlasStyle->SetTextSize(0.08);
   atlasStyle->SetTitleBorderSize(0);
 
   // Histogram title position
   atlasStyle->SetTitleX(0.1);
   atlasStyle->SetTitleFontSize(0.11);
   
//set line widths
   atlasStyle->SetHistLineWidth(2);
   atlasStyle->SetFrameLineWidth(2);
   atlasStyle->SetFuncWidth(2);
 
// Misc
 
//align the titles to be centered
   atlasStyle->SetTextAlign(22);
 
//set the number of divisions to show
//atlasStyle->SetNdivisions(506, "xy");
 
//turn off xy grids
//atlasStyle->SetPadGridX(0);
//atlasStyle->SetPadGridY(0);
 
//set the tick mark style
//atlasStyle->SetPadTickX(1);
//atlasStyle->SetPadTickY(1);
   
   // Set Pad Margins
   //atlasStyle->SetPadBottomMargin(0.);
   //atlasStyle->SetPadTopMargin   (0.);
   //atlasStyle->SetPadLeftMargin  (0.);
   //atlasStyle->SetPadRightMargin (0.);
 
//show the fit parameters in a box
//atlasStyle->SetOptFit(1111);
 
//turn off all other stats
   atlasStyle->SetOptStat(0);
 
//marker settings
   atlasStyle->SetMarkerStyle(8);
   atlasStyle->SetMarkerSize(0.25);
 
// Fonts
//atlasStyle->SetStatFont(42);
//atlasStyle->SetLabelFont(42,"xyz");
//atlasStyle->SetTitleFont(42,"xyz");
//atlasStyle->SetTextFont(42);
 
//done
   atlasStyle->cd();
 
//gROOT->ForceStyle();
//    gStyle->ls();
}

SetTimingRegime()

void L1CaloPprPhos4ShapeMaker::SetTimingRegime ( const std::string &  regime )

private

Definition at line 595 of file L1CaloPprPhos4ShapeMaker.cxx.

                                                                     {
   
   // Regime should be "Physics", "Calib1", or "Calib2"
   if(regime != "Physics" && regime != "Calib1" && regime != "Calib2"){
      ATH_MSG_WARNING( "Timing Regime is expected to be Physics, Calib1, or Calib2, but is actually: " << regime << ", using Calib1 as default." );
      m_timingRegime = "Calib1";
   }
   
   // set local variable
   m_timingRegime = regime;
   
   // set signal shapes collection
   m_signalShapes->SetTimingRegime(m_timingRegime);
   
   // build database name for PprChanCalib folder
   
   m_pprChanCalibFolderName = "/TRIGGER/L1Calo/V1/Calibration/";
   m_pprChanCalibFolderName += m_timingRegime;
   m_pprChanCalibFolderName += "/PprChanCalib";
   
}

sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

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

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

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

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

Definition at line 66 of file AthAlgorithm.cxx.

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

sysStart()

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

overridevirtualinherited

Handle START transition.

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

updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

m_attrList

const CondAttrListCollection* L1CaloPprPhos4ShapeMaker::m_attrList

private

Definition at line 112 of file L1CaloPprPhos4ShapeMaker.h.

m_caloMgr

const CaloIdManager* L1CaloPprPhos4ShapeMaker::m_caloMgr

private

Definition at line 127 of file L1CaloPprPhos4ShapeMaker.h.

m_currentDatabaseMapsFilled

bool L1CaloPprPhos4ShapeMaker::m_currentDatabaseMapsFilled

private

Definition at line 92 of file L1CaloPprPhos4ShapeMaker.h.

m_currentFullDelayDataMap

std::map<unsigned int,unsigned int> L1CaloPprPhos4ShapeMaker::m_currentFullDelayDataMap

private

Definition at line 94 of file L1CaloPprPhos4ShapeMaker.h.

m_currentPedValueMap

std::map<unsigned int,unsigned int> L1CaloPprPhos4ShapeMaker::m_currentPedValueMap

private

Definition at line 96 of file L1CaloPprPhos4ShapeMaker.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_errorCodeName

std::string L1CaloPprPhos4ShapeMaker::m_errorCodeName

private

Definition at line 99 of file L1CaloPprPhos4ShapeMaker.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_firstEvent

bool L1CaloPprPhos4ShapeMaker::m_firstEvent

private

Definition at line 137 of file L1CaloPprPhos4ShapeMaker.h.

m_fullDataDelayName

std::string L1CaloPprPhos4ShapeMaker::m_fullDataDelayName

private

Definition at line 93 of file L1CaloPprPhos4ShapeMaker.h.

m_histosForSelectedCoolIds

std::map<unsigned int,TH2F*> L1CaloPprPhos4ShapeMaker::m_histosForSelectedCoolIds

private

Definition at line 144 of file L1CaloPprPhos4ShapeMaker.h.

m_histTool

ToolHandle<LVL1::TrigT1CaloLWHistogramTool> L1CaloPprPhos4ShapeMaker::m_histTool

private

Definition at line 85 of file L1CaloPprPhos4ShapeMaker.h.

m_isLAr

bool L1CaloPprPhos4ShapeMaker::m_isLAr

private

Definition at line 151 of file L1CaloPprPhos4ShapeMaker.h.

m_isTile

bool L1CaloPprPhos4ShapeMaker::m_isTile

private

Definition at line 150 of file L1CaloPprPhos4ShapeMaker.h.

m_l1aFadcSlice

unsigned int L1CaloPprPhos4ShapeMaker::m_l1aFadcSlice

private

Definition at line 98 of file L1CaloPprPhos4ShapeMaker.h.

m_l1aFadcSliceName

std::string L1CaloPprPhos4ShapeMaker::m_l1aFadcSliceName

private

Definition at line 97 of file L1CaloPprPhos4ShapeMaker.h.

m_l1caloDerivedRunParsFolderName

std::string L1CaloPprPhos4ShapeMaker::m_l1caloDerivedRunParsFolderName

private

Definition at line 116 of file L1CaloPprPhos4ShapeMaker.h.

m_l1caloRunParametersFolderName

std::string L1CaloPprPhos4ShapeMaker::m_l1caloRunParametersFolderName

private

Definition at line 117 of file L1CaloPprPhos4ShapeMaker.h.

m_l1CaloTTIdTools

ToolHandle<LVL1::IL1CaloTTIdTools> L1CaloPprPhos4ShapeMaker::m_l1CaloTTIdTools

private

Definition at line 126 of file L1CaloPprPhos4ShapeMaker.h.

m_lvl1Helper

const CaloLVL1_ID* L1CaloPprPhos4ShapeMaker::m_lvl1Helper

private

Definition at line 130 of file L1CaloPprPhos4ShapeMaker.h.

m_maxSelectedCoolIds

const unsigned short int L1CaloPprPhos4ShapeMaker::m_maxSelectedCoolIds = 50

staticprivate

Definition at line 145 of file L1CaloPprPhos4ShapeMaker.h.

m_minSignalHeight

unsigned int L1CaloPprPhos4ShapeMaker::m_minSignalHeight

private

Definition at line 141 of file L1CaloPprPhos4ShapeMaker.h.

m_outputDirectory

std::string L1CaloPprPhos4ShapeMaker::m_outputDirectory

private

Definition at line 140 of file L1CaloPprPhos4ShapeMaker.h.

m_pedValueName

std::string L1CaloPprPhos4ShapeMaker::m_pedValueName

private

Definition at line 95 of file L1CaloPprPhos4ShapeMaker.h.

m_ppmDeadChannelsFolderName

std::string L1CaloPprPhos4ShapeMaker::m_ppmDeadChannelsFolderName

private

Definition at line 115 of file L1CaloPprPhos4ShapeMaker.h.

m_pprChanCalibFolderName

std::string L1CaloPprPhos4ShapeMaker::m_pprChanCalibFolderName

private

Definition at line 113 of file L1CaloPprPhos4ShapeMaker.h.

m_readoutConfigFolderName

std::string L1CaloPprPhos4ShapeMaker::m_readoutConfigFolderName

private

Definition at line 114 of file L1CaloPprPhos4ShapeMaker.h.

m_rodHeader

const DataVector<LVL1::RODHeader>* L1CaloPprPhos4ShapeMaker::m_rodHeader

private

Definition at line 109 of file L1CaloPprPhos4ShapeMaker.h.

m_runNumber

unsigned int L1CaloPprPhos4ShapeMaker::m_runNumber

private

Definition at line 111 of file L1CaloPprPhos4ShapeMaker.h.

m_selectedCoolIds

std::vector<unsigned int> L1CaloPprPhos4ShapeMaker::m_selectedCoolIds

private

Definition at line 143 of file L1CaloPprPhos4ShapeMaker.h.

m_signalProfiles

std::map<unsigned int,TProfile*>* L1CaloPprPhos4ShapeMaker::m_signalProfiles

private

Definition at line 135 of file L1CaloPprPhos4ShapeMaker.h.

m_signalShapes

L1CaloPprPhos4ShapeCollection* L1CaloPprPhos4ShapeMaker::m_signalShapes

private

Definition at line 82 of file L1CaloPprPhos4ShapeMaker.h.

m_timingRegime

std::string L1CaloPprPhos4ShapeMaker::m_timingRegime

private

Definition at line 101 of file L1CaloPprPhos4ShapeMaker.h.

m_timingRegimeName

std::string L1CaloPprPhos4ShapeMaker::m_timingRegimeName

private

Definition at line 100 of file L1CaloPprPhos4ShapeMaker.h.

m_triggerTowers

const TriggerTowerCollection* L1CaloPprPhos4ShapeMaker::m_triggerTowers

private

Definition at line 106 of file L1CaloPprPhos4ShapeMaker.h.

m_ttcConfiguration

std::string L1CaloPprPhos4ShapeMaker::m_ttcConfiguration

private

Definition at line 103 of file L1CaloPprPhos4ShapeMaker.h.

m_ttcConfigurationName

std::string L1CaloPprPhos4ShapeMaker::m_ttcConfigurationName

private

Definition at line 102 of file L1CaloPprPhos4ShapeMaker.h.

m_ttOnlineIdHelper

const TTOnlineID* L1CaloPprPhos4ShapeMaker::m_ttOnlineIdHelper

private

Definition at line 129 of file L1CaloPprPhos4ShapeMaker.h.

m_ttSvc

CaloTriggerTowerService* L1CaloPprPhos4ShapeMaker::m_ttSvc

private

Definition at line 128 of file L1CaloPprPhos4ShapeMaker.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.

---

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

• L1CaloPprPhos4ShapeMaker.h
• L1CaloPprPhos4ShapeMaker.cxx