JiveXML::CaloTileRetriever Class Reference

Retrieves all Tile Calo Cell objects. More...

#include <CaloTileRetriever.h>

Inheritance diagram for JiveXML::CaloTileRetriever:

Collaboration diagram for JiveXML::CaloTileRetriever:

Public Member Functions
	CaloTileRetriever (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	getCaloTileData (const CaloCellContainer *cellContainer)
	Retrieve Tile 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
void	calcTILELayerSub (Identifier &)
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
ToolHandle< ITileBadChanTool >	m_tileBadChanTool
const CaloCell_ID *	m_calocell_id
SG::ReadHandleKey< CaloCellContainer >	m_sgKey {this, "StoreGateKey", "AllCalo", "Name of the CaloCellContainer"}
SG::ReadHandleKey< TileDigitsContainer >	m_sgKeyTileDigits {this, "TileDigitsContainerKey", "", "Name of the TileDigitsContainer"}
SG::ReadHandleKey< TileRawChannelContainer >	m_sgKeyTileRawChannel {this, "TileRawChannelContainerKey", "", "Name of the TileRawChannelContainer"}
double	m_cellThreshold
int	m_cellEnergyPrec
int	m_cellTimePrec
bool	m_tile
bool	m_doTileDigit
bool	m_doTileCellDetails
bool	m_doBadTile
DataVect	m_sub
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 Tile Calo Cell objects.

• Properties
  • StoreGateKeyTile: default is 'AllCalo'. Don't change.
  • CallThreshold: default is 50 MeV
  • RetrieveTile: activate retriever, default is true
  • DoTileDigits: write Tile digits (ADC), default is false
  • DoTileCellDigits: more verbose on cell details
  • CellEnergyPrec: output precision, default is 3 digits
  • CellTimePrec: output precision, default is 3 digits
• Retrieved Data
  • location in phi and eta
  • identifier and adc counts of each cell
  • various pmt details

Definition at line 48 of file CaloTileRetriever.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

CaloTileRetriever()

JiveXML::CaloTileRetriever::CaloTileRetriever	(	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 37 of file CaloTileRetriever.cxx.

                                                                                                          :
    AthAlgTool(type,name,parent),
    m_calocell_id(nullptr)
  {
   //Only declare the interface
   declareInterface<IDataRetriever>(this);
 
   declareProperty("CellThreshold", m_cellThreshold = 50.);
   declareProperty("RetrieveTILE" , m_tile = true);
   declareProperty("DoTileDigit",   m_doTileDigit = false);
   declareProperty("DoBadTile",     m_doBadTile = false);
   declareProperty("DoTileCellDetails",  m_doTileCellDetails = false);
   declareProperty("CellEnergyPrec", m_cellEnergyPrec = 3);
   declareProperty("CellTimePrec", m_cellTimePrec = 3);
 
   // 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 doTileCellDetails is True.");
  }

Member Function Documentation

calcTILELayerSub()

void JiveXML::CaloTileRetriever::calcTILELayerSub ( Identifier & cellid )

private

Definition at line 554 of file CaloTileRetriever.cxx.

  {
    if (m_calocell_id->is_tile_barrel(cellid))
    {
      if (m_calocell_id->is_tile_negative(cellid))
        m_sub.push_back(DataType(2));
      else
        m_sub.push_back(DataType(3));
    }
    else if (m_calocell_id->is_tile_extbarrel(cellid))
    {
      if (m_calocell_id->is_tile_negative(cellid))
        m_sub.push_back(DataType(0));
      else
        m_sub.push_back(DataType(5));
    }
    //else in ITC or scint
    else
    {
      if (m_calocell_id->is_tile_negative(cellid))
        m_sub.push_back(DataType(1));
      else
        m_sub.push_back(DataType(4));
    }
  }

dataTypeName()

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

inlinevirtual

Return the name of the data type.

Implements JiveXML::IDataRetriever.

Definition at line 61 of file CaloTileRetriever.h.

{ return "TileDigit"; };

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

getCaloTileData()

const DataMap JiveXML::CaloTileRetriever::getCaloTileData

(

const CaloCellContainer *

cellContainer

)

Retrieve Tile 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 118 of file CaloTileRetriever.cxx.

                                                                                         {
 
    ATH_MSG_DEBUG( "getTileData()"  );
    char rndStr[30];
    DataMap DataMap;
 
    DataVect phi; phi.reserve(cellContainer->size());
    DataVect eta; eta.reserve(cellContainer->size());
    DataVect idVec; idVec.reserve(cellContainer->size());
    DataVect energyVec; energyVec.reserve(cellContainer->size());
    DataVect adcCounts1Vec; adcCounts1Vec.reserve(cellContainer->size() * 10);
    DataVect adcCounts2Vec; adcCounts2Vec.reserve(cellContainer->size() * 10);
    DataVect BadCell; BadCell.reserve(cellContainer->size());
 
    DataVect pmt1Energy; pmt1Energy.reserve(cellContainer->size());
    DataVect pmt1Time; pmt1Time.reserve(cellContainer->size());
    DataVect pmt1Chi2; pmt1Chi2.reserve(cellContainer->size());
    DataVect pmt1Gain; pmt1Gain.reserve(cellContainer->size());
    DataVect pmt2Energy; pmt2Energy.reserve(cellContainer->size());
    DataVect pmt2Time; pmt2Time.reserve(cellContainer->size());
    DataVect pmt2Chi2; pmt2Chi2.reserve(cellContainer->size());
    DataVect pmt2Gain; pmt2Gain.reserve(cellContainer->size());
 
    DataVect pmt1RawAmplitude; pmt1RawAmplitude.reserve(cellContainer->size());
    DataVect pmt1RawTime; pmt1RawTime.reserve(cellContainer->size());
    DataVect pmt1Pedestal; pmt1Pedestal.reserve(cellContainer->size());
    DataVect pmt1Number; pmt1Number.reserve(cellContainer->size());
    DataVect pmt1ADCStatus; pmt1ADCStatus.reserve(cellContainer->size());
    DataVect pmt2RawAmplitude; pmt2RawAmplitude.reserve(cellContainer->size());
    DataVect pmt2RawTime; pmt2RawTime.reserve(cellContainer->size());
    DataVect pmt2Pedestal; pmt2Pedestal.reserve(cellContainer->size());
    DataVect pmt2Number; pmt2Number.reserve(cellContainer->size());
    DataVect pmt2ADCStatus; pmt2ADCStatus.reserve(cellContainer->size());
 
//    m_sub; m_sub.reserve(cellContainer->size());
    m_sub.clear();
 
    std::string adcCounts1Str = "adcCounts1 multiple=\"0\"";
    std::string adcCounts2Str = "adcCounts2 multiple=\"0\"";
 
    const TileID* tileID = nullptr;
    const TileHWID* tileHWID = nullptr;
    const TileInfo* tileInfo = nullptr;
    const TileCablingService* cabling=nullptr;
    TileRawChannelUnit::UNIT RChUnit = TileRawChannelUnit::ADCcounts;  
    cabling = TileCablingService::getInstance();
    double energyGeV;
    double amplitude = 0.;
    const int vsize = cellContainer->size();  //5184;
    int Index,pmtInd, cellInd, nTileSamples=0;
    std::vector<double> pmt1ped(vsize,0.0);
    std::vector<double> pmt2ped(vsize,0.0);
    std::vector<double> pmt1rawamp(vsize,0.0);
    std::vector<double> pmt2rawamp(vsize,0.0);
    std::vector<double> pmt1rawtime(vsize,0.0);
    std::vector<double> pmt2rawtime(vsize,0.0);
    std::vector<int> pmt1number(vsize,0);
    std::vector<int> pmt2number(vsize,0);
    std::vector<unsigned long int> pmt1status(vsize,0);
    std::vector<unsigned long int> pmt2status(vsize,0);
    std::map<int,std::vector<float> > pmt1digit;
    std::map<int,std::vector<float> > pmt2digit;
    bool offlineRch = false;
 
    //===== retrieving everything which is needed for Tile
 
    if (detStore()->retrieve(tileID).isFailure()) {
      ATH_MSG_ERROR( "in getCaloTileData(), Could not retrieve TileID"  );
 
    }
 
    if (detStore()->retrieve(tileHWID).isFailure()) {
      ATH_MSG_ERROR( "in getCaloTileData(), Could not retrieve TileHWID"  );
    }
 
    if (detStore()->retrieve(tileInfo, "TileInfo").isFailure()) {
      ATH_MSG_ERROR( "in getCaloTileData(), Could not retrieve TileInfo" );
    }
 
    SG::ReadHandle<TileDigitsContainer> tileDigits;
    if (m_doTileDigit) {
      tileDigits = SG::makeHandle(m_sgKeyTileDigits);
      if (!tileDigits.isValid()){
         ATH_MSG_WARNING( "Could not retrieve TileDigits "  );
      }
    }
 
    SG::ReadHandle<TileRawChannelContainer> RawChannelCnt;
    if (m_doTileCellDetails) {
      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);
      }
    }
 
 
    // Loop Over TileRawChannelContainer to retrieve raw information. Keep the values in vectors
 
    if (m_doTileCellDetails && RawChannelCnt.isValid()) {
     if (offlineRch) {
 
      for (const auto rawChannel : *RawChannelCnt) {
 
         for (const auto cell : *rawChannel) {
 
          /*Identifier cell_id =*/ cell->cell_ID_index(Index,pmtInd);
          if (Index <= -1 ) continue;  //disconnect channel index is -1 and MBTS is -2. They do not have an idhash
          IdentifierHash cell_hash = m_calocell_id->calo_cell_hash( cell->cell_ID() );
          cellInd = cellContainer->findIndex(cell_hash);  //find Cell Index
          if (cellInd < 0) continue;
 
          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 PMT = abs( cabling->channel2hole(ros,channel) );
          int drawerIdx = TileCalibUtils::getDrawerIdx(ros,drawer);
          uint32_t tileAdcStatus = m_tileBadChanTool->encodeStatus(m_tileBadChanTool->getAdcStatus(drawerIdx,channel,adc));
 
          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) {
            // Should never get here due to offlineRch test above.
            //amplitude = m_tileToolEmscale->undoOnlCalib(drawerIdx, channel, adc, amplitude, RChUnit);
            std::abort();
          }
 
          if ( pmtInd == 0 ) { // first PMT
 
            pmt1ped[cellInd] = cell->pedestal();
            pmt1rawamp[cellInd] = amplitude;
            pmt1rawtime[cellInd] = cell->uncorrTime();
            pmt1number[cellInd] = PMT;
            pmt1status[cellInd] = tileAdcStatus;
          }
          else { // second PMT
 
            pmt2ped[cellInd] = cell->pedestal();
            pmt2rawamp[cellInd] = amplitude;
            pmt2rawtime[cellInd] = cell->uncorrTime();
            pmt2number[cellInd] = PMT;
            pmt2status[cellInd] = tileAdcStatus;
 
          }
        }
      }//for TileRawChannelContainer loop
     }
    } // end of doTileCellDetails
 
 
    //Loop over TileDigitsContainer to retrieve digits. Keep the digits values in a map
 
    if (m_doTileDigit && tileDigits.isValid()) {
 
      //----- get tile digits--------------------------
 
      // tile digits loop
      for (const auto digitChannel : *tileDigits) {
 
        for (const auto cell : *digitChannel) {
 
          /*Identifier cell_id =*/ cell->cell_ID_index(Index,pmtInd);
          if (Index <= -1 ) continue; //disconnect channel index is -1 and MBTS is -2. They do not have an idhash
          IdentifierHash cell_hash = m_calocell_id->calo_cell_hash( cell->cell_ID() );
          cellInd = cellContainer->findIndex(cell_hash);  //find Cell Index
          if (cellInd < 0) continue;
          if ( (*cellContainer)[cellInd]->energy() < m_cellThreshold) continue;
 
          nTileSamples = cell->NtimeSamples();
          std::vector<float> tileSamples = cell->samples();
 
          if (pmtInd == 0 ) { // first PMT
            pmt1digit.insert(std::make_pair( cellInd, tileSamples ) );
          }
          else { // second PMT
            pmt2digit.insert(std::make_pair( cellInd, tileSamples ) );
          }
 
        }
      }//for TileDigitContainer loop
    } // end if doTileDigit
 
 
    //Loop Over CaloCellContainer to retrieve TileCell information
 
    CaloCellContainer::const_iterator it1 = cellContainer->beginConstCalo(CaloCell_ID::TILE);
    CaloCellContainer::const_iterator it2 = cellContainer->endConstCalo(CaloCell_ID::TILE);
 
    double energyAllTile = 0.; 
 
    for (;it1!=it2;++it1) {
 
      if ((*it1)->badcell()) BadCell.push_back(1);
      else if ((*it1)->energy()>= m_cellThreshold) BadCell.push_back(0);
      else BadCell.push_back(-1);
 
      Identifier cellid = (*it1)->ID();
      IdentifierHash cell_hash = m_calocell_id->calo_cell_hash( cellid );
      cellInd = cellContainer->findIndex(cell_hash);
      if (cellInd < 0) continue;
      calcTILELayerSub(cellid);
 
      energyGeV = (*it1)->energy()*(1./GeV);
      energyVec.push_back(DataType( gcvt( energyGeV, m_cellEnergyPrec, rndStr) ));
      energyAllTile += energyGeV;
 
      idVec.push_back(DataType( (Identifier::value_type)(*it1)->ID().get_compact() ));
      phi.push_back(DataType((*it1)->phi()));
      eta.push_back(DataType((*it1)->eta()));
 
      if (m_doTileDigit && tileDigits.isValid()) {
 
        if ( !pmt1digit[cellInd].empty()) {
          for (int i=0; i<nTileSamples; i++) {
            adcCounts1Str="adcCounts1 multiple=\""+DataType(nTileSamples).toString()+"\"";
            adcCounts1Vec.push_back(DataType( int(pmt1digit[cellInd][i])));
          }
        }
        else {
          for (int i=0; i<nTileSamples; i++) {
            adcCounts1Str="adcCounts1 multiple=\""+DataType(nTileSamples).toString()+"\"";
            adcCounts1Vec.push_back(DataType(0));
          }
        }
 
 
        if ( !pmt2digit[cellInd].empty()) {
          for (int i=0; i<nTileSamples; i++) {
            adcCounts2Str="adcCounts2 multiple=\""+DataType(nTileSamples).toString()+"\"";
            adcCounts2Vec.push_back(DataType( int(pmt2digit[cellInd][i])));
          }
        }
        else {
          for (int i=0; i<nTileSamples; i++) {
            adcCounts2Str= "adcCounts2 multiple=\""+DataType(nTileSamples).toString()+"\"";
            adcCounts2Vec.push_back(DataType(0));
          }
        }
      }
 
      if (m_doTileCellDetails) {
 
        const TileCell* theTileCell = dynamic_cast<const TileCell *>(*it1);
        if (not theTileCell) {
          //should never happen
          throw std::runtime_error("Could not cast pointer to TileCell in CaloTileRetriever::getCaloTileData");
        }
        int  gain1  = theTileCell->gain1();
        int  qual1  = theTileCell->qual1();
        bool badch1 = theTileCell->badch1();
        bool noch1  = (gain1<0 || gain1>1);
 
        int  qual2  = theTileCell->qual2();
        int  gain2  = theTileCell->gain2();
        bool badch2 = theTileCell->badch2();
        bool noch2  = (gain2<0 || gain2>1);
 
        if (badch1 != badch2 && qual1 != qual2 && qual1 < 255 && qual2 < 255) {
          if (badch1 && !noch1) gain1 = 1 - gain1;
          if (badch2 && !noch1) gain2 = 1 - gain2;
        }
        if (badch1) qual1 = -qual1;
        if (badch2) qual2 = -qual2;
 
        pmt1Energy.push_back(DataType(theTileCell->ene1()*(1./GeV)));
        pmt1Time.push_back(DataType(theTileCell->time1()));
        pmt1Chi2.push_back(DataType(qual1));
        pmt1Gain.push_back(DataType(gain1));
 
        pmt2Energy.push_back(DataType(theTileCell->ene2()*(1./GeV)));
        pmt2Time.push_back(DataType(theTileCell->time2()));
        pmt2Chi2.push_back(DataType(qual2));
        pmt2Gain.push_back(DataType(gain2));
 
        if (offlineRch && RawChannelCnt.isValid() 
            && (noch1 || pmt1number[cellInd]!=0) && (noch2 || pmt2number[cellInd]!=0)) {
 
          uint32_t tileAdcStatus = pmt1status[cellInd];
          if (badch1) tileAdcStatus += 10;
 
          pmt1RawAmplitude.push_back(DataType(pmt1rawamp[cellInd]));
          pmt1RawTime.push_back(DataType(pmt1rawtime[cellInd]));
          pmt1Pedestal.push_back(DataType(pmt1ped[cellInd]));
          pmt1Number.push_back(DataType(pmt1number[cellInd]));
          pmt1ADCStatus.push_back(DataType(tileAdcStatus));
 
          tileAdcStatus = pmt2status[cellInd];
          if (badch2) tileAdcStatus += 10;
 
          pmt2RawAmplitude.push_back(DataType(pmt2rawamp[cellInd]));
          pmt2RawTime.push_back(DataType(pmt2rawtime[cellInd]));
          pmt2Pedestal.push_back(DataType(pmt2ped[cellInd]));
          pmt2Number.push_back(DataType(pmt2number[cellInd]));
          pmt2ADCStatus.push_back(DataType(tileAdcStatus));
        }
        else {  
 
          float maxTime = (tileInfo->NdigitSamples()/2) * 25;
 
          if (noch1 /* || pmt1digit[cellInd].empty() */ ) { //invalid gain - channel missing or digits not include in DPD
            pmt1RawAmplitude.push_back(DataType(0));
            pmt1RawTime.push_back(DataType(0));
            pmt1ADCStatus.push_back(DataType(0));
            pmt1Number.push_back(DataType(0));
            pmt1Pedestal.push_back(DataType(0));  //The is no pedestal in DPD.
          } else {
            HWIdentifier hwid = cabling->s2h_adc_id(tileID->adc_id(cellid,0,gain1));
 
            int adc       = tileHWID->adc(hwid);
            int channel   = tileHWID->channel(hwid);
            int drawer    = tileHWID->drawer(hwid);
            int ros       = tileHWID->ros(hwid);
            int PMT = abs( cabling->channel2hole(ros,channel) );
            int drawerIdx = TileCalibUtils::getDrawerIdx(ros,drawer);
            float scale = m_tileToolEmscale->channelCalib(drawerIdx, channel, adc, 1.0,
                                                          TileRawChannelUnit::ADCcounts, TileRawChannelUnit::MegaElectronVolts);
            float amp = theTileCell->ene1() / scale;
            float time = theTileCell->time1();
 
            int qbit = (theTileCell->qbit1() & TileCell::MASK_TIME);
            if ((qual1 != 0 || qbit != 0 || amp != 0.0) && (fabs(time) < maxTime && time != 0.0)) {
              time += m_tileToolTiming->getSignalPhase(drawerIdx, channel, adc);
            }
 
            uint32_t tileAdcStatus = m_tileBadChanTool->encodeStatus(m_tileBadChanTool->getAdcStatus(drawerIdx,channel,adc));
            if (badch1) tileAdcStatus += 10;
 
            pmt1RawAmplitude.push_back(DataType(amp));
            pmt1RawTime.push_back(DataType(time));
            pmt1Number.push_back(DataType(PMT));
            pmt1ADCStatus.push_back(DataType( tileAdcStatus ));
            pmt1Pedestal.push_back(DataType(0));  //The is no pedestal in DPD . This line is temporary.
          }
 
          if (noch2 /* || pmt2digit[cellInd].empty() */ ) { //invalid gain - channel missing
            pmt2RawAmplitude.push_back(DataType(0));
            pmt2RawTime.push_back(DataType(0));
            pmt2ADCStatus.push_back(DataType(0));
            pmt2Number.push_back(DataType(0));
            pmt2Pedestal.push_back(DataType(0));  //The is no pedestal in DPD
          } else {
            HWIdentifier hwid = cabling->s2h_adc_id(tileID->adc_id(cellid,1,gain2));
 
            int adc       = tileHWID->adc(hwid);
            int channel   = tileHWID->channel(hwid);
            int drawer    = tileHWID->drawer(hwid);
            int ros       = tileHWID->ros(hwid);
            int PMT = abs( cabling->channel2hole(ros,channel) );
            int drawerIdx = TileCalibUtils::getDrawerIdx(ros,drawer);
            float scale = m_tileToolEmscale->channelCalib(drawerIdx, channel, adc, 1.0,
                                                          TileRawChannelUnit::ADCcounts, TileRawChannelUnit::MegaElectronVolts);
            float amp = theTileCell->ene2() / scale;
            float time = theTileCell->time2();
 
            int qbit = (theTileCell->qbit2() & TileCell::MASK_TIME);
            if ((qual2 != 0 || qbit != 0 || amp != 0.0) && (fabs(time) < maxTime && time != 0.0)) {
              time += m_tileToolTiming->getSignalPhase(drawerIdx, channel, adc);
            }
 
            uint32_t tileAdcStatus = m_tileBadChanTool->encodeStatus(m_tileBadChanTool->getAdcStatus(drawerIdx,channel,adc));
            if (badch2) tileAdcStatus += 10;
 
            pmt2RawAmplitude.push_back(DataType(amp));
            pmt2RawTime.push_back(DataType(time));
            pmt2ADCStatus.push_back(DataType( tileAdcStatus ));
            pmt2Number.push_back(DataType(PMT));
            pmt2Pedestal.push_back(DataType(0));  //The is no pedestal in DPD .
          }
        } //don't have TileRawChannel
      } //if (m_doTileCellDetails)
    } // end cell iterator
 
    ATH_MSG_DEBUG( " Total energy in Tile in GeV : " <<  energyAllTile );
 
    if ( !pmt1digit.empty() ) pmt1digit.clear();
    if ( !pmt2digit.empty() ) pmt2digit.clear();
 
    // write values into DataMap
    auto n =  phi.size();
    DataMap["phi"] = std::move(phi);
    DataMap["eta"] = std::move(eta);
    DataMap["sub"] = m_sub;
    DataMap["id"] = std::move(idVec);
    DataMap["energy"] = std::move(energyVec);
 
 
    //BadCells
    if (m_doBadTile==true) {
      DataMap["BadCell"]= std::move(BadCell);
    }
 
    if (m_doTileCellDetails) {
      DataMap["pmt1Energy"] = std::move(pmt1Energy);
      DataMap["pmt1Time"] = std::move(pmt1Time);
      DataMap["pmt1Chi2"] = std::move(pmt1Chi2);
      DataMap["pmt1Gain"] = std::move(pmt1Gain);
 
      DataMap["pmt2Energy"] = std::move(pmt2Energy);
      DataMap["pmt2Time"] = std::move(pmt2Time);
      DataMap["pmt2Chi2"] = std::move(pmt2Chi2);
      DataMap["pmt2Gain"] = std::move(pmt2Gain);
 
      DataMap["pmt1RawAmplitude"] = std::move(pmt1RawAmplitude);
      DataMap["pmt1RawTime"] = std::move(pmt1RawTime);
      DataMap["pmt1ADCStatus"] = std::move(pmt1ADCStatus);
      DataMap["pmt1Number"] = std::move(pmt1Number);
      DataMap["pmt1Pedestal"] = std::move(pmt1Pedestal);
 
      DataMap["pmt2RawAmplitude"] = std::move(pmt2RawAmplitude);
      DataMap["pmt2RawTime"] = std::move(pmt2RawTime);
      DataMap["pmt2ADCStatus"] = std::move(pmt2ADCStatus);
      DataMap["pmt2Number"] = std::move(pmt2Number);
      DataMap["pmt2Pedestal"] = std::move(pmt2Pedestal);
    }
 
    DataMap[adcCounts1Str] = std::move( adcCounts1Vec);
    DataMap[adcCounts2Str] = std::move(adcCounts2Vec);
 
    //Be verbose
    ATH_MSG_DEBUG( dataTypeName() << " retrieved with " << n << " entries" );
 
    //All collections retrieved okay
    return DataMap;
 
  } // getTileData

initialize()

StatusCode JiveXML::CaloTileRetriever::initialize

(

)

Default AthAlgTool methods.

Initialise the ToolSvc.

Definition at line 67 of file CaloTileRetriever.cxx.

                                           {
 
    ATH_MSG_DEBUG( "Initialising Tool" );
    ATH_CHECK( detStore()->retrieve (m_calocell_id, "CaloCell_ID") );
 
    //=== get TileCondToolTiming
    ATH_CHECK( m_tileToolTiming.retrieve() );
 
    //=== get TileCondToolEmscale
    ATH_CHECK( m_tileToolEmscale.retrieve() );
 
    //=== get TileBadChanTool
    ATH_CHECK( m_tileBadChanTool.retrieve() );
    
    ATH_CHECK( m_sgKey.initialize() );
 
    ATH_CHECK( m_sgKeyTileDigits.initialize(m_doTileDigit) );
 
    ATH_CHECK( m_sgKeyTileRawChannel.initialize(m_doTileCellDetails) );
 
    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::CaloTileRetriever::retrieve ( ToolHandle< IFormatTool > & FormatTool )

virtual

Retrieve all the data.

Tile data retrieval from chosen collection.

Implements JiveXML::IDataRetriever.

Definition at line 93 of file CaloTileRetriever.cxx.

                                                                            {
 
    ATH_MSG_DEBUG( "in retrieve()"  );
 
    SG::ReadHandle<CaloCellContainer> cellContainer(m_sgKey);
    if (!cellContainer.isValid()){
        ATH_MSG_WARNING( "Could not retrieve Calorimeter Cells "  );
    }
    else{
      if (m_tile) {
        DataMap data = getCaloTileData(&(*cellContainer));
        ATH_CHECK( FormatTool->AddToEvent("TILE", m_sgKey.key(), &data) );
        ATH_MSG_DEBUG( "Tile retrieved"  );
      }
    }
 
    //Tile 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_calocell_id

const CaloCell_ID* JiveXML::CaloTileRetriever::m_calocell_id

private

Definition at line 77 of file CaloTileRetriever.h.

m_cellEnergyPrec

int JiveXML::CaloTileRetriever::m_cellEnergyPrec

private

Definition at line 83 of file CaloTileRetriever.h.

m_cellThreshold

double JiveXML::CaloTileRetriever::m_cellThreshold

private

Definition at line 82 of file CaloTileRetriever.h.

m_cellTimePrec

int JiveXML::CaloTileRetriever::m_cellTimePrec

private

Definition at line 84 of file CaloTileRetriever.h.

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_doBadTile

bool JiveXML::CaloTileRetriever::m_doBadTile

private

Definition at line 88 of file CaloTileRetriever.h.

m_doTileCellDetails

bool JiveXML::CaloTileRetriever::m_doTileCellDetails

private

Definition at line 87 of file CaloTileRetriever.h.

m_doTileDigit

bool JiveXML::CaloTileRetriever::m_doTileDigit

private

Definition at line 86 of file CaloTileRetriever.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_sgKey

SG::ReadHandleKey<CaloCellContainer> JiveXML::CaloTileRetriever::m_sgKey {this, "StoreGateKey", "AllCalo", "Name of the CaloCellContainer"}

private

Definition at line 79 of file CaloTileRetriever.h.

{this, "StoreGateKey", "AllCalo", "Name of the CaloCellContainer"};

m_sgKeyTileDigits

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

private

Definition at line 80 of file CaloTileRetriever.h.

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

m_sgKeyTileRawChannel

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

private

Definition at line 81 of file CaloTileRetriever.h.

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

m_sub

DataVect JiveXML::CaloTileRetriever::m_sub

private

Definition at line 90 of file CaloTileRetriever.h.

m_tile

bool JiveXML::CaloTileRetriever::m_tile

private

Definition at line 85 of file CaloTileRetriever.h.

m_tileBadChanTool

ToolHandle<ITileBadChanTool> JiveXML::CaloTileRetriever::m_tileBadChanTool

private

Initial value:

{this,
          "TileBadChanTool", "TileBadChanTool", "Tile bad channel tool"}

Definition at line 73 of file CaloTileRetriever.h.

                                                    {this,
          "TileBadChanTool", "TileBadChanTool", "Tile bad channel tool"};

m_tileToolEmscale

ToolHandle<TileCondToolEmscale> JiveXML::CaloTileRetriever::m_tileToolEmscale

private

Initial value:

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

Definition at line 70 of file CaloTileRetriever.h.

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

m_tileToolTiming

ToolHandle<TileCondToolTiming> JiveXML::CaloTileRetriever::m_tileToolTiming

private

Initial value:

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

Definition at line 67 of file CaloTileRetriever.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:

• CaloTileRetriever.h
• CaloTileRetriever.cxx