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
virtual StatusCode	retrieve (ToolHandle< IFormatTool > &FormatTool) override
	Retrieve all the data.
const DataMap	getMBTSData (const TileCellContainer *tileMBTSCellContainer)
	Retrieve MBTS cell location and details.
virtual std::string	dataTypeName () const override
	Return the name of the data type.
virtual StatusCode	initialize () override
	Default AthAlgTool methods.

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"}
SG::ReadHandleKey< TileDigitsContainer >	m_sgKeyTileDigits
SG::ReadHandleKey< TileRawChannelContainer >	m_sgKeyTileRawChannel
Gaudi::Property< double >	m_mbtsThreshold {this, "MBTSThreshold", 0.05}
Gaudi::Property< bool >	m_mbts {this, "RetrieveMBTS", true}
Gaudi::Property< bool >	m_mbtsdigit {this, "DoMBTSDigits", false}
Gaudi::Property< bool >	m_mbtsCellDetails {this, "DoMBTSCellDetails", false}

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 Function Documentation

dataTypeName()

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

inlineoverridevirtual

Return the name of the data type.

Definition at line 57 of file CaloMBTSRetriever.h.

{ return "MBTS"; };

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

overridevirtual

Default AthAlgTool methods.

Initialise the Tool.

Definition at line 27 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;
  }

retrieve()

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

overridevirtual

Retrieve all the data.

MBTS data retrieval from chosen collection.

Definition at line 49 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;
  }

Member Data Documentation

m_mbts

Gaudi::Property<bool> JiveXML::CaloMBTSRetriever::m_mbts {this, "RetrieveMBTS", true}

private

Definition at line 78 of file CaloMBTSRetriever.h.

{this, "RetrieveMBTS", true};

m_mbtsCellDetails

Gaudi::Property<bool> JiveXML::CaloMBTSRetriever::m_mbtsCellDetails {this, "DoMBTSCellDetails", false}

private

Definition at line 80 of file CaloMBTSRetriever.h.

{this, "DoMBTSCellDetails", false};

m_mbtsdigit

Gaudi::Property<bool> JiveXML::CaloMBTSRetriever::m_mbtsdigit {this, "DoMBTSDigits", false}

private

Definition at line 79 of file CaloMBTSRetriever.h.

{this, "DoMBTSDigits", false};

m_mbtsThreshold

Gaudi::Property<double> JiveXML::CaloMBTSRetriever::m_mbtsThreshold {this, "MBTSThreshold", 0.05}

private

Definition at line 77 of file CaloMBTSRetriever.h.

{this, "MBTSThreshold", 0.05};

m_sgKeyMBTS

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

private

Definition at line 71 of file CaloMBTSRetriever.h.

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

m_sgKeyTileDigits

SG::ReadHandleKey<TileDigitsContainer> JiveXML::CaloMBTSRetriever::m_sgKeyTileDigits

private

Initial value:

{this, "TileDigitsContainer", ""
    , "Input collection to retrieve Tile raw channels, used when DoMBTSCellDetails is True"}

Definition at line 72 of file CaloMBTSRetriever.h.

                                                            {this, "TileDigitsContainer", ""
    , "Input collection to retrieve Tile raw channels, used when DoMBTSCellDetails is True"};

m_sgKeyTileRawChannel

SG::ReadHandleKey<TileRawChannelContainer> JiveXML::CaloMBTSRetriever::m_sgKeyTileRawChannel

private

Initial value:

{this, "TileRawChannelContainer", ""
    , "Input collection to retrieve Tile digits, used when doTileDigit is True"}

Definition at line 74 of file CaloMBTSRetriever.h.

                                                                    {this, "TileRawChannelContainer", ""
    , "Input collection to retrieve Tile digits, used when doTileDigit is True"};

m_tileTBID

const TileTBID* JiveXML::CaloMBTSRetriever::m_tileTBID {}

private

Definition at line 69 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 66 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 63 of file CaloMBTSRetriever.h.

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

---

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

• CaloMBTSRetriever.h
• CaloMBTSRetriever.cxx