JiveXML::CaloMBTSRetriever Class Reference

Retrieves all Calo Cluster objects. More...

#include <CaloMBTSRetriever.h>

Inheritance diagram for JiveXML::CaloMBTSRetriever:

Collaboration diagram for JiveXML::CaloMBTSRetriever:

Public Member Functions
	CaloMBTSRetriever (const std::string &type, const std::string &name, const IInterface *parent)
	Standard Constructor.
virtual StatusCode	retrieve (ToolHandle< IFormatTool > &FormatTool)
	Retrieve all the data.
const DataMap	getMBTSData (const TileCellContainer *tileMBTSCellContainer)
	Retrieve MBTS cell location and details.
virtual std::string	dataTypeName () const
	Return the name of the data type.
StatusCode	initialize ()
	Default AthAlgTool methods.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()
	Return the interface identifier.

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

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

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

Private Attributes
ToolHandle< TileCondToolTiming >	m_tileToolTiming
ToolHandle< TileCondToolEmscale >	m_tileToolEmscale
const TileTBID *	m_tileTBID
SG::ReadHandleKey< TileCellContainer >	m_sgKeyMBTS {this, "StoreGateKey", "MBTSContainer", "Name of the TileCellContainer"}
	properties:
SG::ReadHandleKey< TileDigitsContainer >	m_sgKeyTileDigits {this, "TileDigitsContainerKey", "", "Name of the TileDigitsContainer"}
SG::ReadHandleKey< TileRawChannelContainer >	m_sgKeyTileRawChannel {this, "TileRawChannelContainerKey", "", "Name of the TileRawChannelContainer"}
double	m_mbtsThreshold
bool	m_mbts
bool	m_mbtsdigit
bool	m_mbtsCellDetails
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

Retrieves all Calo Cluster objects.

• Properties
  • StoreGateKeyMBTS: default is 'MBTSContainer'. Don't change.
  • MBTSThreshold: default is 0.05 (geV)
  • RetrieveMBTS: activate retriever, default is true
  • DoMBTSDigits: write MBTS digits (ADC), default is false
• Retrieved Data
  • location in phi and eta
  • numCells: number of cells in each cluster
  • cells: identifier and adc counts of each cell

Definition at line 47 of file CaloMBTSRetriever.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

CaloMBTSRetriever()

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

Standard Constructor.

This is the standard AthAlgTool constructor.

Parameters

type	AlgTool type name
name	AlgTool instance name
parent	AlgTools parent owning this tool

Definition at line 29 of file CaloMBTSRetriever.cxx.

                                                                                                          :
    AthAlgTool(type,name,parent),
    m_tileTBID(nullptr)
  {
    //Only declare the interface
    declareInterface<IDataRetriever>(this);
 
    declareProperty("MBTSThreshold", m_mbtsThreshold = 0.05);
    declareProperty("RetrieveMBTS" , m_mbts = true);
    declareProperty("DoMBTSDigits",  m_mbtsdigit=false);
    declareProperty("DoMBTSCellDetails",  m_mbtsCellDetails = false);
 
    // TileDigitsContainer names: {"TileDigitsCnt","TileDigitsFlt"};
    declareProperty("TileDigitsContainer" ,m_sgKeyTileDigits = "",
        "Input collection to retrieve Tile digits, used when doTileDigit is True");
 
    // TileRawChannelContainer names: {"TileRawChannelOpt2","TileRawChannelOpt","TileRawChannelFixed",
    //                                 "TileRawChannelFitCool","TileRawChannelFit",
    //                                 "TileRawChannelCnt","TileRawChannelFlt"};
    declareProperty("TileRawChannelContainer" ,m_sgKeyTileRawChannel = "",
        "Input collection to retrieve Tile raw channels, used when DoMBTSCellDetails is True.");
  }

Member Function Documentation

dataTypeName()

virtual std::string JiveXML::CaloMBTSRetriever::dataTypeName ( ) const

inlinevirtual

Return the name of the data type.

Implements JiveXML::IDataRetriever.

Definition at line 60 of file CaloMBTSRetriever.h.

{ return "MBTS"; };

declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

getMBTSData()

const DataMap JiveXML::CaloMBTSRetriever::getMBTSData

(

const TileCellContainer *

tileMBTSCellContainer

)

Retrieve MBTS cell location and details.

Parameters

FormatTool

the tool that will create formated output from the DataMap

< Unit for TileRawChannels (ADC, pCb, etc.)

Definition at line 103 of file CaloMBTSRetriever.cxx.

                                                                                             {
 
    ATH_MSG_DEBUG( "getMBTSData()"  );
 
    DataMap DataMap;
 
    DataVect energy; energy.reserve(tileMBTSCellContainer->size());
    DataVect label; label.reserve(tileMBTSCellContainer->size());
    DataVect phi; phi.reserve(tileMBTSCellContainer->size());
    DataVect eta; eta.reserve(tileMBTSCellContainer->size());
    DataVect sampling; sampling.reserve(tileMBTSCellContainer->size());
    DataVect timeVec; timeVec.reserve(tileMBTSCellContainer->size());
    DataVect quality; quality.reserve(tileMBTSCellContainer->size());
    DataVect type; type.reserve(tileMBTSCellContainer->size());
    DataVect channel; channel.reserve(tileMBTSCellContainer->size());
    DataVect module; module.reserve(tileMBTSCellContainer->size());
    DataVect cellPedestal; cellPedestal.reserve(tileMBTSCellContainer->size());
    DataVect cellRawAmplitude; cellRawAmplitude.reserve(tileMBTSCellContainer->size());
    DataVect cellRawTime; cellRawTime.reserve(tileMBTSCellContainer->size());
    DataVect adcCounts; adcCounts.reserve(tileMBTSCellContainer->size() * 10);
 
    std::string adcCountsStr="adcCounts multiple=\"0\"";
    const TileHWID* tileHWID = nullptr;
    const TileInfo* tileInfo = nullptr;
    const TileCablingService* cabling=nullptr;
    TileRawChannelUnit::UNIT RChUnit = TileRawChannelUnit::ADCcounts;  
    cabling = TileCablingService::getInstance();
    bool offlineRch = false;
 
    if ( detStore()->retrieve(m_tileTBID).isFailure() ) {
      ATH_MSG_ERROR( "in getMBTSData(), Could not retrieve m_tileTBID"  );
    }
 
    if ( detStore()->retrieve(tileHWID).isFailure() ) {
      ATH_MSG_ERROR( "in getMBTSData(), Could not retrieve TileHWID"  );
    }
 
    if ( detStore()->retrieve(tileInfo, "TileInfo").isFailure() ) {
      ATH_MSG_ERROR( "in getMBTSData(), Could not retrieve TileInfo" );
    }
 
    SG::ReadHandle<TileRawChannelContainer> RawChannelCnt;
    if (m_mbtsCellDetails) {
      RawChannelCnt = SG::makeHandle(m_sgKeyTileRawChannel);
      if (!RawChannelCnt.isValid()){
          ATH_MSG_WARNING( "Could not retrieve TileRawChannel "  );
      }
      else{
          RChUnit = RawChannelCnt->get_unit();
          offlineRch = (RChUnit<TileRawChannelUnit::OnlineADCcounts &&
                        RawChannelCnt->get_type() != TileFragHash::OptFilterDsp);
      }
    }
 
    SG::ReadHandle<TileDigitsContainer> tileDigits;
    if (m_mbtsdigit) {
      tileDigits = SG::makeHandle(m_sgKeyTileDigits);
      if (!tileDigits.isValid()){
         ATH_MSG_WARNING( "Could not retrieve TileDigits "  );
      }
    }
 
    // from: TileCalorimeter/TileRec/src/TileCellToNtuple.cxx
 
    std::string MBTS_ID;
    int nchan =0;
    int nTileSamples=0;
    const int max_chan=5216;
    double energyMeV = 0.;
    double phiMBTS = 0.;
    double amplitude = 0.;
    unsigned long int cellid;
    std::map<unsigned long int,double> theMbtspedestal;
    std::map<unsigned long int,double> theMbtsrawamp;
    std::map<unsigned long int,double> theMbtsrawtime;
    std::map<unsigned long int,std::vector<float> > theMbtsdigit;
    std::string myCellRawTimeStr = "0.";
 
    //Loop over TileRawChannel to get Pedestal and raw amplitude and time
 
    if (m_mbtsCellDetails && RawChannelCnt.isValid()) {
      if (offlineRch) {
 
        for (const auto rawChannel : *RawChannelCnt) {
          for (const auto cell : *rawChannel) {
            Identifier pmt_id = cell->pmt_ID();
            if (!m_tileTBID->is_tiletb(pmt_id)) continue;
            Identifier id = cell->cell_ID();
            cellid = id.get_identifier32().get_compact();
            HWIdentifier hwid=cell->adc_HWID();
            int adc       = tileHWID->adc(hwid);
            int channel   = tileHWID->channel(hwid);
            int drawer    = tileHWID->drawer(hwid);
            int ros       = tileHWID->ros(hwid);
            int drawerIdx = TileCalibUtils::getDrawerIdx(ros,drawer);
 
            amplitude = cell->amplitude();
            //Change amplitude units to ADC counts
            if (TileRawChannelUnit::ADCcounts < RChUnit && RChUnit < TileRawChannelUnit::OnlineADCcounts) {
              amplitude /= m_tileToolEmscale->channelCalib(drawerIdx, channel, adc, 1.0, TileRawChannelUnit::ADCcounts, RChUnit);
            } else if (RChUnit > TileRawChannelUnit::OnlineADCcounts) {
              amplitude = m_tileToolEmscale->undoOnlCalib(drawerIdx, channel, adc, amplitude, RChUnit);
            }
            theMbtspedestal.insert(std::make_pair( cellid, cell->pedestal() ) );
            theMbtsrawamp.insert(std::make_pair( cellid, amplitude ));
            theMbtsrawtime.insert(std::make_pair( cellid, cell->time(cell->uncorrTime()) ));
            break;
 
          }
        }
      }
    }
 
    //Loop over TileDigits to retrieve MBTS digits
 
    if (m_mbtsdigit && tileDigits.isValid()) {
 
      //----- get tile digits--------------------------
 
      // tile digits loop
      for (const auto digitChannel : *tileDigits) {
 
        for (const auto cell : *digitChannel) {
 
          Identifier pmt_id = cell->pmt_ID();
          if (!m_tileTBID->is_tiletb(pmt_id)) continue;
 
          Identifier id = cell->cell_ID();
          cellid = id.get_identifier32().get_compact();
 
          nTileSamples = cell->NtimeSamples();
          std::vector<float> tileSamples = cell->samples();
          theMbtsdigit.insert(std::make_pair( cellid, tileSamples));
          break;
 
        }
      }//for TileDigitContainer loop
    } //if (m_mbtsdigit)
 
    //Loop Over TileCellContainer to retrieve MBTSCell information
 
    for (const auto cell : *tileMBTSCellContainer) {
 
      int qual = cell->quality();
      if (cell->badcell()) qual = -qual;
 
      timeVec.push_back(DataType( cell->time() ));
      quality.push_back(DataType( qual ));
 
      if (  cell->energy() >= m_mbtsThreshold ) {
        energyMeV = cell->energy(); // roughly correct: energy unit is pC, which is 95% MeV
      }else{
        energyMeV = 0.;
      }
      energy.push_back(DataType( energyMeV )); // write in MeV
 
      Identifier id=cell->ID();
 
      //TileCell/type is  "side"  +/- 1
      //TileCell/module is "phi"  0-7
      //TileCell/channel is "eta"  0-1   zero is closer to beam pipe
 
      type.push_back(DataType( m_tileTBID->type(id) ));
      channel.push_back(DataType( m_tileTBID->channel(id) ));
      module.push_back(DataType( m_tileTBID->module(id) ));
 
      MBTS_ID = "type_" + DataType( m_tileTBID->type(id) ).toString() + "_ch_" +
          DataType( m_tileTBID->channel(id) ).toString() + "_mod_" +
          DataType( m_tileTBID->module(id) ).toString();
 
      label.push_back(DataType( MBTS_ID ));
 
      eta.push_back(DataType( 5.0*m_tileTBID->type(id) ));
 
      phiMBTS = (M_PI/8)+(2*M_PI/8)*int(m_tileTBID->module(id));
      phi.push_back(DataType( phiMBTS ));
      sampling.push_back(DataType( m_tileTBID->channel(id) ));
 
      if (m_mbtsCellDetails && RawChannelCnt.isValid()) {
 
        cellPedestal.push_back(DataType( theMbtspedestal[id.get_identifier32().get_compact()] ));
        cellRawAmplitude.push_back(DataType( theMbtsrawamp[id.get_identifier32().get_compact()] ));
        myCellRawTimeStr =  DataType(theMbtsrawtime[id.get_identifier32().get_compact()]).toString();
 
        if ( myCellRawTimeStr.find('n') == 1 )  myCellRawTimeStr="0.";
        cellRawTime.push_back( myCellRawTimeStr );
 
          // this can rarely be '-nan', but checking this each time may make code slow ?
      }
      else { // don't have TileRawChannel container (for DPF input)
 
        float maxTime = (tileInfo->NdigitSamples()/2) * 25;
        int gain = cell->gain();
 
        if (gain<0 || gain>1) { //invalid gain - channel missing
          cellRawAmplitude.push_back(DataType(0));
          cellRawTime.push_back(DataType(0));
          cellPedestal.push_back(DataType(0));  //There is no pedestal in DPD .
        }
        else {
 
          HWIdentifier hwid = tileHWID->adc_id(cabling->s2h_channel_id(id),gain);
          int adc       = tileHWID->adc(hwid);
          int channel   = tileHWID->channel(hwid);
          int drawer    = tileHWID->drawer(hwid);
          int ros       = tileHWID->ros(hwid);
          int drawerIdx = TileCalibUtils::getDrawerIdx(ros,drawer);
          float scale = m_tileToolEmscale->channelCalib(drawerIdx, channel, adc, 1.0,
                                                        TileRawChannelUnit::ADCcounts, TileRawChannelUnit::MegaElectronVolts);
          float amp;
 
          if (  cell->energy() >= m_mbtsThreshold ) amp = cell->energy()/scale;
          else amp = 0.0;
          float time = cell->time();
 
          if ((qual != 0 || amp != 0.0) && (fabs(time) < maxTime && time != 0.0)) {
            time += m_tileToolTiming->getSignalPhase(drawerIdx, channel, adc);
          }
 
          cellRawAmplitude.push_back(DataType(amp));
          cellRawTime.push_back(DataType(time));
          cellPedestal.push_back(DataType(0));  //There is no pedestal in DPD . This line is temporary.
        }
      }
 
 
      if (m_mbtsdigit && tileDigits.isValid()) {
 
        if ( !theMbtsdigit[id.get_identifier32().get_compact()].empty() ) {
          for (int i=0; i<nTileSamples; i++) {
            adcCountsStr="adcCounts multiple=\""+DataType(nTileSamples).toString()+"\"";
            adcCounts.push_back(DataType( int(theMbtsdigit[id.get_identifier32().get_compact()][i]) ));
          }
        }
        else {
          for (int i=0; i<nTileSamples; i++) {
            adcCountsStr="adcCounts multiple=\""+DataType(nTileSamples).toString()+"\"";
            adcCounts.push_back(DataType(0));
          }
        }
      }
 
 
      ATH_MSG_DEBUG( "MBTS no: " << nchan << ", type_chan_mod: " << MBTS_ID
                     << ", energy MeV pC: " << energyMeV  );
 
      nchan++;
 
      if (nchan >= max_chan) break;
 
    }//TileCell Loop
 
    if (!theMbtspedestal.empty()) theMbtspedestal.clear();
    if (!theMbtsrawamp.empty() )  theMbtsrawamp.clear();
    if (!theMbtsrawtime.empty())  theMbtsrawtime.clear();
 
    // write values into DataMap
    const auto nentries = phi.size();
    DataMap["energy"] = std::move(energy);
    DataMap["label"] = std::move(label);
    DataMap["phi"] = std::move(phi);
    DataMap["eta"] = std::move(eta);
    DataMap["sampling"] = std::move(sampling);
    DataMap["time"] = std::move(timeVec);
    DataMap["quality"] = std::move(quality);
    DataMap["type"] = std::move(type);
    DataMap["channel"] = std::move(channel);
    DataMap["module"] = std::move(module);
    DataMap["cellPedestal"] = std::move(cellPedestal);
    DataMap["cellRawAmplitude"] = std::move(cellRawAmplitude);
    DataMap["cellRawTime"] = std::move(cellRawTime);
    DataMap[adcCountsStr] = std::move(adcCounts);
 
    //Be verbose
    ATH_MSG_DEBUG( dataTypeName() << " retrieved with " << nentries << " entries" );
 
    //All collections retrieved okay
    return DataMap;
 
  } // getMBTSData

initialize()

StatusCode JiveXML::CaloMBTSRetriever::initialize

(

)

Default AthAlgTool methods.

Initialise the ToolSvc.

Definition at line 56 of file CaloMBTSRetriever.cxx.

                                           {
 
    ATH_MSG_DEBUG( "Initialising Tool" );
 
    ATH_CHECK(m_sgKeyMBTS.initialize());
 
    //=== get TileCondToolTiming
    ATH_CHECK( m_tileToolTiming.retrieve() );
 
    //=== get TileCondToolEmscale
    ATH_CHECK( m_tileToolEmscale.retrieve() );
 
    ATH_CHECK( m_sgKeyTileDigits.initialize(m_mbtsdigit) );
 
    ATH_CHECK( m_sgKeyTileRawChannel.initialize(m_mbtsCellDetails) );
 
    return StatusCode::SUCCESS;
  }

inputHandles()

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

overridevirtualinherited

Return this algorithm's input handles.

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

interfaceID()

const InterfaceID & JiveXML::IDataRetriever::interfaceID ( )

inlinestaticinherited

Return the interface identifier.

Definition at line 40 of file IDataRetriever.h.

{ return IID_IDataRetriever; }

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

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

overridevirtualinherited

Return this algorithm's output handles.

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

renounce()

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

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

retrieve()

StatusCode JiveXML::CaloMBTSRetriever::retrieve ( ToolHandle< IFormatTool > & FormatTool )

virtual

Retrieve all the data.

MBTS data retrieval from chosen collection.

Implements JiveXML::IDataRetriever.

Definition at line 78 of file CaloMBTSRetriever.cxx.

                                                                            {
 
    ATH_MSG_DEBUG( "in retrieve()"  );
 
    SG::ReadHandle<TileCellContainer> cellContainerMBTS(m_sgKeyMBTS);
    if (!cellContainerMBTS.isValid()){
        ATH_MSG_WARNING( "Could not retrieve MBTS Cells "  );
    }
    else{
      if (m_mbts) {
        DataMap data = getMBTSData(&(*cellContainerMBTS));
        ATH_CHECK( FormatTool->AddToEvent(dataTypeName(), m_sgKeyMBTS.key(), &data) );
        ATH_MSG_DEBUG( "MBTS retrieved"  );
      }
    }
 
    //MBTS cells retrieved okay
    return StatusCode::SUCCESS;
  }

sysInitialize()

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

overridevirtualinherited

Perform system initialization for an algorithm.

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

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

sysStart()

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

overridevirtualinherited

Handle START transition.

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

updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_mbts

bool JiveXML::CaloMBTSRetriever::m_mbts

private

Definition at line 79 of file CaloMBTSRetriever.h.

m_mbtsCellDetails

bool JiveXML::CaloMBTSRetriever::m_mbtsCellDetails

private

Definition at line 81 of file CaloMBTSRetriever.h.

m_mbtsdigit

bool JiveXML::CaloMBTSRetriever::m_mbtsdigit

private

Definition at line 80 of file CaloMBTSRetriever.h.

m_mbtsThreshold

double JiveXML::CaloMBTSRetriever::m_mbtsThreshold

private

Definition at line 78 of file CaloMBTSRetriever.h.

m_sgKeyMBTS

SG::ReadHandleKey<TileCellContainer> JiveXML::CaloMBTSRetriever::m_sgKeyMBTS {this, "StoreGateKey", "MBTSContainer", "Name of the TileCellContainer"}

private

properties:

Definition at line 75 of file CaloMBTSRetriever.h.

{this, "StoreGateKey", "MBTSContainer", "Name of the TileCellContainer"};

m_sgKeyTileDigits

SG::ReadHandleKey<TileDigitsContainer> JiveXML::CaloMBTSRetriever::m_sgKeyTileDigits {this, "TileDigitsContainerKey", "", "Name of the TileDigitsContainer"}

private

Definition at line 76 of file CaloMBTSRetriever.h.

{this, "TileDigitsContainerKey", "", "Name of the TileDigitsContainer"};

m_sgKeyTileRawChannel

SG::ReadHandleKey<TileRawChannelContainer> JiveXML::CaloMBTSRetriever::m_sgKeyTileRawChannel {this, "TileRawChannelContainerKey", "", "Name of the TileRawChannelContainer"}

private

Definition at line 77 of file CaloMBTSRetriever.h.

{this, "TileRawChannelContainerKey", "", "Name of the TileRawChannelContainer"};

m_tileTBID

const TileTBID* JiveXML::CaloMBTSRetriever::m_tileTBID

private

Definition at line 72 of file CaloMBTSRetriever.h.

m_tileToolEmscale

ToolHandle<TileCondToolEmscale> JiveXML::CaloMBTSRetriever::m_tileToolEmscale

private

Initial value:

{this,
          "TileCondToolEmscale", "TileCondToolEmscale", "Tile EM scale calibration tool"}

Definition at line 69 of file CaloMBTSRetriever.h.

                                                       {this,
          "TileCondToolEmscale", "TileCondToolEmscale", "Tile EM scale calibration tool"};

m_tileToolTiming

ToolHandle<TileCondToolTiming> JiveXML::CaloMBTSRetriever::m_tileToolTiming

private

Initial value:

{this,
          "TileCondToolTiming", "TileCondToolTiming", "Tile timing tool"}

Definition at line 66 of file CaloMBTSRetriever.h.

                                                     {this,
          "TileCondToolTiming", "TileCondToolTiming", "Tile timing tool"};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• CaloMBTSRetriever.h
• CaloMBTSRetriever.cxx