TileHitVecToCntTool Class Reference

This AlgTool merges TileHits from different AthenaHitVectors and stores the result in a TileHitContainer. More...

#include <TileHitVecToCntTool.h>

Inheritance diagram for TileHitVecToCntTool:

Public Member Functions
	TileHitVecToCntTool (const std::string &type, const std::string &name, const IInterface *parent)
	Constructor.
StatusCode	initialize () override final
virtual StatusCode	prepareEvent (const EventContext &ctx, unsigned int) override final
virtual StatusCode	mergeEvent (const EventContext &ctx) override final
virtual StatusCode	processBunchXing (int bunchXing, SubEventIterator bSubEvents, SubEventIterator eSubEvents) override final
virtual StatusCode	processAllSubEvents (const EventContext &ctx) override final
virtual StatusCode	processAllSubEvents (const EventContext &ctx) const
StatusCode	finalize () override final

Private Types
enum	CELL_TOWER { E1_TOWER = 10 }

Private Member Functions
StatusCode	createContainers ()
void	processHitVectorForOverlay (const TileHitVector *inputHits, std::unique_ptr< TileHitNonConstContainer > &hits, int &nHit, double &eHitTot) const
void	processHitVectorForPileUp (const TileHitVector *inputHits, double SubEvtTimOffset, std::vector< std::unique_ptr< TileHit > > &allHits, std::vector< std::unique_ptr< TileHit > > &allHits_DigiHSTruth, int &nHit, double &eHitTot, bool isSignal=false) const
void	processHitVectorWithoutPileUp (const TileHitVector *inputHits, int &nHit, double &eHitTot, TileHitNonConstContainer *hitCont, CLHEP::HepRandomEngine *engine) const
double	applyPhotoStatistics (double energy, Identifier pmt_id, CLHEP::HepRandomEngine *engine, const TileSamplingFraction *samplingFraction, int drawerIdx) const
void	findAndMergeE1 (TileHitCollection *coll, int frag_id, TileHitNonConstContainer *hitCont) const
void	findAndMergeMBTS (TileHitCollection *coll, int frag_id, TileHitNonConstContainer *hitCont) const
void	findAndMergeMultipleHitsInChannel (std::unique_ptr< TileHitNonConstContainer > &hitCont) const
void	mergeExtraHitToChannelHit (TileHit *extraHit, TileHit *channelHit) const
void	putAllHitsInContainer (std::vector< std::unique_ptr< TileHit > > &allHits, std::vector< std::unique_ptr< TileHit > > &allHits_DigiHSTruth, std::unique_ptr< TileHitNonConstContainer > &hits, std::unique_ptr< TileHitNonConstContainer > &hits_DigiHSTruth, SG::OwnershipPolicy ownPolicy) const
StatusCode	commitContainers (const EventContext &ctx, std::unique_ptr< TileHitNonConstContainer > &hits, std::unique_ptr< TileHitNonConstContainer > &hits_DigiHSTruth, SG::OwnershipPolicy ownPolicy) const
void	prepareAllHits (std::vector< std::unique_ptr< TileHit > > &allHits) const
int	mbts_index (int side, int phi, int eta) const
int	e4pr_index (int phi) const

Private Attributes
Gaudi::Property< bool >	m_onlyUseContainerName {this, "OnlyUseContainerName", true, "Don't use the ReadHandleKey directly. Just extract the container name from it."}
StringArrayProperty	m_inputKeys
	vector with the names of TileHitVectors to use
SG::ReadHandleKeyArray< TileHitVector >	m_hitVectorKeys {this, "TileHitVectorKeys", {}, "Do not set manually!"}
std::vector< std::string >	m_hitVectorNames {}
SG::WriteHandleKey< TileHitContainer >	m_hitContainerKey
SG::WriteHandleKey< TileHitContainer >	m_hitContainer_DigiHSTruthKey
SG::ReadCondHandleKey< TileSamplingFraction >	m_samplingFractionKey
	Name of TileSamplingFraction in condition store.
bool	m_run2 {false}
	if true => RUN2 geometry with E4' and merged E1
bool	m_run2plus {false}
	if true => RUN2+ geometry with merged E1 (and E4' in RUN2)
Gaudi::Property< bool >	m_pileUp
	if true => pileup mode is activated
Gaudi::Property< double >	m_deltaT
	minimal time granularity for TileHit
Gaudi::Property< int >	m_timeFlag
	special options to deal with times of hits for cosmics and TB
Gaudi::Property< double >	m_triggerTime
	fixed trigger time value (default=0)
Gaudi::Property< double >	m_maxHitTime
	all sub-hits with time above m_maxHitTime will be ignored
Gaudi::Property< double >	m_photoStatisticsWindow
	sum up energy in [-m_photoStatWindow,+m_photoStatWindow] and use it for photostatistics
Gaudi::Property< int >	m_photoElectronStatistics
	photoelectron statistics type: 0 - Poisson, 1 - "new" Poisson + Gauss, 2 - Poisson->Gauss
Gaudi::Property< bool >	m_skipNoHit
	if true => skip events with no Tile hits
Gaudi::Property< bool >	m_rndmEvtOverlay
	If true => overlay with random event (zero-luminosity pile-up)
Gaudi::Property< bool >	m_useTriggerTime
	if true => take trigger time from external tool or from m_triggerTime
Gaudi::Property< bool >	m_doDigiTruth
Gaudi::Property< bool >	m_usePhotoStatistics
Gaudi::Property< bool >	m_mergeMultipleHitsInChannel
SG::ReadHandleKey< CosTrigTime >	m_triggerTimeKey {this,"CosTimeKey", "", "To take the trigger time from"}
ServiceHandle< PileUpMergeSvc >	m_mergeSvc {this, "PileUpMergeSvc", "PileUpMergeSvc", ""}
const TileID *	m_tileID {nullptr}
	Pointer to TileID helper.
const TileTBID *	m_tileTBID {nullptr}
	Pointer to TileID helper.
const TileHWID *	m_tileHWID {nullptr}
	Pointer to TileID helper.
ServiceHandle< IAthRNGSvc >	m_rndmSvc {this, "RndmSvc", "AthRNGSvc", ""}
	Random number generator engine to use.
Gaudi::Property< std::string >	m_randomStreamName {this, "RandomStreamName", "Tile_HitVecToCnt", ""}
	Random Stream Name.
std::vector< std::unique_ptr< TileHit > >	m_allHits
	vector for all TileHits
std::vector< std::unique_ptr< TileHit > >	m_allHits_DigiHSTruth
	vector for all TileHits
std::unique_ptr< TileHitNonConstContainer >	m_hits {}
	pointer to hits container
std::unique_ptr< TileHitNonConstContainer >	m_hits_DigiHSTruth {}
	pointer to hits container
int	m_mbtsOffset {0}
ServiceHandle< TileCablingSvc >	m_cablingSvc {this, "TileCablingSvc", "TileCablingSvc", ""}
const TileCablingService *	m_cabling {}
TileFragHash	m_fragHashFunc
std::vector< bool >	m_E1merged
std::vector< bool >	m_MBTSmerged

Static Private Attributes
static const int	N_SIDE = 2
static const int	N_PHI = 8
static const int	N_ETA = 2
static const int	N_MBTS_CELLS = N_SIDE * N_PHI * N_ETA
static const int	E4_SIDE = -1
static const int	E4_ETA = 2
static const int	E4_N_PHI = 4
static const int	N_E4PRIME_CELLS = E4_N_PHI

structors and AlgTool implementation
virtual bool	toProcess (int bunchXing) const override
	the method this base class helps implementing
virtual bool	filterPassed () const override
	dummy implementation of passing filter
virtual void	resetFilter () override
	dummy implementation of filter reset
Gaudi::Property< int >	m_firstXing
Gaudi::Property< int >	m_lastXing
Gaudi::Property< int >	m_vetoPileUpTruthLinks
bool	m_filterPassed {true}

Detailed Description

This AlgTool merges TileHits from different AthenaHitVectors and stores the result in a TileHitContainer.

TileHitVecToCntTool copies all TileHits from TileHitVector (AthenaHitsVector) to TileHitContainer (identifiable container) without any corrections If pileup option is set, all hits are merged, if several hits have the same ID, energy and time from all of them is stored in vectors inside single TileHit

Definition at line 85 of file TileHitVecToCntTool.h.

Member Enumeration Documentation

CELL_TOWER

enum TileHitVecToCntTool::CELL_TOWER

private

Enumerator
E1_TOWER

Definition at line 206 of file TileHitVecToCntTool.h.

{E1_TOWER = 10};

Constructor & Destructor Documentation

TileHitVecToCntTool()

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

Constructor.

Definition at line 46 of file TileHitVecToCntTool.cxx.

    : PileUpToolBase(type,name,parent)
{
}

Member Function Documentation

applyPhotoStatistics()

double TileHitVecToCntTool::applyPhotoStatistics ( double energy, Identifier pmt_id, CLHEP::HepRandomEngine * engine, const TileSamplingFraction * samplingFraction, int drawerIdx ) const

private

Definition at line 950 of file TileHitVecToCntTool.cxx.

                                                                                                                    {
 
  int channel = m_tileHWID->channel(m_cabling->s2h_channel_id(pmt_id));
  // take number of photoelectrons per GeV divide by 1000 to go to MeV
  // and multiply by inverted sampling fraction (about 36, depends on G4 version, sampling and eta)
  // to get number of photoelectrons per 1 MeV energy in scintillator
  float nPhotoElectrons = samplingFraction->getNumberOfPhotoElectrons(drawerIdx, channel)
    / (Gaudi::Units::GeV / Gaudi::Units::MeV) * samplingFraction->getSamplingFraction(drawerIdx, channel);
 
  nPhotoElectrons = std::round(nPhotoElectrons * 1000) / 1000;
 
  double pe = energy * nPhotoElectrons;
  double pe_scale = 1., RndmPois = 1.;
 
  switch (m_photoElectronStatistics) {
    case 2:
      if (pe > 20.0) {
        RndmPois = std::max(0.0, RandGaussQ::shoot(engine, pe, sqrt(pe))); // FIXME CLHEP::RandGaussZiggurat is faster and more accurate.
        pe_scale = RndmPois / pe;
      } else { // pe<=20
 
        if (pe > 0.) {
          double singleMEAN = 1.0;  //Parameterization of monoelectron spectra
          double singleSIGMA = 1.0;
          RndmPois = RandPoissonT::shoot(engine, pe);
 
          if (RndmPois > 0) {
            pe_scale = 0;
            for (int i = 0; i < RndmPois; i++)
              pe_scale += 1 / (1.08332) * std::max(0., RandGaussQ::shoot(engine, singleMEAN, singleSIGMA)); // FIXME CLHEP::RandGaussZiggurat is faster and more accurate.
 
            pe_scale /= RndmPois;
          } else
            pe_scale = 0;  //RndmPois==0
        }
      }
      break;
 
    case 0:
      if (pe > 0.0) {
        RndmPois = RandPoissonT::shoot(engine, pe);
        pe_scale = RndmPois / pe;
      }
      break;
 
    case 1:
      if (pe > 0.0) {
        if (pe > 10.0) {
          RndmPois = std::max(0.0, RandGaussQ::shoot(engine, pe, sqrt(pe))); // FIXME CLHEP::RandGaussZiggurat is faster and more accurate.
        } else {
          int nn = std::max(10, (int) (pe * 10.0));
          double * ProbFunc = new double[nn];
          ProbFunc[0] = exp(-pe);
          for (int i = 1; i < nn; ++i) {
            ProbFunc[i] = ProbFunc[i - 1] * pe / i;
          }
          RandGeneral* RandG = new RandGeneral(ProbFunc, nn, 0);
          RndmPois = RandG->shoot(engine) * nn;
          //here RndmPois is continuously distributed random value obtained from Poisson
          //distribution by approximation.
          delete RandG;
          delete[] ProbFunc;
        }
        pe_scale = RndmPois / pe;
      }
      break;
  } //end switch(m_PhElStat)
 
  ATH_MSG_VERBOSE( "PhotoElec: id=" << m_tileID->to_string(pmt_id,-1)
                  << " totEne=" << energy
                  << ", numPhElec=" << nPhotoElectrons
                  << ", pe=" << pe
                  << ", rndmPoisson=" << RndmPois
                  << ", pe_scale=" << pe_scale);
 
  return pe_scale;
}

commitContainers()

StatusCode TileHitVecToCntTool::commitContainers ( const EventContext & ctx, std::unique_ptr< TileHitNonConstContainer > & hits, std::unique_ptr< TileHitNonConstContainer > & hits_DigiHSTruth, SG::OwnershipPolicy ownPolicy ) const

private

Definition at line 798 of file TileHitVecToCntTool.cxx.

                                                                                    {
 
  ATH_MSG_DEBUG("Entering commitContainers");
 
  if (!m_pileUp) {
    if (m_mergeMultipleHitsInChannel) {
      findAndMergeMultipleHitsInChannel(hits);
      if (m_doDigiTruth) {
        findAndMergeMultipleHitsInChannel(hits_DigiHSTruth);
      }
    }
  }
 
  if (m_run2plus) {
    // Merge MBTS and E1 where it is needed.
 
    for (std::unique_ptr<TileHitCollection>& coll : *hits ) {
      int frag_id = coll->identify();
      IdentifierHash frag_hash = m_fragHashFunc(frag_id);
      if (m_E1merged[frag_hash])
        findAndMergeE1(coll.get(), frag_id, hits.get());
      else if (m_MBTSmerged[frag_hash]) findAndMergeMBTS(coll.get(), frag_id, hits.get());
    }
    if(m_doDigiTruth){
      TileHitNonConstContainer::iterator collIt = hits_DigiHSTruth->begin();
      TileHitNonConstContainer::iterator endcollIt = hits_DigiHSTruth->end();
 
      for (; collIt != endcollIt; ++collIt) {
        int frag_id = (*collIt)->identify();
        IdentifierHash frag_hash = m_fragHashFunc(frag_id);
        if (m_E1merged[frag_hash]) findAndMergeE1((*collIt).get(), frag_id, hits_DigiHSTruth.get());
        else if (m_MBTSmerged[frag_hash]) findAndMergeMBTS((*collIt).get(), frag_id, hits_DigiHSTruth.get());
      }
    }
  }
 
  //photoelectron statistics.
  //loop over all hits in TileHitContainer and take energy deposited in certain period of time
  //std::vector<std::string>::const_iterator hitVecNamesEnd = m_hitVectorNames.end();
 
  ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this, m_randomStreamName);
  CLHEP::HepRandomEngine * engine = rngWrapper->getEngine(ctx);
 
  SG::ReadCondHandle<TileSamplingFraction> samplingFraction(m_samplingFractionKey, ctx);
  ATH_CHECK( samplingFraction.isValid() );
 
  TileHitNonConstContainer::iterator collIt_DigiHSTruth; 
  TileHitNonConstContainer::iterator endColl_DigiHSTruth;
  if(m_doDigiTruth) {
    collIt_DigiHSTruth = hits_DigiHSTruth->begin();
    endColl_DigiHSTruth = hits_DigiHSTruth->end();
  }
 
  for (std::unique_ptr<TileHitCollection>& coll : *hits ) {
    TileHitCollection* coll_DigiHSTruth;
    TileHitCollection::iterator hitItr_DigiHSTruth;
    TileHitCollection::iterator hitEnd_DigiHSTruth;
    if(m_doDigiTruth) {
      coll_DigiHSTruth = (*collIt_DigiHSTruth).get();
      hitItr_DigiHSTruth = coll_DigiHSTruth->begin();
      hitEnd_DigiHSTruth = coll_DigiHSTruth->end();
    }
 
    HWIdentifier drawer_id = m_tileHWID->drawer_id(coll->identify());
    int ros = m_tileHWID->ros(drawer_id);
    int drawer = m_tileHWID->drawer(drawer_id);
    int drawerIdx = TileCalibUtils::getDrawerIdx(ros, drawer);
 
    for (TileHit* pHit : *coll) {
      double ehit = 0.0;
      int hitsize = pHit->size();
      for (int i = 0; i < hitsize; ++i) {
        double thit = pHit->time(i);
        if (fabs(thit) < m_photoStatisticsWindow) ehit += pHit->energy(i);
      }
 
      Identifier pmt_id = pHit->pmt_ID();
      //HWIdentifier channel_id = (*hitItr)->pmt_HWID();
      // for gap/crack scintillators
      if (m_tileID->sample(pmt_id) == 3) {
        pmt_id = m_tileID->pmt_id(m_tileID->cell_id(pmt_id), 0);
        //channel_id = m_cabling->s2h_channel_id(pmt_id);
      }
 
      double scaleFactor = 1.0;
      if (m_usePhotoStatistics) {
        scaleFactor = applyPhotoStatistics(ehit, pmt_id, engine, *samplingFraction, drawerIdx);
        pHit->scale(scaleFactor);
      }
 
      if(m_doDigiTruth){
        TileHit *pHit_DigiHSTruth = (*hitItr_DigiHSTruth);
        pHit_DigiHSTruth->scale(scaleFactor);
 
        ++hitItr_DigiHSTruth;
      }
    }
 
      if(m_doDigiTruth) ++collIt_DigiHSTruth;
  }
 
 
  /* Register the set of TileHits to the event store. */
  auto hitCont = std::make_unique<TileHitContainer>(false, ownPolicy);
  size_t hashId = 0;
  for (std::unique_ptr<TileHitCollection>& coll : *hits ) {
    CHECK(hitCont->addCollection (coll.release(), hashId++));
  }
 
  SG::WriteHandle<TileHitContainer> hitContainer(m_hitContainerKey, ctx);
  ATH_CHECK( hitContainer.record(std::move(hitCont)) );
 
  ATH_MSG_DEBUG("TileHit container registered to the TES with name" << m_hitContainerKey.key());
 
  if(m_doDigiTruth){
    auto hitCont_DigiHSTruth = std::make_unique<TileHitContainer>(false, ownPolicy);
    size_t hashId_DigiHSTruth = 0;
    for (std::unique_ptr<TileHitCollection>& coll : *hits_DigiHSTruth ) {
      ATH_CHECK(hitCont_DigiHSTruth->addCollection (coll.release(), hashId_DigiHSTruth++));
    }
 
    SG::WriteHandle<TileHitContainer> hitContainer_DigiHSTruth(m_hitContainer_DigiHSTruthKey, ctx);
    ATH_CHECK( hitContainer_DigiHSTruth.record(std::move(hitCont_DigiHSTruth)) );
  }
 
  ATH_MSG_DEBUG("Exiting mergeEvent in TileHitVecToCntTool");
  return StatusCode::SUCCESS;
}

createContainers()

StatusCode TileHitVecToCntTool::createContainers ( )

private

Definition at line 180 of file TileHitVecToCntTool.cxx.

                                                 {
 
  ATH_MSG_VERBOSE("TileHitVecToCntTool createContainers started");
 
  if (m_pileUp) {
    m_hits = std::make_unique<TileHitNonConstContainer>(SG::VIEW_ELEMENTS);
    if(m_doDigiTruth) m_hits_DigiHSTruth = std::make_unique<TileHitNonConstContainer>(SG::VIEW_ELEMENTS);
 
    if (m_allHits.empty()) {
 
      prepareAllHits(m_allHits);
      if (m_doDigiTruth) prepareAllHits(m_allHits_DigiHSTruth);
 
    } else {
      for (std::unique_ptr<TileHit>& hit : m_allHits) {
        hit->setZero();
      }
 
      if(m_doDigiTruth){
        for (std::unique_ptr<TileHit>& hit : m_allHits_DigiHSTruth) {
          hit->setZero();
        }
      }
    }
  } else {
    m_hits = std::make_unique<TileHitNonConstContainer>(SG::OWN_ELEMENTS);
    if(m_doDigiTruth) m_hits_DigiHSTruth = std::make_unique<TileHitNonConstContainer>(SG::OWN_ELEMENTS);
 
  }
 
  ATH_MSG_VERBOSE("TileHitVecToCntTool createContainers finished");
 
  return StatusCode::SUCCESS;
 
}

e4pr_index()

int TileHitVecToCntTool::e4pr_index ( int phi ) const

inlineprivate

Definition at line 197 of file TileHitVecToCntTool.h.

                                       {
    return  phi + N_MBTS_CELLS + m_mbtsOffset;
  }

filterPassed()

virtual bool PileUpToolBase::filterPassed ( ) const

inlineoverridevirtualinherited

dummy implementation of passing filter

Definition at line 49 of file PileUpToolBase.h.

{ return m_filterPassed; }

finalize()

StatusCode TileHitVecToCntTool::finalize ( )

finaloverride

Definition at line 940 of file TileHitVecToCntTool.cxx.

                                         {
 
  ATH_MSG_DEBUG("Finalizing TileHitVecToCntTool");
 
  ATH_MSG_DEBUG("TileHitVecToCntTool finalized");
 
  return StatusCode::SUCCESS;
 
}

findAndMergeE1()

void TileHitVecToCntTool::findAndMergeE1 ( TileHitCollection * coll, int frag_id, TileHitNonConstContainer * hitCont ) const

private

Definition at line 1030 of file TileHitVecToCntTool.cxx.

                                                                                                                      {
  int module = frag_id & 0x3F;
 
  TileHitCollection::iterator hitIt = coll->begin();
  TileHitCollection::iterator endHitIt = coll->end();
 
  TileHitCollection::iterator fromHitIt = coll->end();
  TileHit* toHit(0);
 
  for (; hitIt != endHitIt; ++hitIt) {
    Identifier pmt_id = (*hitIt)->pmt_ID();
    if (m_tileID->tower(pmt_id) == E1_TOWER && m_tileID->sample(pmt_id) == TileID::SAMP_E) {
      if (module == m_tileID->module(pmt_id)) {
        toHit = *hitIt;
      } else {
        fromHitIt = hitIt; // need iterator to delete this hit later.
      }
    }
  }
  
  if (fromHitIt != coll->end()) {
    ATH_MSG_VERBOSE("Found TileHit (E1 cell) for merging [" << m_tileID->to_string((*fromHitIt)->pmt_ID(), -1) 
            << "] in module: " << module);
    bool isToHitNew = false;
    if (toHit == 0) {
      int side = m_tileID->side((*fromHitIt)->pmt_ID());
      Identifier to_pmt_id = m_tileID->pmt_id(TileID::GAPDET, side, module, E1_TOWER, TileID::SAMP_E, 0);
      toHit = new TileHit(to_pmt_id);
      isToHitNew = true;
      ATH_MSG_VERBOSE("New TileHit (E1 cell) for merging added Id: " << m_tileID->to_string(toHit->pmt_ID(), -1) );
    } else {
      ATH_MSG_VERBOSE("Found TileHit (E1 cell) for merging Id: " << m_tileID->to_string(toHit->pmt_ID(), -1) );
    }
 
    ATH_MSG_DEBUG( "TileHit (E1 cell) Id: " << m_tileID->to_string((*fromHitIt)->pmt_ID(), -1) 
           << " will be merged to " << m_tileID->to_string(toHit->pmt_ID(), -1) );
    
    if (msgLvl(MSG::VERBOSE)) {
      msg(MSG::VERBOSE) << "Before merging (E1 cell) => " << (std::string) (**fromHitIt) << endmsg;
      msg(MSG::VERBOSE) << "Before merging (E1 cell) => " << (std::string) (*toHit) << endmsg;
    }
 
    toHit->add(*fromHitIt, 0.1);
 
    if (msgLvl(MSG::VERBOSE)) {
      msg(MSG::VERBOSE) << "After merging (E1 cell) => " << (std::string) (*toHit) << endmsg;
      msg(MSG::VERBOSE) << "TileHit to be deleted Id (E1 cell): " << m_tileID->to_string((*fromHitIt)->pmt_ID(), -1) << endmsg;
    }
    
    coll->erase(fromHitIt);
 
    if (isToHitNew) {
      hitCont->push_back(toHit);
    }
  }
}

findAndMergeMBTS()

void TileHitVecToCntTool::findAndMergeMBTS ( TileHitCollection * coll, int frag_id, TileHitNonConstContainer * hitCont ) const

private

Definition at line 1088 of file TileHitVecToCntTool.cxx.

                                                                                                                        {
  int module = frag_id & 0x3F;
 
  TileHitCollection::iterator hitIt = coll->begin();
  TileHitCollection::iterator endHitIt = coll->end();
 
  TileHitCollection::iterator fromHitIt = coll->end();
  TileHit* toHit(0);
 
  for (; hitIt != endHitIt; ++hitIt) {
    Identifier pmt_id = (*hitIt)->pmt_ID();
    if (m_tileTBID->is_tiletb(pmt_id)) {
      if (m_tileTBID->phi(pmt_id) % 2 == 0) {
        toHit = *hitIt;
      } else {
        fromHitIt = hitIt; // need iterator to delete this hit later.
      }
    }
  }
  
  if (fromHitIt != coll->end()) {
    ATH_MSG_VERBOSE("Found TileHit (MBTS) for merging [" << m_tileTBID->to_string((*fromHitIt)->pmt_ID(), 0) 
            << "] in module: " << module);
    bool isToHitNew = false;
    if (toHit == 0) {
      int side = m_tileTBID->side((*fromHitIt)->pmt_ID());
      int phi = m_tileTBID->phi((*fromHitIt)->pmt_ID()) - 1;
      Identifier to_pmt_id = m_tileTBID->channel_id(side, phi, 1);
      toHit = new TileHit(to_pmt_id);
      isToHitNew = true;
      ATH_MSG_VERBOSE("New TileHit (MBTS) for merging added Id: " << m_tileTBID->to_string(toHit->pmt_ID(), 0) );
    } else {
      ATH_MSG_VERBOSE("Found TileHit (MBTS) for merging Id: " << m_tileTBID->to_string(toHit->pmt_ID(), 0) );
    }
    
    ATH_MSG_DEBUG( "TileHit (MBTS) Id: " << m_tileTBID->to_string((*fromHitIt)->pmt_ID(), 0) 
           << " will be merged to " << m_tileTBID->to_string(toHit->pmt_ID(), 0) );
 
    if (msgLvl(MSG::VERBOSE)) {
      msg(MSG::VERBOSE) << "Before merging (MBTS) => " << (std::string) (**fromHitIt) << endmsg;
      msg(MSG::VERBOSE) << "Before merging (MBTS) => " <<  (std::string) (*toHit) << endmsg;
    }
 
    toHit->add(*fromHitIt, 0.1);
 
    if (msgLvl(MSG::VERBOSE)) {
      msg(MSG::VERBOSE) << "After merging (MBTS) => " << (std::string) (*toHit) << endmsg;
      msg(MSG::VERBOSE) << "TileHit to be deleted Id (MBTS): " 
            << m_tileTBID->to_string((*fromHitIt)->pmt_ID(), 0) << endmsg;
    }
    
    coll->erase(fromHitIt);
 
    if (isToHitNew) {
      hitCont->push_back(toHit);
    }
  }
}

findAndMergeMultipleHitsInChannel()

void TileHitVecToCntTool::findAndMergeMultipleHitsInChannel ( std::unique_ptr< TileHitNonConstContainer > & hitCont ) const

private

Definition at line 1147 of file TileHitVecToCntTool.cxx.

                                                                                                                  {
  for (std::unique_ptr<TileHitCollection>& coll : *hitCont) {
 
    int frag_id = coll->identify();
    int module = frag_id & 0x3F;
    IdentifierHash frag_hash = m_fragHashFunc(frag_id);
    std::vector<TileHit*> hits(48, nullptr);
    std::vector<std::unique_ptr<TileHit>> otherModuleHits;
    coll->erase(std::remove_if(coll->begin(), coll->end(),
                               [this, &hits, &otherModuleHits, module, frag_hash] (TileHit* hit) {
                                 Identifier pmt_id = hit->pmt_ID();
                                 int channel = m_tileHWID->channel(hit->pmt_HWID());
                                 TileHit* channelHit = hits[channel];
                                 if (channelHit) {
                                   mergeExtraHitToChannelHit(hit, channelHit);
                                   return true;
                                 } else if (m_run2plus // Special case for merged E1 and MBTS in Run 2+ geometries, which will be merged finally correctly later
                                            && ((m_E1merged[frag_hash] && m_tileID->module(pmt_id) != module
                                                 && m_tileID->tower(pmt_id) == E1_TOWER && m_tileID->sample(pmt_id) == TileID::SAMP_E)  // Merged E1 in Run 2+ from other module
                                                || (m_MBTSmerged[frag_hash] && m_tileTBID->is_tiletb(pmt_id) && (m_tileTBID->phi(pmt_id) % 2 == 1)))) { // Merged MBTS in Run 2+ from other module
                                   otherModuleHits.push_back(std::make_unique<TileHit>(*hit));
                                   return true;
                                 } else {
                                   hits[channel] = hit;
                                   return false;
                                 }}),
                coll->end());
 
    for (std::unique_ptr<TileHit>& hit : otherModuleHits) {
      int channel = m_tileHWID->channel(hit->pmt_HWID());
      TileHit* channelHit = hits[channel];
      if (channelHit) {
        mergeExtraHitToChannelHit(hit.get(), channelHit);
      } else {
        hits[channel] = hit.get();
        coll->push_back(std::move(hit));
      }
    }
  }
}

initialize()

StatusCode TileHitVecToCntTool::initialize ( )

finaloverridevirtual

Reimplemented from PileUpToolBase.

Definition at line 53 of file TileHitVecToCntTool.cxx.

                                           {
 
  ATH_MSG_DEBUG("TileHitVecToCntTool initialization started");
 
  ATH_CHECK(m_rndmSvc.retrieve());
 
  // retrieve TileID helper from det store
  ATH_CHECK(detStore()->retrieve(m_tileID));
 
  ATH_CHECK(detStore()->retrieve(m_tileTBID));
 
  ATH_CHECK(detStore()->retrieve(m_tileHWID));
 
  ATH_CHECK( m_samplingFractionKey.initialize() );
 
  ATH_CHECK(m_cablingSvc.retrieve());
  m_cabling = m_cablingSvc->cablingService();
 
  m_run2 = m_cabling->isRun2Cabling();
  m_run2plus = m_cabling->isRun2PlusCabling();
 
  if (!m_usePhotoStatistics) {
    ATH_MSG_INFO("No photostatistics effect will be simulated");
  }
 
  if (m_rndmEvtOverlay) {
    m_pileUp = false;
    ATH_MSG_INFO("Zero-luminosity pile-up selected");
    ATH_MSG_INFO("Taking hits from original event only");
  }
 
  if (m_pileUp || m_rndmEvtOverlay) {
    ATH_MSG_INFO("take events from PileUp service");
 
    if (m_onlyUseContainerName) {
      ATH_CHECK(m_mergeSvc.retrieve());
    }
 
    if (m_useTriggerTime) {
      ATH_MSG_INFO(" In case of pileup, the trigger time subtraction is done in PileUpSvc");
      ATH_MSG_INFO("  => TileHitVecToCnt will not apply Trigger Time ");
      m_useTriggerTime = false;
    }
    m_timeFlag = 0;
 
    if (m_pileUp) {
      m_mbtsOffset = m_tileID->pmt_hash_max();
    }
 
  } else {
 
    ATH_MSG_INFO("no pile up");
 
    if (m_useTriggerTime) {
 
      m_timeFlag = 2;
 
      if (!m_triggerTimeKey.empty()) {
        ATH_MSG_INFO( "Trigger time is taken from external ojbect '" << m_triggerTimeKey.key()
                     << "'; therefore set HitTimeFlag to 2");
        ATH_CHECK(m_triggerTimeKey.initialize());
      }
    }
 
    switch (m_timeFlag) {
      case 2:
        if (m_triggerTimeKey.empty()) {
          if (m_triggerTime > 0.0) {
            m_useTriggerTime = true;
            ATH_MSG_INFO("Fixed trigger time of " << m_triggerTime << " ns will be used");
          } else if (m_triggerTime < 0.0) {
            m_useTriggerTime = false;
            ATH_MSG_INFO( "Minimal hit time will be used as trigger time"
                         << " with random additional shift between 0 and " << -m_triggerTime << " ns");
          } else {
            m_useTriggerTime = false;
            ATH_MSG_INFO("Average time will be calculated in every event");
          }
        }
        break;
      case 1:
        ATH_MSG_INFO("Time of all hits will be reset to zero");
        break;
      default:
        ATH_MSG_INFO("Time of all hits will be preserved during copy");
        m_timeFlag = 0;
        break;
    }
  }
 
  if (m_run2plus) {
    m_fragHashFunc.initialize(m_tileHWID);
 
    m_E1merged.resize(m_tileHWID->drawer_hash_max());
    m_MBTSmerged.resize(m_tileHWID->drawer_hash_max());
 
    for (int ros = 3; ros < 5; ++ros) {
      for (int drawer = 0; drawer < 64; ++drawer) {
        int frag_id = m_tileHWID->frag(ros, drawer);
        IdentifierHash frag_hash = m_fragHashFunc(frag_id);
        m_E1merged[frag_hash] = (m_cabling->E1_merged_with_run2plus(ros, drawer) != 0);
        m_MBTSmerged[frag_hash] = (m_cabling->is_MBTS_merged_run2plus(drawer));
      }
    }
    ATH_MSG_INFO("Number of E1 cell to be merged: " << std::count (m_E1merged.begin(), m_E1merged.end(), true));
    ATH_MSG_INFO("Number of MBTS cell to be merged: " << std::count (m_MBTSmerged.begin(), m_MBTSmerged.end(), true));
  }
 
  if (m_onlyUseContainerName) {
    m_hitVectorNames = m_inputKeys.value();
  }
  else {
    ATH_CHECK(m_hitVectorKeys.assign(m_inputKeys.value()));
  }
  ATH_MSG_DEBUG("Input objects in these containers : '" << m_hitVectorNames << "'");
 
  // Initialize ReadHandleKey
  ATH_CHECK(m_hitVectorKeys.initialize(!m_onlyUseContainerName && !m_hitVectorKeys.empty() ));
 
  ATH_CHECK( m_hitContainerKey.initialize() );
  ATH_CHECK( m_hitContainer_DigiHSTruthKey.initialize(m_doDigiTruth) );
 
  ATH_MSG_DEBUG("TileHitVecToCntTool initialization completed");
 
  return StatusCode::SUCCESS;
}

mbts_index()

int TileHitVecToCntTool::mbts_index ( int side, int phi, int eta ) const

inlineprivate

Definition at line 190 of file TileHitVecToCntTool.h.

                                                          {
    return (side * N_PHI + phi) * N_ETA + eta + m_mbtsOffset;
  }

mergeEvent()

StatusCode TileHitVecToCntTool::mergeEvent ( const EventContext & ctx )

finaloverridevirtual

Definition at line 931 of file TileHitVecToCntTool.cxx.

                                                                  {
 SG::OwnershipPolicy ownPolicy = SG::OWN_ELEMENTS;
  if (m_pileUp) {
    ownPolicy = SG::VIEW_ELEMENTS;
    putAllHitsInContainer(m_allHits, m_allHits_DigiHSTruth, m_hits, m_hits_DigiHSTruth, ownPolicy);
  }
  return commitContainers(ctx, m_hits, m_hits_DigiHSTruth, ownPolicy);
}

mergeExtraHitToChannelHit()

void TileHitVecToCntTool::mergeExtraHitToChannelHit ( TileHit * extraHit, TileHit * channelHit ) const

private

Definition at line 1188 of file TileHitVecToCntTool.cxx.

                                                                                                {
 
  ATH_MSG_DEBUG("Found extra hit for channel Id: "
                << m_tileID->to_string(extraHit->pmt_ID(), -1) << ", will be merged to "
                << m_tileID->to_string(channelHit->pmt_ID(), -1));
  ATH_MSG_VERBOSE("Before merging => " << (std::string) (*extraHit));
  ATH_MSG_VERBOSE("Before merging => " << (std::string) (*channelHit));
 
  channelHit->add(extraHit, 0.1);
 
  ATH_MSG_VERBOSE("After merging => " << (std::string) (*channelHit));
}

prepareAllHits()

void TileHitVecToCntTool::prepareAllHits ( std::vector< std::unique_ptr< TileHit > > & allHits ) const

private

Definition at line 1202 of file TileHitVecToCntTool.cxx.

                                                                                         {
 
  int nHits = m_mbtsOffset + N_MBTS_CELLS;
  if (m_run2) nHits += N_E4PRIME_CELLS;
  allHits.reserve(nHits);
 
  Identifier hit_id;
  IdContext pmt_context = m_tileID->pmt_context();
  for (int i = 0; i < m_mbtsOffset; ++i) {
    m_tileID->get_id((IdentifierHash) i, hit_id, &pmt_context);
    allHits.emplace_back(std::make_unique<TileHit>(hit_id, 0., 0.));
    allHits.back()->reserve(71);  // reserve max possible size for pileup
  }
 
  allHits.resize(allHits.size() + N_MBTS_CELLS);
  for (int side = 0; side < N_SIDE; ++side) {
    for (int phi = 0; phi < N_PHI; ++phi) {
      for (int eta = 0; eta < N_ETA; ++eta) {
        int mbtsIndex = mbts_index(side, phi, eta);
        hit_id = m_tileTBID->channel_id((side > 0) ? 1 : -1, phi, eta);
        allHits[mbtsIndex] = std::make_unique<TileHit>(hit_id, 0., 0.);
        allHits[mbtsIndex]->reserve(71); // reserve max possible size for pileup
      }
    }
  }
  if (m_run2) {
    allHits.resize(allHits.size() + N_E4PRIME_CELLS);
    for (int phi = 0; phi < E4_N_PHI; ++phi) {
      int e4prIndex = e4pr_index(phi);
      hit_id = m_tileTBID->channel_id(E4_SIDE, phi, E4_ETA);
      allHits[e4prIndex] = std::make_unique<TileHit>(hit_id, 0., 0.);
      allHits[e4prIndex]->reserve(71); // reserve max possible size for pileup
    }
  }
}

prepareEvent()

StatusCode TileHitVecToCntTool::prepareEvent ( const EventContext & ctx, unsigned int  )

finaloverridevirtual

Definition at line 216 of file TileHitVecToCntTool.cxx.

                                                                                    {
 
  ATH_MSG_DEBUG("TileHitVecToCntTool prepareEvent initialization started");
 
  CHECK(this->createContainers());
 
  ATH_MSG_DEBUG("TileHitVecToCntTool prepareEvent finished");
 
  ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this, m_randomStreamName);
  rngWrapper->setSeed( m_randomStreamName, ctx );
 
  return StatusCode::SUCCESS;
}

processAllSubEvents() [1/2]

StatusCode TileHitVecToCntTool::processAllSubEvents ( const EventContext & ctx ) const

virtual

Definition at line 652 of file TileHitVecToCntTool.cxx.

                                                                                 {
 
 
  ATH_MSG_DEBUG("TileHitVecToCntTool processAllSubEvents started");
  typedef PileUpMergeSvc::TimedList<TileHitVector>::type TimedHitContList;
 
  SG::OwnershipPolicy ownPolicy = SG::OWN_ELEMENTS;
 
  std::vector<std::unique_ptr<TileHit>> allHits;
  auto hits = std::make_unique<TileHitNonConstContainer>(ownPolicy);
 
  std::vector<std::unique_ptr<TileHit>> allHits_DigiHSTruth;
  std::unique_ptr<TileHitNonConstContainer> hits_DigiHSTruth;
  if (m_doDigiTruth) {
    hits_DigiHSTruth = std::make_unique<TileHitNonConstContainer>(ownPolicy);
  }
  if (m_pileUp) {
    prepareAllHits(allHits);
    if (m_doDigiTruth) {
      prepareAllHits(allHits_DigiHSTruth);
    }
  }
 
  /* zero all counters and sums */
  int nHit(0);
  double eHitTot(0.0);
 
  ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this, m_randomStreamName);
  rngWrapper->setSeed( name(), ctx );
  CLHEP::HepRandomEngine * engine = rngWrapper->getEngine(ctx);
 
  if(!m_onlyUseContainerName) {
    auto hitVectorHandles = m_hitVectorKeys.makeHandles(ctx);
    for (auto & inputHits : hitVectorHandles) {
      if (!inputHits.isValid()) {
        ATH_MSG_ERROR("Input Tile hit container is missing!");
        return StatusCode::FAILURE;
      }
      const double SubEvtTimeOffset(0.0);
      // get HitVector for this subevent
      ATH_MSG_DEBUG(" New HitCont.  TimeOffset=" << SubEvtTimeOffset << ", size =" << inputHits->size());
      this->processHitVectorForOverlay(inputHits.cptr(), hits, nHit, eHitTot);
      if(m_doDigiTruth) this->processHitVectorWithoutPileUp(inputHits.cptr(), nHit, eHitTot, hits_DigiHSTruth.get(), engine);
    }
    ATH_CHECK(commitContainers(ctx, hits, hits_DigiHSTruth, ownPolicy));
    return StatusCode::SUCCESS;
  }
 
  for (const auto& hitVectorName : m_hitVectorNames) {
 
    if (m_pileUp || m_rndmEvtOverlay) {
      TimedHitContList hitContList;
      // retrieve list of pairs (time,container) from PileUp service
      if (!(m_mergeSvc->retrieveSubEvtsData(hitVectorName, hitContList).isSuccess()) || hitContList.size() == 0) {
        ATH_MSG_WARNING("Could not fill TimedHitContList for hit vector " << hitVectorName);
        continue; // continue to the next hit vector
      }
 
      // loop over this list
      TimedHitContList::iterator iCont(hitContList.begin());
      TimedHitContList::iterator iEndCont(hitContList.end());
 
      if (m_rndmEvtOverlay) {  // overlay code
        if (iCont != iEndCont) { // use only hits from first container
          // get time for this subevent
          const double SubEvtTimeOffset(iCont->first.time());
          if (fabs(SubEvtTimeOffset) > 0.1) {
            ATH_MSG_ERROR("Wrong time for in-time event: " << SubEvtTimeOffset << " Ignoring all hits ");
          } else {
            // get HitVector for this subevent
            const TileHitVector* inputHits = &(*(iCont->second));
            ATH_MSG_DEBUG(" New HitCont.  TimeOffset=" << SubEvtTimeOffset << ", size =" << inputHits->size());
            this->processHitVectorForOverlay(inputHits, hits, nHit, eHitTot);
            if(m_doDigiTruth) this->processHitVectorWithoutPileUp(inputHits, nHit, eHitTot, hits_DigiHSTruth.get(), engine);
          }
        }
      } else if (m_pileUp) {  // pileup code
 
        for (; iCont != iEndCont; ++iCont) {
          // get time for this subevent
          const double SubEvtTimeOffset(iCont->first.time());
          // get HitVector for this subevent
          const TileHitVector* inputHits = &(*(iCont->second));
          ATH_MSG_VERBOSE(" New HitCont.  TimeOffset=" << SubEvtTimeOffset << ", size =" << inputHits->size());
          bool isSignal = false;
          if(iCont == hitContList.begin() ) isSignal = true;
          this->processHitVectorForPileUp(inputHits, SubEvtTimeOffset, allHits, allHits_DigiHSTruth, nHit, eHitTot, isSignal);
        }
      }           // loop over subevent list
    } else {  // no PileUp
 
      //**
      //* Get TileHits from TileHitVector
      //**
      SG::ReadHandle<TileHitVector> inputHits(hitVectorName);
      if (!inputHits.isValid()) {
        ATH_MSG_WARNING("Hit Vector "<< hitVectorName << " not found in StoreGate");
        continue; // continue to the next hit vector
      }
      this->processHitVectorWithoutPileUp(inputHits.cptr(), nHit, eHitTot, hits.get(), engine);
      if(m_doDigiTruth) this->processHitVectorWithoutPileUp(inputHits.cptr(), nHit, eHitTot, hits_DigiHSTruth.get(), engine);
    }
 
  } // end of the loop over different input hitVectorNames (normal hits and MBTS hits)
 
  if (m_pileUp) {
    putAllHitsInContainer(allHits, allHits_DigiHSTruth, hits, hits_DigiHSTruth, ownPolicy);
  }
 
  ATH_CHECK(commitContainers(ctx, hits, hits_DigiHSTruth, ownPolicy));
 
  return StatusCode::SUCCESS;
}

processAllSubEvents() [2/2]

StatusCode TileHitVecToCntTool::processAllSubEvents ( const EventContext & ctx )

finaloverridevirtual

Reimplemented from PileUpToolBase.

Definition at line 647 of file TileHitVecToCntTool.cxx.

                                                                           {
  return ((const TileHitVecToCntTool*) this)->processAllSubEvents(ctx);
}

processBunchXing()

StatusCode TileHitVecToCntTool::processBunchXing ( int bunchXing, SubEventIterator bSubEvents, SubEventIterator eSubEvents )

finaloverridevirtual

Reimplemented from PileUpToolBase.

Definition at line 576 of file TileHitVecToCntTool.cxx.

{
 
  ATH_MSG_DEBUG("Inside TileHitVecToCntTool processBunchXing" << bunchXing);
  //  setFilterPassed(true);
 
  ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this, m_randomStreamName);
  CLHEP::HepRandomEngine * engine = rngWrapper->getEngine(Gaudi::Hive::currentContext());
 
  SubEventIterator iEvt(bSubEvents);
  if (m_rndmEvtOverlay && bunchXing != 0) iEvt = eSubEvents; // in overlay skip all events except BC=0
 
  while (iEvt != eSubEvents) {
    /* zero all counters and sums */
    int nHit(0);
    double eHitTot(0.0);
 
    std::vector<std::string>::const_iterator hitVecNamesItr = m_hitVectorNames.begin();
    std::vector<std::string>::const_iterator hitVecNamesEnd = m_hitVectorNames.end();
    for (; hitVecNamesItr != hitVecNamesEnd; ++hitVecNamesItr) {
 
      const std::string hitVectorName(*hitVecNamesItr);
 
      if (m_pileUp || m_rndmEvtOverlay) {
 
        const TileHitVector* inputHits = nullptr;
        if (!(m_mergeSvc->retrieveSingleSubEvtData(hitVectorName, inputHits, bunchXing, iEvt))){
          ATH_MSG_ERROR(" Tile Hit container not found for event key " << hitVectorName);
        }
 
        const double SubEvtTimOffset(iEvt->time());
 
        if (m_rndmEvtOverlay) { // overlay code
          if (fabs(SubEvtTimOffset) > 0.1) {
            ATH_MSG_ERROR("Wrong time for in-time event: " << SubEvtTimOffset << " Ignoring all hits ");
          } else {
            ATH_MSG_DEBUG(" New HitCont.  TimeOffset=" << SubEvtTimOffset << ", size =" << inputHits->size());
            this->processHitVectorForOverlay(inputHits, m_hits, nHit, eHitTot);
            //if( m_doDigiTruth && iEvt == bSubEvents) this->processHitVectorWithoutPileUp(inputHits, nHit, eHitTot, m_signalHits, engine);
          }
        } else if (m_pileUp) { // pileup code
          bool isSignal = false;
          if(iEvt == bSubEvents) isSignal = true;
          this->processHitVectorForPileUp(inputHits, SubEvtTimOffset, m_allHits, m_allHits_DigiHSTruth, nHit, eHitTot, isSignal);
        }
      } else {  // no PileUp
        //**
        //* Get TileHits from TileHitVector
        //**
        const TileHitVector * inputHits = nullptr;
        if (!(m_mergeSvc->retrieveSingleSubEvtData(hitVectorName, inputHits, bunchXing, iEvt))){
          ATH_MSG_ERROR(" Tile Hit container not found for event key " << hitVectorName);
        }
 
        this->processHitVectorWithoutPileUp(inputHits, nHit, eHitTot, m_hits.get(), engine);
        if(m_doDigiTruth) this->processHitVectorWithoutPileUp(inputHits, nHit, eHitTot, m_hits_DigiHSTruth.get(), engine);
      } // to pile-up or not
 
    } // end of the loop over different input hitVectorNames (normal hits and MBTS hits)
 
    ++iEvt;
    if (m_rndmEvtOverlay) iEvt = eSubEvents; // in overlay skip all events except fisrt one
  } // subEvent loop
 
  ATH_MSG_DEBUG("Exiting processBunchXing in TileHitVecToCntTool");
 
  return StatusCode::SUCCESS;
}

processHitVectorForOverlay()

void TileHitVecToCntTool::processHitVectorForOverlay ( const TileHitVector * inputHits, std::unique_ptr< TileHitNonConstContainer > & hits, int & nHit, double & eHitTot ) const

private

Definition at line 230 of file TileHitVecToCntTool.cxx.

                                                                                                                                                                    {
 
  TileHitVecConstIterator inpItr = inputHits->begin();
  TileHitVecConstIterator end = inputHits->end();
 
  for (; inpItr != end; ++inpItr) {
 
    const TileHit * cinp = &(*inpItr);
 
    eHitTot += cinp->energy(); // not really correct if TileHit contains vector of energies
    // but eHitTot is needed for debug purposes only
    TileHit * pHit = new TileHit(*cinp);
    hits->push_back(pHit);
    ++nHit;
 
    if (msgLvl(MSG::VERBOSE)) {
      int hitsize = cinp->size();
      double eHit = 0.0;
      double tHit = 0.0;
      for (int i = 0; i < hitsize; ++i) {
        eHit += cinp->energy(i);
        tHit += cinp->time(i) * cinp->energy(i);
      }
      if (eHit > 0.0)
        tHit /= eHit;
      else
        tHit = cinp->time();
 
      eHitTot += eHit - cinp->energy(); // put total energy instead of first hit energy
 
      msg(MSG::VERBOSE) << " nHit=" << nHit
                        << " id=" << m_tileID->to_string(cinp->identify(), -1)
                        << " eHit=" << eHit
                        << " tHit=" << tHit
                        << " Copy hit: ener=";
      for (int i = 0; i < hitsize; ++i)
        msg(MSG::VERBOSE) << cinp->energy(i) << " ";
      msg(MSG::VERBOSE) << "time=";
      for (int i = 0; i < hitsize; ++i)
        msg(MSG::VERBOSE) << cinp->time(i) << " ";
      msg(MSG::VERBOSE) << endmsg;
    }
  }
  return;
}

processHitVectorForPileUp()

void TileHitVecToCntTool::processHitVectorForPileUp ( const TileHitVector * inputHits, double SubEvtTimOffset, std::vector< std::unique_ptr< TileHit > > & allHits, std::vector< std::unique_ptr< TileHit > > & allHits_DigiHSTruth, int & nHit, double & eHitTot, bool isSignal = false ) const

private

Definition at line 276 of file TileHitVecToCntTool.cxx.

                                                                                                     {
 
  IdContext pmt_context = m_tileID->pmt_context();
  IdContext tbchannel_context = m_tileTBID->channel_context();
  IdentifierHash hit_idhash;
 
  // Loop over hits in this HitVector
  TileHitVecConstIterator inpItr = inputHits->begin();
  TileHitVecConstIterator end = inputHits->end();
 
  for (; inpItr != end; ++inpItr) {
 
    const TileHit * cinp = &(*inpItr);
    Identifier hit_id = cinp->identify();
 
    if (m_tileTBID->is_tiletb(hit_id)) {
      int side = std::max(0, m_tileTBID->type(hit_id));
      int phi = m_tileTBID->module(hit_id);
      int eta = m_tileTBID->channel(hit_id);
      if (eta < 2)
        hit_idhash = mbts_index(side, phi, eta);
      else
        hit_idhash = e4pr_index(phi);
    } else {
      m_tileID->get_hash(hit_id, hit_idhash, &pmt_context);
    }
 
    if (hit_idhash >= allHits.size()) {
      // Seems to be E4pr or MBTS hit in minimum bias while geometry is used without them => skipping
      continue;
    }
 
    double ener = cinp->energy();
    double time = cinp->time() + SubEvtTimOffset;
 
    ++nHit;
    eHitTot += ener;
 
    std::unique_ptr<TileHit>& pHit = allHits[hit_idhash];
    std::unique_ptr<TileHit> inValidHit(nullptr);
    std::unique_ptr<TileHit>& pHit_DigiHSTruth = m_doDigiTruth ? allHits_DigiHSTruth[hit_idhash] : inValidHit;
 
    if (time < m_maxHitTime){
      pHit->add(ener, time, m_deltaT);
      if(m_doDigiTruth){
        if(isSignal) {
          pHit_DigiHSTruth->add(ener, time, m_deltaT);
        } else {
          pHit_DigiHSTruth->add(0,time, m_deltaT);
        }
      }
    }
 
    if (msgLvl(MSG::VERBOSE)) {
      if (pHit->size() > 1 || pHit->energy() != 0.0)
        msg(MSG::VERBOSE) << " nHit=" << nHit
                          << " id=" << m_tileID->to_string(hit_id, -1)
                          << " ener=" << ener
                          << " time=" << time
                          << " offs=" << SubEvtTimOffset
                          << " double hit" << endmsg;
      else
        msg(MSG::VERBOSE) << " nH=" << nHit
                          << " id=" << m_tileID->to_string(hit_id, -1)
                          << " HWid=" << m_tileID->to_string(pHit->pmt_HWID())
                          << " e=" << ener
                          << " time=" << time
                          << " offs=" << SubEvtTimOffset
                          << " new hit" << endmsg;
    }
 
    int hitsize = cinp->size();
    for (int ind = 1; ind < hitsize; ++ind) { // if we have double hits in original hit
      ener = cinp->energy(ind);           // merge all of them with appropriate time
      time = cinp->time(ind) + SubEvtTimOffset;
 
      ++nHit;
      eHitTot += ener;
 
      if (time < m_maxHitTime){
        pHit->add(ener, time, m_deltaT);
        if(m_doDigiTruth){
          if(isSignal)
            pHit_DigiHSTruth->add(ener, time, m_deltaT);
          else
            pHit_DigiHSTruth->add(0, time, m_deltaT);
        }
      }
 
      if (msgLvl(MSG::VERBOSE))
        msg(MSG::VERBOSE) << " nHit=" << nHit
                          << " id=" << m_tileID->to_string(hit_id, -1)
                          << " ener=" << ener
                          << " time=" << time
                          << " double hit from single hit" << endmsg;
    }
  }         // loop over hits in one vector
  return;
}

processHitVectorWithoutPileUp()

void TileHitVecToCntTool::processHitVectorWithoutPileUp ( const TileHitVector * inputHits, int & nHit, double & eHitTot, TileHitNonConstContainer * hitCont, CLHEP::HepRandomEngine * engine ) const

private

Definition at line 379 of file TileHitVecToCntTool.cxx.

                                                                                                                                                                                          {
 
  TileHitVecConstIterator inpItr = inputHits->begin();
  TileHitVecConstIterator end = inputHits->end();
 
  //**
  //* Iterate over hits, creating new TileHits
  //* Add each TileHit to the TileHitContainer.
  //**
 
  switch (m_timeFlag) {
 
    case 0: {
      for (; inpItr != end; ++inpItr) {
        const TileHit * cinp = &(*inpItr);
        eHitTot += cinp->energy(); // not really correct if TileHit contains vector of energies
        // but eHitTot is needed for debug purposes only
        TileHit * pHit = new TileHit(*cinp);
        hitCont->push_back(pHit);
        ++nHit;
 
        if (msgLvl(MSG::VERBOSE)) {
          int hitsize = cinp->size();
          double eHit = 0.0;
          double tHit = 0.0;
          for (int i = 0; i < hitsize; ++i) {
            eHit += cinp->energy(i);
            tHit += cinp->time(i) * cinp->energy(i);
          }
          if (eHit > 0.0)
            tHit /= eHit;
          else
            tHit = cinp->time();
 
          eHitTot += eHit - cinp->energy(); // put total energy instead of first hit energy
 
          msg(MSG::VERBOSE) << " nHit=" << nHit
                            << " id=" << m_tileID->to_string(cinp->identify(), -1)
                            << " eHit=" << eHit
                            << " tHit=" << tHit
                            << " Copy hit: ener=";
          for (int i = 0; i < hitsize; ++i)
            msg(MSG::VERBOSE) << cinp->energy(i) << " ";
          msg(MSG::VERBOSE) << "time=";
          for (int i = 0; i < hitsize; ++i)
            msg(MSG::VERBOSE) << cinp->time(i) << " ";
          msg(MSG::VERBOSE) << endmsg;
        }
      }
      break;
    }
 
    case 1: {
 
      for (; inpItr != end; ++inpItr) {
        const TileHit * cinp = &(*inpItr);
        int size = cinp->size();
        double eHit = 0.0;
        for (int i = 0; i < size; ++i) {
          eHit += cinp->energy(i);
        }
        eHitTot += eHit;
 
        // create hit with total energy at time=0 instead of original one
        Identifier pmID = cinp->pmt_ID();
        TileHit * pHit = new TileHit(pmID, eHit, 0.);
 
        hitCont->push_back(pHit);
        ++nHit;
 
        if (msgLvl(MSG::VERBOSE)) {
          int hitsize = cinp->size();
          msg(MSG::VERBOSE) << " nHit=" << nHit
                            << " id=" << m_tileID->to_string(cinp->identify(), -1)
                            << " eHit=" << eHit
                            << " tHit=0.0"
                            << " Input hit: ener=";
          for (int i = 0; i < hitsize; ++i)
            msg(MSG::VERBOSE) << cinp->energy(i) << " ";
          msg(MSG::VERBOSE) << "time=";
          for (int i = 0; i < hitsize; ++i)
            msg(MSG::VERBOSE) << cinp->time(i) << " ";
          msg(MSG::VERBOSE) << endmsg;
        }
      }
      break;
 
    }
 
    case 2: {
 
      double avtime = 0.0;
 
      if (m_useTriggerTime) {
 
        if (m_triggerTimeKey.empty()) {
          avtime = m_triggerTime;
        } else {
          SG::ReadHandle<CosTrigTime> cosTriggerTime(m_triggerTimeKey);
          avtime = cosTriggerTime->time();
        }
        ATH_MSG_DEBUG("Trigger time used : " << avtime);
 
      } else {
 
        if (m_triggerTime < 0.0) {
 
          avtime = 1.0e20;
 
          // loop to find minimal time
          for (; inpItr != end; ++inpItr) {
            const TileHit * cinp = &(*inpItr);
            int size = cinp->size();
            for (int i = 0; i < size; ++i) {
              if (cinp->time(i) < avtime) avtime = cinp->time(i);
            }
          }
          ATH_MSG_DEBUG("Minimal time in input event " << avtime);
          double shift = RandFlat::shoot(engine, m_triggerTime, 0.0);
          ATH_MSG_DEBUG("Minimal time after random shift " << shift);
          avtime -= shift; // subtracting negative shift value here
 
        } else {
 
          double weight = 0.0;
 
          // loop to calculate average time
          for (; inpItr != end; ++inpItr) {
            const TileHit * cinp = &(*inpItr);
            int size = cinp->size();
            for (int i = 0; i < size; ++i) {
              avtime += cinp->time(i) * cinp->energy(i);
              weight += cinp->energy(i);
            }
          }
          if (weight > 0.0)
            avtime /= weight;
          else
            avtime = 0.0;
 
          ATH_MSG_DEBUG("Average time used : " << avtime);
        }
 
        // reset iterator to the first hit
        inpItr = inputHits->begin();
      }
 
      for (; inpItr != end; ++inpItr) {
        const TileHit * cinp = &(*inpItr);
        TileHit * pHit = new TileHit(*cinp);
        // subract average time from all time bins in the hit
        int size = pHit->size();
        for (int i = 0; i < size; ++i) {
          pHit->setTime(pHit->time(i) - avtime, i);
          eHitTot += cinp->energy(i);
        }
 
        hitCont->push_back(pHit);
        ++nHit;
 
        if (msgLvl(MSG::VERBOSE)) {
          int hitsize = pHit->size();
          double eHit = 0.0;
          double tHit = 0.0;
          for (int i = 0; i < hitsize; ++i) {
            eHit += pHit->energy(i);
            tHit += pHit->time(i) * cinp->energy(i);
          }
          if (eHit > 0.0)
            tHit /= eHit;
          else
            tHit = cinp->time(); // just first time
 
          msg(MSG::VERBOSE) << " nHit="  << nHit
                            << " id=" << m_tileID->to_string(pHit->identify(), -1)
                            << " eHit=" << eHit
                            << " tHit=" << tHit
                            << " Output hit: ener=";
          for (int i = 0; i < hitsize; ++i)
            msg(MSG::VERBOSE) << pHit->energy(i) << " ";
          msg(MSG::VERBOSE) << "time=";
          for (int i = 0; i < hitsize; ++i)
            msg(MSG::VERBOSE) << pHit->time(i) << " ";
          msg(MSG::VERBOSE) << endmsg;
        }
      }
      break;
    }
 
    default:
      ATH_MSG_ERROR("unexpected value m_timeFlag=" << m_timeFlag);
      break;
  }
 
  return;
}

putAllHitsInContainer()

void TileHitVecToCntTool::putAllHitsInContainer ( std::vector< std::unique_ptr< TileHit > > & allHits, std::vector< std::unique_ptr< TileHit > > & allHits_DigiHSTruth, std::unique_ptr< TileHitNonConstContainer > & hits, std::unique_ptr< TileHitNonConstContainer > & hits_DigiHSTruth, SG::OwnershipPolicy ownPolicy ) const

private

Definition at line 766 of file TileHitVecToCntTool.cxx.

                                                                                         {
 
    std::vector<std::unique_ptr<TileHit>>::iterator iHit = allHits.begin();
    std::vector<std::unique_ptr<TileHit>>::iterator lastHit = allHits.end();
    std::vector<std::unique_ptr<TileHit>>::iterator iHit_DigiHSTruth = allHits_DigiHSTruth.begin();
 
    int nHitUni = 0;
    double eHitInTime = 0.0;
 
    ATH_MSG_DEBUG("Hits being stored in container");
 
    std::function<TileHit*(std::unique_ptr<TileHit>&)> getOrRelease(&std::unique_ptr<TileHit>::get);
    if (ownPolicy == SG::OWN_ELEMENTS) getOrRelease = &std::unique_ptr<TileHit>::release;
 
    for (; iHit != lastHit; ++iHit) {
      std::unique_ptr<TileHit>& hit = (*iHit);
      if (hit->size() > 1 || hit->energy() != 0.0) {       // hit exists
        eHitInTime += hit->energy();
        hits->push_back(getOrRelease(hit));
        if(m_doDigiTruth) hits_DigiHSTruth->push_back(getOrRelease((*iHit_DigiHSTruth)));
        ++nHitUni;
      }
      if(m_doDigiTruth) ++iHit_DigiHSTruth;
    }
 
    ATH_MSG_DEBUG(" nHitUni=" << nHitUni << " eHitInTime="<< eHitInTime);
}

resetFilter()

virtual void PileUpToolBase::resetFilter ( )

inlineoverridevirtualinherited

dummy implementation of filter reset

Reimplemented in MergeTruthJetsTool.

Definition at line 51 of file PileUpToolBase.h.

{ m_filterPassed=true; }

toProcess()

virtual bool PileUpToolBase::toProcess ( int bunchXing ) const

inlineoverridevirtualinherited

the method this base class helps implementing

Reimplemented in MergeHijingParsTool, and MergeTrackRecordCollTool.

Definition at line 32 of file PileUpToolBase.h.

                                                       {
    //closed interval [m_firstXing,m_lastXing]
    return !((m_firstXing > bunchXing) || (bunchXing > m_lastXing));
  }

Member Data Documentation

E4_ETA

const int TileHitVecToCntTool::E4_ETA = 2

staticprivate

Definition at line 194 of file TileHitVecToCntTool.h.

E4_N_PHI

const int TileHitVecToCntTool::E4_N_PHI = 4

staticprivate

Definition at line 195 of file TileHitVecToCntTool.h.

E4_SIDE

const int TileHitVecToCntTool::E4_SIDE = -1

staticprivate

Definition at line 193 of file TileHitVecToCntTool.h.

m_allHits

std::vector<std::unique_ptr<TileHit> > TileHitVecToCntTool::m_allHits

private

vector for all TileHits

Definition at line 180 of file TileHitVecToCntTool.h.

m_allHits_DigiHSTruth

std::vector<std::unique_ptr<TileHit> > TileHitVecToCntTool::m_allHits_DigiHSTruth

private

vector for all TileHits

Definition at line 181 of file TileHitVecToCntTool.h.

m_cabling

const TileCablingService* TileHitVecToCntTool::m_cabling {}

private

Definition at line 202 of file TileHitVecToCntTool.h.

{};

m_cablingSvc

ServiceHandle<TileCablingSvc> TileHitVecToCntTool::m_cablingSvc {this, "TileCablingSvc", "TileCablingSvc", ""}

private

Definition at line 201 of file TileHitVecToCntTool.h.

{this, "TileCablingSvc", "TileCablingSvc", ""};

m_deltaT

Gaudi::Property<double> TileHitVecToCntTool::m_deltaT

private

Initial value:

{this, "DeltaT", 1.0*Gaudi::Units::nanosecond,
      "Minimal Time granularity in TileHit (default=1ns)"}

minimal time granularity for TileHit

Definition at line 145 of file TileHitVecToCntTool.h.

                                {this, "DeltaT", 1.0*Gaudi::Units::nanosecond,
      "Minimal Time granularity in TileHit (default=1ns)"}; 

m_doDigiTruth

Gaudi::Property<bool> TileHitVecToCntTool::m_doDigiTruth

private

Initial value:

{this, "DoHSTruthReconstruction", false,
      "DigiTruth reconstruction"}

Definition at line 163 of file TileHitVecToCntTool.h.

                                   {this, "DoHSTruthReconstruction", false,
      "DigiTruth reconstruction"};                       

m_E1merged

std::vector<bool> TileHitVecToCntTool::m_E1merged

private

Definition at line 204 of file TileHitVecToCntTool.h.

m_filterPassed

bool PileUpToolBase::m_filterPassed {true}

protectedinherited

Definition at line 60 of file PileUpToolBase.h.

{true}; 

m_firstXing

Gaudi::Property<int> PileUpToolBase::m_firstXing

protectedinherited

Initial value:

{this, "FirstXing", -999,
      "First bunch-crossing in which det is live"}

Definition at line 54 of file PileUpToolBase.h.

                                {this, "FirstXing", -999,
      "First bunch-crossing in which det is live"};

m_fragHashFunc

TileFragHash TileHitVecToCntTool::m_fragHashFunc

private

Definition at line 203 of file TileHitVecToCntTool.h.

m_hitContainer_DigiHSTruthKey

SG::WriteHandleKey<TileHitContainer> TileHitVecToCntTool::m_hitContainer_DigiHSTruthKey

private

Initial value:

{this,"TileHitContainer_DigiHSTruth","TileHitCnt_DigiHSTruth",
      "Output DigiHSTruth Tile hit container key"}

Definition at line 132 of file TileHitVecToCntTool.h.

                                                                  {this,"TileHitContainer_DigiHSTruth","TileHitCnt_DigiHSTruth",
      "Output DigiHSTruth Tile hit container key"};

m_hitContainerKey

SG::WriteHandleKey<TileHitContainer> TileHitVecToCntTool::m_hitContainerKey

private

Initial value:

{this,"TileHitContainer","TileHitCnt",
      "Output Tile hit container key"}

Definition at line 129 of file TileHitVecToCntTool.h.

                                                      {this,"TileHitContainer","TileHitCnt",
      "Output Tile hit container key"};

m_hits

std::unique_ptr<TileHitNonConstContainer> TileHitVecToCntTool::m_hits {}

private

pointer to hits container

Definition at line 182 of file TileHitVecToCntTool.h.

{};          

m_hits_DigiHSTruth

std::unique_ptr<TileHitNonConstContainer> TileHitVecToCntTool::m_hits_DigiHSTruth {}

private

pointer to hits container

Definition at line 183 of file TileHitVecToCntTool.h.

{};   

m_hitVectorKeys

SG::ReadHandleKeyArray<TileHitVector> TileHitVecToCntTool::m_hitVectorKeys {this, "TileHitVectorKeys", {}, "Do not set manually!"}

private

Definition at line 126 of file TileHitVecToCntTool.h.

{this, "TileHitVectorKeys", {}, "Do not set manually!"};

m_hitVectorNames

std::vector<std::string> TileHitVecToCntTool::m_hitVectorNames {}

private

Definition at line 127 of file TileHitVecToCntTool.h.

{};

m_inputKeys

StringArrayProperty TileHitVecToCntTool::m_inputKeys

private

Initial value:

{this, "TileHitVectors", {"TileHitVec"},
      "Name of input hit vectors (default=TileHitVec)" }

vector with the names of TileHitVectors to use

Definition at line 124 of file TileHitVecToCntTool.h.

                                 {this, "TileHitVectors", {"TileHitVec"},
      "Name of input hit vectors (default=TileHitVec)" };  

m_lastXing

Gaudi::Property<int> PileUpToolBase::m_lastXing

protectedinherited

Initial value:

{this, "LastXing", 999,
      "Last bunch-crossing in which det is live"}

Definition at line 56 of file PileUpToolBase.h.

                                {this, "LastXing", 999,
      "Last bunch-crossing in which det is live"};

m_maxHitTime

Gaudi::Property<double> TileHitVecToCntTool::m_maxHitTime

private

Initial value:

{this, "MaxHitTime", 150.5*Gaudi::Units::nanosecond,
      "All sub-hits with time above m_maxHitTime will be ignored"}

all sub-hits with time above m_maxHitTime will be ignored

Definition at line 151 of file TileHitVecToCntTool.h.

                                    {this, "MaxHitTime", 150.5*Gaudi::Units::nanosecond,
      "All sub-hits with time above m_maxHitTime will be ignored"}; 

m_MBTSmerged

std::vector<bool> TileHitVecToCntTool::m_MBTSmerged

private

Definition at line 205 of file TileHitVecToCntTool.h.

m_mbtsOffset

int TileHitVecToCntTool::m_mbtsOffset {0}

private

Definition at line 185 of file TileHitVecToCntTool.h.

{0};                           //<! index of first MBTS hit in m_allHits vector

m_mergeMultipleHitsInChannel

Gaudi::Property<bool> TileHitVecToCntTool::m_mergeMultipleHitsInChannel

private

Initial value:

{this, "MergeMultipleHitsInChannel", true,
      "Find and merge multiple hits for the same channel in container (default=true)"}

Definition at line 167 of file TileHitVecToCntTool.h.

                                                  {this, "MergeMultipleHitsInChannel", true,
      "Find and merge multiple hits for the same channel in container (default=true)"};

m_mergeSvc

ServiceHandle<PileUpMergeSvc> TileHitVecToCntTool::m_mergeSvc {this, "PileUpMergeSvc", "PileUpMergeSvc", ""}

private

Definition at line 170 of file TileHitVecToCntTool.h.

{this, "PileUpMergeSvc", "PileUpMergeSvc", ""};

m_onlyUseContainerName

Gaudi::Property<bool> TileHitVecToCntTool::m_onlyUseContainerName {this, "OnlyUseContainerName", true, "Don't use the ReadHandleKey directly. Just extract the container name from it."}

private

Definition at line 123 of file TileHitVecToCntTool.h.

{this, "OnlyUseContainerName", true, "Don't use the ReadHandleKey directly. Just extract the container name from it."};

m_photoElectronStatistics

Gaudi::Property<int> TileHitVecToCntTool::m_photoElectronStatistics

private

Initial value:

{this, "PhotostatType", 2,
      "Method to apply photostatistics (default=2)"}

photoelectron statistics type: 0 - Poisson, 1 - "new" Poisson + Gauss, 2 - Poisson->Gauss

Definition at line 155 of file TileHitVecToCntTool.h.

                                              {this, "PhotostatType", 2,
      "Method to apply photostatistics (default=2)"}; 

m_photoStatisticsWindow

Gaudi::Property<double> TileHitVecToCntTool::m_photoStatisticsWindow

private

Initial value:

{this, "PhotostatWindow", 62.5*Gaudi::Units::nanosecond,
      "Sum up energy in [-m_photoStatWindow,+m_photoStatWindow] and use it for photostatistics"}

sum up energy in [-m_photoStatWindow,+m_photoStatWindow] and use it for photostatistics

Definition at line 153 of file TileHitVecToCntTool.h.

                                               {this, "PhotostatWindow", 62.5*Gaudi::Units::nanosecond,
      "Sum up energy in [-m_photoStatWindow,+m_photoStatWindow] and use it for photostatistics"}; 

m_pileUp

Gaudi::Property<bool> TileHitVecToCntTool::m_pileUp

private

Initial value:

{this, "PileUp", false,
      "To switch on pileup (default=false)"}

if true => pileup mode is activated

Definition at line 143 of file TileHitVecToCntTool.h.

                              {this, "PileUp", false,
      "To switch on pileup (default=false)"}; 

m_randomStreamName

Gaudi::Property<std::string> TileHitVecToCntTool::m_randomStreamName {this, "RandomStreamName", "Tile_HitVecToCnt", ""}

private

Random Stream Name.

Definition at line 178 of file TileHitVecToCntTool.h.

{this, "RandomStreamName", "Tile_HitVecToCnt", ""};

m_rndmEvtOverlay

Gaudi::Property<bool> TileHitVecToCntTool::m_rndmEvtOverlay

private

Initial value:

{this, "RndmEvtOverlay", false,
      "Pileup and/or noise added by overlaying random events (default=false)"}

If true => overlay with random event (zero-luminosity pile-up)

Definition at line 159 of file TileHitVecToCntTool.h.

                                      {this, "RndmEvtOverlay", false,
      "Pileup and/or noise added by overlaying random events (default=false)"}; 

m_rndmSvc

ServiceHandle<IAthRNGSvc> TileHitVecToCntTool::m_rndmSvc {this, "RndmSvc", "AthRNGSvc", ""}

private

Random number generator engine to use.

Definition at line 176 of file TileHitVecToCntTool.h.

{this, "RndmSvc", "AthRNGSvc", ""};     

m_run2

bool TileHitVecToCntTool::m_run2 {false}

private

if true => RUN2 geometry with E4' and merged E1

Definition at line 141 of file TileHitVecToCntTool.h.

{false};                                

m_run2plus

bool TileHitVecToCntTool::m_run2plus {false}

private

if true => RUN2+ geometry with merged E1 (and E4' in RUN2)

Definition at line 142 of file TileHitVecToCntTool.h.

{false};                            

m_samplingFractionKey

SG::ReadCondHandleKey<TileSamplingFraction> TileHitVecToCntTool::m_samplingFractionKey

private

Initial value:

{this,
      "TileSamplingFraction", "TileSamplingFraction", "Input Tile sampling fraction"}

Name of TileSamplingFraction in condition store.

Definition at line 138 of file TileHitVecToCntTool.h.

                                                                 {this,
      "TileSamplingFraction", "TileSamplingFraction", "Input Tile sampling fraction"};

m_skipNoHit

Gaudi::Property<bool> TileHitVecToCntTool::m_skipNoHit

private

Initial value:

{this, "SkipNoHit", false,
      "Skip events with no Tile hits (default=false)"}

if true => skip events with no Tile hits

Definition at line 157 of file TileHitVecToCntTool.h.

                                 {this, "SkipNoHit", false,
      "Skip events with no Tile hits (default=false)"}; 

m_tileHWID

const TileHWID* TileHitVecToCntTool::m_tileHWID {nullptr}

private

Pointer to TileID helper.

Definition at line 174 of file TileHitVecToCntTool.h.

{nullptr};          

m_tileID

const TileID* TileHitVecToCntTool::m_tileID {nullptr}

private

Pointer to TileID helper.

Definition at line 172 of file TileHitVecToCntTool.h.

{nullptr};              

m_tileTBID

const TileTBID* TileHitVecToCntTool::m_tileTBID {nullptr}

private

Pointer to TileID helper.

Definition at line 173 of file TileHitVecToCntTool.h.

{nullptr};          

m_timeFlag

Gaudi::Property<int> TileHitVecToCntTool::m_timeFlag

private

Initial value:

{this, "HitTimeFlag", 0,
      "Special options to deal with times of hits for cosmics and TB (default=0)"}

special options to deal with times of hits for cosmics and TB

Definition at line 147 of file TileHitVecToCntTool.h.

                               {this, "HitTimeFlag", 0,
      "Special options to deal with times of hits for cosmics and TB (default=0)"}; 

m_triggerTime

Gaudi::Property<double> TileHitVecToCntTool::m_triggerTime

private

Initial value:

{this, "TriggerTime", 0.0,
      "Fixed trigger time value (default=0)"}

fixed trigger time value (default=0)

Definition at line 149 of file TileHitVecToCntTool.h.

                                     {this, "TriggerTime", 0.0,
      "Fixed trigger time value (default=0)"}; 

m_triggerTimeKey

SG::ReadHandleKey<CosTrigTime> TileHitVecToCntTool::m_triggerTimeKey {this,"CosTimeKey", "", "To take the trigger time from"}

private

Definition at line 169 of file TileHitVecToCntTool.h.

{this,"CosTimeKey", "", "To take the trigger time from"};

m_usePhotoStatistics

Gaudi::Property<bool> TileHitVecToCntTool::m_usePhotoStatistics

private

Initial value:

{this,
      "usePhotoStatistics", true, "Simulate photo statistics effect (default=true)"}

Definition at line 165 of file TileHitVecToCntTool.h.

                                          {this,
      "usePhotoStatistics", true, "Simulate photo statistics effect (default=true)"};

m_useTriggerTime

Gaudi::Property<bool> TileHitVecToCntTool::m_useTriggerTime

private

Initial value:

{this, "UseTriggerTime", false,
      "Take trigger time from external tool (default=false)"}

if true => take trigger time from external tool or from m_triggerTime

Definition at line 161 of file TileHitVecToCntTool.h.

                                      {this, "UseTriggerTime", false,
      "Take trigger time from external tool (default=false)"}; 

m_vetoPileUpTruthLinks

Gaudi::Property<int> PileUpToolBase::m_vetoPileUpTruthLinks

protectedinherited

Initial value:

{this, "VetoPileUpTruthLinks", true,
      "Ignore links to suppressed pile-up truth"}

Definition at line 58 of file PileUpToolBase.h.

                                           {this, "VetoPileUpTruthLinks", true,
      "Ignore links to suppressed pile-up truth"};

N_E4PRIME_CELLS

const int TileHitVecToCntTool::N_E4PRIME_CELLS = E4_N_PHI

staticprivate

Definition at line 196 of file TileHitVecToCntTool.h.

N_ETA

const int TileHitVecToCntTool::N_ETA = 2

staticprivate

Definition at line 188 of file TileHitVecToCntTool.h.

N_MBTS_CELLS

const int TileHitVecToCntTool::N_MBTS_CELLS = N_SIDE * N_PHI * N_ETA

staticprivate

Definition at line 189 of file TileHitVecToCntTool.h.

N_PHI

const int TileHitVecToCntTool::N_PHI = 8

staticprivate

Definition at line 187 of file TileHitVecToCntTool.h.

N_SIDE

const int TileHitVecToCntTool::N_SIDE = 2

staticprivate

Definition at line 186 of file TileHitVecToCntTool.h.

---

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

• TileHitVecToCntTool.h
• TileHitVecToCntTool.cxx