CscDigitizationTool Class Reference

#include <CscDigitizationTool.h>

Inheritance diagram for CscDigitizationTool:

Collaboration diagram for CscDigitizationTool:

Public Member Functions
	CscDigitizationTool (const std::string &type, const std::string &name, const IInterface *pIID)
	~CscDigitizationTool ()=default
virtual StatusCode	initialize () override final
virtual StatusCode	mergeEvent (const EventContext &ctx) override final
	called at the end of the subevts loop. Not (necessarily) able to access subEvents More...
virtual StatusCode	processBunchXing (int bunchXing, SubEventIterator bSubEvents, SubEventIterator eSubEvents) override final
	called for each active bunch-crossing to process current subEvents. bunchXing is in ns More...
virtual StatusCode	prepareEvent (const EventContext &ctx, unsigned int) override final
	return false if not interested in certain xing times (in ns) implemented by default in PileUpToolBase as FirstXing<=bunchXing<=LastXing More...
virtual StatusCode	processAllSubEvents (const EventContext &ctx) override final
	alternative interface which uses the PileUpMergeSvc to obtain all the required SubEvents. More...

Private Types
typedef std::vector< CscSimData::Deposit >	deposits
typedef std::map< IdentifierHash, std::pair< double, double > >	csc_map
typedef std::map< IdentifierHash, std::vector< float > >	csc_newmap
using	Collections_t = std::vector< std::unique_ptr< CscDigitCollection > >

Private Member Functions
StatusCode	FillCollectionWithNewDigitEDM (csc_newmap &data_SampleMap, std::map< IdentifierHash, deposits > &myDeposits, bool phaseToSet, Collections_t &collections, CscSimDataCollection *cscSimData)
StatusCode	FillCollectionWithOldDigitEDM (csc_map &data_map, std::map< IdentifierHash, deposits > &myDeposits, Collections_t &collections, CscSimDataCollection *cscSimData)
StatusCode	CoreDigitization (Collections_t &collections, CscSimDataCollection *cscSimData, CLHEP::HepRandomEngine *rndmEngine, const EventContext &ctx)
StatusCode	getNextEvent (const EventContext &ctx)

Private Attributes
ToolHandle< ICscCalibTool >	m_pcalib {this, "cscCalibTool", "CscCalibTool", "CSC calibration tool"}
BooleanProperty	m_onlyUseContainerName {this, "OnlyUseContainerName", true, "Don't use the ReadHandleKey directly. Just extract the container name from it."}
SG::ReadHandleKey< CSCSimHitCollection >	m_hitsContainerKey {this, "InputObjectName", "CSC_Hits", "name of the input objects"}
std::string	m_inputObjectName {""}
SG::WriteHandleKey< CscSimDataCollection >	m_cscSimDataCollectionWriteHandleKey {this,"CSCSimDataCollectionOutputName","CSC_SDO","WriteHandleKey for Output CscSimDataCollection"}
SG::WriteHandleKey< CscDigitContainer >	m_cscDigitContainerKey {this,"OutputObjectName","CSC_DIGITS","CSC digit container object"}
std::unique_ptr< CSC_Digitizer >	m_cscDigitizer {nullptr}
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
Gaudi::Property< double >	m_pedestal {this, "pedestal",0.0, ""}
Gaudi::Property< bool >	m_maskBadChannel {this, "maskBadChannels", true, ""}
Gaudi::Property< double >	m_amplification {this, "amplification", 0.58e5, ""}
TimedHitCollection< CSCSimHit > *	m_thpcCSC {nullptr}
std::list< CSCSimHitCollection * >	m_cscHitCollList
Gaudi::Property< bool >	m_includePileUpTruth {this, "IncludePileUpTruth", true, "Include pile-up truth info"}
Gaudi::Property< double >	m_timeWindowLowerOffset {this, "WindowLowerOffset", -25., ""}
Gaudi::Property< double >	m_timeWindowUpperOffset {this, "WindowUpperOffset", +25., ""}
Gaudi::Property< bool >	m_isPileUp {this, "isPileUp", false, ""}
Gaudi::Property< bool >	m_newDigitEDM {this, "NewDigitEDM", true, ""}
Gaudi::Property< double >	m_driftVelocity {this, "DriftVelocity", 60, ""}
Gaudi::Property< double >	m_electronEnergy {this, "ElectronEnergy", 66, ""}
Gaudi::Property< bool >	m_NInterFixed {this, "NInterFixed", false, ""}
ServiceHandle< PileUpMergeSvc >	m_mergeSvc {this, "PileUpMergeSvc", "PileUpMergeSvc", ""}
ServiceHandle< IAthRNGSvc >	m_rndmSvc {this, "RndmSvc", "AthRNGSvc", ""}

structors and AlgTool implementation
virtual bool	toProcess (int bunchXing) const override
	the method this base class helps implementing More...
virtual StatusCode	processAllSubEvents (const EventContext &ctx)=0
	dummy implementation to allow compilation while all Digitization packages are migrated to use this new interface. More...
virtual bool	filterPassed () const override
	dummy implementation of passing filter More...
virtual void	resetFilter () override
	dummy implementation of filter reset More...
Gaudi::Property< int >	m_firstXing
Gaudi::Property< int >	m_lastXing
Gaudi::Property< int >	m_vetoPileUpTruthLinks
bool	m_filterPassed {true}

Detailed Description

Definition at line 39 of file CscDigitizationTool.h.

Member Typedef Documentation

Collections_t

using CscDigitizationTool::Collections_t = std::vector<std::unique_ptr<CscDigitCollection> >

private

Definition at line 75 of file CscDigitizationTool.h.

csc_map

typedef std::map<IdentifierHash,std::pair<double,double> > CscDigitizationTool::csc_map

private

Definition at line 42 of file CscDigitizationTool.h.

csc_newmap

typedef std::map<IdentifierHash,std::vector<float> > CscDigitizationTool::csc_newmap

private

Definition at line 43 of file CscDigitizationTool.h.

deposits

typedef std::vector<CscSimData::Deposit> CscDigitizationTool::deposits

private

Definition at line 41 of file CscDigitizationTool.h.

Constructor & Destructor Documentation

CscDigitizationTool()

CscDigitizationTool::CscDigitizationTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	pIID
	)

Definition at line 17 of file CscDigitizationTool.cxx.

                                                                                                           :
  PileUpToolBase(type, name, pIID) {
}

~CscDigitizationTool()

CscDigitizationTool::~CscDigitizationTool ( )

default

Member Function Documentation

CoreDigitization()

StatusCode CscDigitizationTool::CoreDigitization ( Collections_t &  collections, CscSimDataCollection *  cscSimData, CLHEP::HepRandomEngine *  rndmEngine, const EventContext &  ctx  )

private

Definition at line 139 of file CscDigitizationTool.cxx.

                                                                                                                                                                       {
 
  std::map <IdentifierHash,deposits> myDeposits;
  csc_map    data_map;
  csc_newmap data_SampleMap, data_SampleMapOddPhase;
 
  TimedHitCollection< CSCSimHit >::const_iterator i, e;
 
  // Perform null check on m_thpcCSC
  if(!m_thpcCSC) {
    ATH_MSG_ERROR ( "m_thpcCSC is null" );
    return StatusCode::FAILURE;
  }
 
  // get the iterator pairs for this DetEl
  while( m_thpcCSC->nextDetectorElement(i, e) ) {
 
    // Loop over the hits:
    while (i != e) {
 
      TimedHitPtr<CSCSimHit> phit(*i++);
      const CSCSimHit& hit(*phit);
 
 
      ATH_MSG_DEBUG(hit.print());
 
 
 
      double globalHitTime(hitTime(phit));
      double bunchTime(globalHitTime - hit.globalTime());
 
      // Hit time is the G4 hit time plus the drift time.
      // Gloabl time add the bnch crossing time to the hit time.
      ATH_MSG_DEBUG ( "bunch time (ns) " << bunchTime  << "globalHitTime (ns) " << globalHitTime << " hit Time (ns) " << hitTime(phit) );
      m_cscDigitizer->set(bunchTime);
 
      std::vector<IdentifierHash> hashVec;
      StatusCode status = (m_newDigitEDM)
        ? m_cscDigitizer->digitize_hit(&hit, hashVec, data_SampleMap, data_SampleMapOddPhase, rndmEngine)
        : m_cscDigitizer->digitize_hit(&hit, hashVec, data_map, rndmEngine);
 
      if (status.isFailure()) {
        ATH_MSG_ERROR ( "CSC Digitizer Failed to digitize a hit!" );
        return status;
      }
 
      std::vector<IdentifierHash>::const_iterator vecBeg = hashVec.begin();
      std::vector<IdentifierHash>::const_iterator vecEnd = hashVec.end();
      // Fetch the energy deposit.
      const double energy = hit.energyDeposit();
      // Determine where hit crosses the wire plane (x=0).
      float ypos = -99999.9;
      float zpos = ypos;
      double xi = hit.getHitStart().x();
      double yi = hit.getHitStart().y();
      double zi = hit.getHitStart().z();
      double xf = hit.getHitEnd().x();
      double yf = hit.getHitEnd().y();
      double zf = hit.getHitEnd().z();
      double dx = xf - xi;
      double dy = yf - yi;
      double dz = zf - zi;
      if ( dx>0.0 && xi<=0.0 && xf>=0.0 ) {
        double f = -xi/dx;
        ypos = yi + f*dy;
        zpos = zi + f*dz;
      }
 
      if (!m_includePileUpTruth && HepMC::ignoreTruthLink(phit->particleLink(), m_vetoPileUpTruthLinks)) {
        hashVec.clear();
        continue;
      }
      const HepMcParticleLink trackLink = HepMcParticleLink::getRedirectedLink(phit->particleLink(), phit.eventId(), ctx); // This link should now correctly resolve to the TruthEvent McEventCollection in the main StoreGateSvc.
      const auto cscd = CscMcData(energy, ypos, zpos);
      for (; vecBeg != vecEnd; ++vecBeg) {
        myDeposits[(*vecBeg)].emplace_back(trackLink,cscd);
      }
      hashVec.clear();
    }
  }
 
  // reset the pointer.
  delete m_thpcCSC;
  m_thpcCSC=nullptr;
 
  // now loop over the digit map
  // build the digits
  // build the digit collections and record them
 
  if (m_newDigitEDM) {
    double flat = CLHEP::RandFlat::shoot(rndmEngine, 0.0,1.0);                 // for other particles
    bool phaseToSet = flat<0.5;
    if (phaseToSet)
      return FillCollectionWithNewDigitEDM(data_SampleMapOddPhase, myDeposits, phaseToSet, collections, cscSimData);
    else
      return FillCollectionWithNewDigitEDM(data_SampleMap, myDeposits, phaseToSet, collections, cscSimData);
  }  else
    return FillCollectionWithOldDigitEDM(data_map, myDeposits, collections, cscSimData);
 
}

FillCollectionWithNewDigitEDM()

StatusCode CscDigitizationTool::FillCollectionWithNewDigitEDM ( csc_newmap &  data_SampleMap, std::map< IdentifierHash, deposits > &  myDeposits, bool  phaseToSet, Collections_t &  collections, CscSimDataCollection *  cscSimData  )

private

mask this readout channel if it is a dead channel or a hot channel

Definition at line 241 of file CscDigitizationTool.cxx.

                                {
 
  CscDigitCollection * collection = nullptr;
 
  IdContext context    = m_idHelperSvc->cscIdHelper().channel_context();
  IdContext cscContext = m_idHelperSvc->cscIdHelper().module_context();
 
  Identifier prevId;
 
  csc_newmap::const_iterator cscMap    = data_SampleMap.begin();
  csc_newmap::const_iterator cscMapEnd = data_SampleMap.end();
 
  for (; cscMap != cscMapEnd; ++cscMap) {
    Identifier digitId;
    IdentifierHash hashId = (*cscMap).first;
    if (m_idHelperSvc->cscIdHelper().get_id( hashId, digitId, &context ) ) {
      ATH_MSG_ERROR ( "cannot get CSC channel identifier from hash " << hashId );
      return StatusCode::FAILURE;
    }
 
    Identifier elementId = m_idHelperSvc->cscIdHelper().parentID(digitId);
    IdentifierHash coll_hash;
    if (m_idHelperSvc->cscIdHelper().get_hash(elementId, coll_hash, &cscContext)) {
      ATH_MSG_ERROR ( "Unable to get CSC hash id from CSC Digit collection "
                      << "context begin_index = " << cscContext.begin_index()
                      << " context end_index  = " << cscContext.end_index()
                      << " the identifier is " );
      elementId.show();
    }
 
 
    // get the charge
    double stripCharge = 0.0;
    double driftTime = 0.0;
    const std::vector<float> samples = (*cscMap).second;
 
    unsigned int samplingPhase =0;
    double samplingTime = m_pcalib->getSamplingTime();
    m_pcalib->findCharge(samplingTime, samplingPhase, samples, stripCharge, driftTime);
    driftTime += m_pcalib->getLatency();
 
    if ( !m_pcalib->isGood( hashId ) && m_maskBadChannel ) {
      stripCharge = 0.0;
      driftTime   = 2*m_timeWindowUpperOffset;
    }
 
    int zsec = m_idHelperSvc->cscIdHelper().stationEta(digitId);
    int phisec = m_idHelperSvc->cscIdHelper().stationPhi(digitId);
    int istation = m_idHelperSvc->cscIdHelper().stationName(digitId) - 49;
 
    int wlay = m_idHelperSvc->cscIdHelper().wireLayer(digitId);
    int measphi = m_idHelperSvc->cscIdHelper().measuresPhi(digitId);
    int istrip = m_idHelperSvc->cscIdHelper().strip(digitId);
 
    int sector = zsec*(2*phisec-istation+1);
 
    auto depositsForHash = myDeposits.find(hashId);
    if (depositsForHash != myDeposits.end() && !depositsForHash->second.empty()) {
      depositsForHash->second[0].second.setCharge(stripCharge);
      cscSimData->insert ( std::make_pair(digitId, CscSimData(depositsForHash->second,0)) );
    }
 
    // fill the digit collections in StoreGate
    // Now, we pass driftTime as well as stripCharge.
    // SimHIT time should be added to distinguish prompt muons from secondary.... 11/19/2009 WP
    ATH_MSG_DEBUG ( "NEWDigit sec:measphi:wlay:istr:chg:t(w/latency) "
                    << m_idHelperSvc->cscIdHelper().show_to_string(digitId,&context)
                    << " hash:eleId = " << hashId << " " << elementId << " " << prevId << "   "
                    << sector << " " << measphi << " " <<  wlay << " " << istrip << "   "
                    << int(stripCharge+1) << " " << float(driftTime)
                    << " phase=" << phaseToSet
                    << "  samps: " << samples[0] << " " << samples[1] << " "
                    << samples[2] << " " << samples[3]
                    );
 
    if (prevId != elementId) {
      if (coll_hash >= collections.size()) {
        collections.resize (coll_hash+1);
      }
      collection = collections[coll_hash].get();
      if (nullptr ==  collection) {
        collections[coll_hash] = std::make_unique<CscDigitCollection>(elementId,coll_hash);
        collection = collections[coll_hash].get();
      }
      if (phaseToSet) collection->set_samplingPhase();
      collection->push_back (std::make_unique<CscDigit>(digitId, samples));
 
      prevId = elementId;
    } else {
      // According to coverity, collection could still be null here.
      if (!collection) {
        ATH_MSG_ERROR("Trying to use NULL CscDigitCollection");
        return StatusCode::FAILURE;
      }
 
      if (phaseToSet) collection->set_samplingPhase();
      collection->push_back (std::make_unique<CscDigit>(digitId, samples));
    }
  }
  return StatusCode::SUCCESS;
}

FillCollectionWithOldDigitEDM()

StatusCode CscDigitizationTool::FillCollectionWithOldDigitEDM ( csc_map &  data_map, std::map< IdentifierHash, deposits > &  myDeposits, Collections_t &  collections, CscSimDataCollection *  cscSimData  )

private

mask this readout channel if it is a dead channel or a hot channel

Definition at line 349 of file CscDigitizationTool.cxx.

                                                                                                                                                          {
 
  CscDigitCollection * collection = nullptr;
  IdContext context    = m_idHelperSvc->cscIdHelper().channel_context();
  IdContext cscContext = m_idHelperSvc->cscIdHelper().module_context();
 
  Identifier prevId;
  csc_map::const_iterator cscMap    = data_map.begin();
  csc_map::const_iterator cscMapEnd = data_map.end();
  for (; cscMap != cscMapEnd; ++cscMap) {
    Identifier digitId;
    IdentifierHash hashId = (*cscMap).first;
    if (m_idHelperSvc->cscIdHelper().get_id( hashId, digitId, &context ) ) {
      ATH_MSG_ERROR ( "cannot get CSC channel identifier from hash " << hashId );
      return StatusCode::FAILURE;
    }
 
    // get the charge
    double stripCharge = 0.0;
    stripCharge   = ((*cscMap).second).second + m_pedestal; // + m_noiseLevel*gaus;
    double driftTime =((*cscMap).second).first;  // SimHIT time is added yet 12/03/2009
 
    if ( !m_pcalib->isGood( hashId ) && m_maskBadChannel ) {
      stripCharge = 0.0;
      driftTime   = 2*m_timeWindowUpperOffset;
    }
 
    ATH_MSG_VERBOSE ( "CSC Digit Id = " << m_idHelperSvc->cscIdHelper().show_to_string(digitId,&context)
                      << " hash = " << hashId
                      << " charge = " << int (stripCharge+1) );
 
    int zsec = m_idHelperSvc->cscIdHelper().stationEta(digitId);
    int phisec = m_idHelperSvc->cscIdHelper().stationPhi(digitId);
    int istation = m_idHelperSvc->cscIdHelper().stationName(digitId) - 49;
 
    int wlay = m_idHelperSvc->cscIdHelper().wireLayer(digitId);
    int measphi = m_idHelperSvc->cscIdHelper().measuresPhi(digitId);
    int istrip = m_idHelperSvc->cscIdHelper().strip(digitId);
 
    int sector = zsec*(2*phisec-istation+1);
 
    auto depositsForHash = myDeposits.find(hashId);
    if (depositsForHash != myDeposits.end() && !depositsForHash->second.empty()) {
      depositsForHash->second[0].second.setCharge(stripCharge);
      cscSimData->insert ( std::make_pair(digitId, CscSimData(depositsForHash->second,0)) );
    }
 
    // fill the digit collections in StoreGate
    // Now, we pass driftTime as well as stripCharge.
    // SimHIT time should be added to distinguish prompt muons from secondary.... 11/19/2009 WP
    auto newDigit  = std::make_unique<CscDigit>(digitId, int(stripCharge+1), float(driftTime) );
    Identifier elementId = m_idHelperSvc->cscIdHelper().parentID(digitId);
 
    ATH_MSG_DEBUG ( "CSC Digit sector:measphi:wlay:istrip:charge "
                    << sector << " "
                    << measphi << " " <<  wlay << " " << istrip
                    << " " << int(stripCharge+1) << " " << float(driftTime) << " " << (newDigit->sampleCharges()).size());
 
 
    IdentifierHash coll_hash;
    if (m_idHelperSvc->cscIdHelper().get_hash(elementId, coll_hash, &cscContext)) {
      ATH_MSG_ERROR ( "Unable to get CSC hash id from CSC Digit collection "
                      << "context begin_index = " << cscContext.begin_index()
                      << " context end_index  = " << cscContext.end_index()
                      << " the identifier is " );
      elementId.show();
    }
 
    if (prevId != elementId) {
      if (coll_hash >= collections.size()) {
        collections.resize (coll_hash+1);
      }
      collection = collections[coll_hash].get();
      if (nullptr ==  collection) {
        collections[coll_hash] = std::make_unique<CscDigitCollection>(elementId,coll_hash);
        collection = collections[coll_hash].get();
      }
      collection->push_back(std::move(newDigit));
      prevId = elementId;
    } else {
      // According to coverity, collection could still be null here.
      if (collection) {
        collection->push_back(std::move(newDigit));
      } else {
        ATH_MSG_ERROR("Trying to push back NULL CscDigitCollection");
        return StatusCode::FAILURE;
      }
    }
  }
  return StatusCode::SUCCESS;
}

filterPassed()

virtual bool PileUpToolBase::filterPassed ( ) const

inlineoverridevirtualinherited

dummy implementation of passing filter

Definition at line 49 of file PileUpToolBase.h.

{ return m_filterPassed; }

getNextEvent()

StatusCode CscDigitizationTool::getNextEvent ( const EventContext &  ctx )

private

Definition at line 445 of file CscDigitizationTool.cxx.

{
 
  //  get the container(s)
  typedef PileUpMergeSvc::TimedList<CSCSimHitCollection>::type TimedHitCollList;
 
  // In case of single hits container just load the collection using read handles
  if (!m_onlyUseContainerName) {
    SG::ReadHandle<CSCSimHitCollection> hitCollection(m_hitsContainerKey, ctx);
    if (!hitCollection.isValid()) {
      ATH_MSG_ERROR("Could not get CSCSimHitCollection container " << hitCollection.name() << " from store " << hitCollection.store());
      return StatusCode::FAILURE;
    }
 
    // create a new hits collection
    m_thpcCSC = new TimedHitCollection<CSCSimHit>{1};
    m_thpcCSC->insert(0, hitCollection.cptr());
    ATH_MSG_DEBUG("CSCSimHitCollection found with " << hitCollection->size() << " hits");
 
    return StatusCode::SUCCESS;
  }
 
  //this is a list<pair<time_t, DataLink<CSCSimHitCollection> > >
  TimedHitCollList hitCollList;
 
  if (!(m_mergeSvc->retrieveSubEvtsData(m_inputObjectName, hitCollList).isSuccess()) ) {
    ATH_MSG_ERROR ( "Could not fill TimedHitCollList" );
    return StatusCode::FAILURE;
  }
  if (hitCollList.empty()) {
    ATH_MSG_ERROR ( "TimedHitCollList has size 0" );
    return StatusCode::FAILURE;
  } else {
    ATH_MSG_DEBUG ( hitCollList.size()
                    << " CSCSimHitCollections with key " << m_inputObjectName
                    << " found" );
  }
 
  // create a new hits collection
  m_thpcCSC = new TimedHitCollection<CSCSimHit>();
 
  //now merge all collections into one
  TimedHitCollList::iterator iColl(hitCollList.begin());
  TimedHitCollList::iterator endColl(hitCollList.end());
  while (iColl != endColl) {
    const CSCSimHitCollection* p_collection(iColl->second);
    m_thpcCSC->insert(iColl->first, p_collection);
    ATH_MSG_DEBUG ( "CSCSimHitCollection found with "
                    << p_collection->size() << " hits" );    // loop on the hit collections
    ++iColl;
  }
  return StatusCode::SUCCESS;
}

initialize()

StatusCode CscDigitizationTool::initialize ( )

finaloverridevirtual

CSC calibratin tool for the Condtiions Data base access

Reimplemented from PileUpToolBase.

Definition at line 21 of file CscDigitizationTool.cxx.

                                           {
 
  ATH_MSG_DEBUG ( "Initialized Properties :" );
  ATH_MSG_DEBUG ( "  InputObjectName           " << m_inputObjectName );
  ATH_MSG_DEBUG ( "  WindowLowerOffset         " << m_timeWindowLowerOffset );
  ATH_MSG_DEBUG ( "  WindowUpperOffset         " << m_timeWindowUpperOffset );
  ATH_MSG_DEBUG ( "  PileUp On?                " << m_isPileUp );
  ATH_MSG_DEBUG ( "  maskBadChannels?          " << m_maskBadChannel );
  ATH_MSG_DEBUG ( "  amplification(gain)       " << m_amplification );
  ATH_MSG_DEBUG ( "  Use NewDigitEDM?          " << m_newDigitEDM );
  ATH_MSG_DEBUG ( "  Drift Velocity Set?       " << m_driftVelocity );
  ATH_MSG_DEBUG ( "  NInteraction per layer from poisson not from energyLoss?  " << m_NInterFixed );
  ATH_MSG_DEBUG ( "  IncludePileUpTruth        " << m_includePileUpTruth );
  ATH_MSG_DEBUG ( "  VetoPileUpTruthLinks      " << m_vetoPileUpTruthLinks );
 
  ATH_MSG_DEBUG ( "  RndmSvc                   " << m_rndmSvc.typeAndName() );
  ATH_MSG_DEBUG ( "  cscCalibTool              " << m_pcalib.typeAndName() );
  ATH_MSG_DEBUG ( "  CscSimDataCollection key  " << m_cscSimDataCollectionWriteHandleKey.key());
  ATH_MSG_DEBUG ( "  CscDigitContainer key     " << m_cscDigitContainerKey.key());
 
  // initialize transient detector store and MuonDetDescrManager
  const MuonGM::MuonDetectorManager* muDetMgr=nullptr;
  ATH_CHECK(detStore()->retrieve(muDetMgr));
  ATH_MSG_DEBUG ( "MuonDetectorManager retrieved from StoreGate.");
 
  if (m_onlyUseContainerName) {
    ATH_CHECK(m_mergeSvc.retrieve());
  }
 
  //random number initialization
  ATH_CHECK(m_rndmSvc.retrieve());
 
  ATH_CHECK(m_pcalib.retrieve());
 
  //initialize the CSC digitizer
  m_cscDigitizer = std::make_unique<CSC_Digitizer>(CscHitIdHelper::GetHelper(), muDetMgr, &*(m_pcalib));
  m_cscDigitizer->setAmplification(m_amplification);
  m_cscDigitizer->setDebug        ( msgLvl(MSG::DEBUG) );
  m_cscDigitizer->setDriftVelocity(m_driftVelocity);
  m_cscDigitizer->setElectronEnergy  (m_electronEnergy);
  if (m_NInterFixed) {
    m_cscDigitizer->setNInterFixed();
  }
  m_cscDigitizer->setWindow(m_timeWindowLowerOffset, m_timeWindowUpperOffset);
  ATH_CHECK(m_cscDigitizer->initialize());
  
  ATH_CHECK(m_idHelperSvc.retrieve());
 
  // check the input object name
  if (m_hitsContainerKey.key().empty()) {
    ATH_MSG_FATAL("Property InputObjectName not set !");
    return StatusCode::FAILURE;
  }
  if(m_onlyUseContainerName) m_inputObjectName = m_hitsContainerKey.key();
  ATH_MSG_DEBUG("Input objects in container : '" << m_inputObjectName << "'");
 
  // Initialize ReadHandleKey
  ATH_CHECK(m_hitsContainerKey.initialize(true));
 
  // +++ Initialize WriteHandleKey
  ATH_CHECK(m_cscDigitContainerKey.initialize());
  ATH_CHECK(m_cscSimDataCollectionWriteHandleKey.initialize());
 
  return StatusCode::SUCCESS;
 
}

mergeEvent()

StatusCode CscDigitizationTool::mergeEvent ( const EventContext &  ctx )

finaloverridevirtual

called at the end of the subevts loop. Not (necessarily) able to access subEvents

Definition at line 545 of file CscDigitizationTool.cxx.

                                                                  {
 
  ATH_MSG_DEBUG ( "in mergeEvent()" );
 
  //create and record CscDigitContainer in SG
  SG::WriteHandle<CscDigitContainer> cscDigits(m_cscDigitContainerKey, ctx);
  ATH_CHECK(cscDigits.record(std::make_unique<CscDigitContainer>(m_idHelperSvc->cscIdHelper().module_hash_max())));
  ATH_MSG_DEBUG("recorded CscDigitContainer with name "<<cscDigits.key());
 
  // create and record the SDO container in StoreGate
  SG::WriteHandle<CscSimDataCollection> cscSimData(m_cscSimDataCollectionWriteHandleKey, ctx);
  ATH_CHECK(cscSimData.record(std::make_unique<CscSimDataCollection>()));
 
  ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this);
  rngWrapper->setSeed( name(), ctx );
 
  Collections_t collections;
  ATH_CHECK(CoreDigitization(collections,cscSimData.ptr(), rngWrapper->getEngine(ctx), ctx));
  for (size_t coll_hash = 0; coll_hash < collections.size(); ++coll_hash) {
    if (collections[coll_hash]) {
      ATH_CHECK( cscDigits->addCollection (collections[coll_hash].release(), coll_hash) );
    }
  }
 
  // remove cloned one in processBunchXing......
  std::list<CSCSimHitCollection*>::iterator cscHitColl = m_cscHitCollList.begin();
  std::list<CSCSimHitCollection*>::iterator cscHitCollEnd = m_cscHitCollList.end();
  while(cscHitColl!=cscHitCollEnd)
    {
      delete (*cscHitColl);
      ++cscHitColl;
    }
  m_cscHitCollList.clear();
 
  return StatusCode::SUCCESS;
}

prepareEvent()

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

finaloverridevirtual

return false if not interested in certain xing times (in ns) implemented by default in PileUpToolBase as FirstXing<=bunchXing<=LastXing

Definition at line 90 of file CscDigitizationTool.cxx.

                                                                                  {
 
  if (nullptr == m_thpcCSC)
    m_thpcCSC = new TimedHitCollection<CSCSimHit>();
 
  m_cscHitCollList.clear();
 
  return StatusCode::SUCCESS;
}

processAllSubEvents() [1/2]

StatusCode CscDigitizationTool::processAllSubEvents ( const EventContext &  ctx )

finaloverridevirtual

alternative interface which uses the PileUpMergeSvc to obtain all the required SubEvents.

Reimplemented from PileUpToolBase.

Definition at line 101 of file CscDigitizationTool.cxx.

                                                                           {
 
  ATH_MSG_DEBUG ( "in processAllSubEvents()" );
 
  //create and record CscDigitContainer in SG
  SG::WriteHandle<CscDigitContainer> cscDigits(m_cscDigitContainerKey, ctx);
  ATH_CHECK(cscDigits.record(std::make_unique<CscDigitContainer>(m_idHelperSvc->cscIdHelper().module_hash_max())));
  ATH_MSG_DEBUG("recorded CscDigitContainer with name "<<cscDigits.key());
 
  if (m_isPileUp) return StatusCode::SUCCESS;
 
  // create and record the SDO container in StoreGate
  SG::WriteHandle<CscSimDataCollection> cscSimData(m_cscSimDataCollectionWriteHandleKey, ctx);
  ATH_CHECK(cscSimData.record(std::make_unique<CscSimDataCollection>()));
 
  //merging of the hit collection in getNextEvent method
  if (nullptr == m_thpcCSC ) {
    StatusCode sc = getNextEvent(ctx);
    if (StatusCode::FAILURE == sc) {
      ATH_MSG_INFO ( "There are no CSC hits in this event" );
      return sc; // there are no hits in this event
    }
  }
 
  ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this);
  rngWrapper->setSeed( name(), ctx );
 
  Collections_t collections;
  ATH_CHECK( CoreDigitization(collections,cscSimData.ptr(), rngWrapper->getEngine(ctx), ctx) );
  for (size_t coll_hash = 0; coll_hash < collections.size(); ++coll_hash) {
    if (collections[coll_hash]) {
      ATH_CHECK( cscDigits->addCollection (collections[coll_hash].release(), coll_hash) );
    }
  }
 
  return StatusCode::SUCCESS;
}

processAllSubEvents() [2/2]

virtual StatusCode IPileUpTool::processAllSubEvents

inherited

dummy implementation to allow compilation while all Digitization packages are migrated to use this new interface.

processBunchXing()

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

finaloverridevirtual

called for each active bunch-crossing to process current subEvents. bunchXing is in ns

Reimplemented from PileUpToolBase.

Definition at line 502 of file CscDigitizationTool.cxx.

{
  ATH_MSG_DEBUG("CscDigitizationTool::processBunchXing() " << bunchXing);
 
  using TimedHitCollList = PileUpMergeSvc::TimedList<CSCSimHitCollection>::type;
  TimedHitCollList hitCollList;
 
  if (!(m_mergeSvc->retrieveSubSetEvtData(m_inputObjectName, hitCollList, bunchXing,
                                          bSubEvents, eSubEvents).isSuccess()) &&
        hitCollList.empty()) {
    ATH_MSG_ERROR("Could not fill TimedHitCollList");
    return StatusCode::FAILURE;
  } else {
    ATH_MSG_VERBOSE(hitCollList.size() << " CSCSimHitCollection with key " <<
                    m_inputObjectName << " found");
  }
 
  TimedHitCollList::iterator iColl(hitCollList.begin());
  TimedHitCollList::iterator endColl(hitCollList.end());
 
  // Iterating over the list of collections
  for( ; iColl != endColl; ++iColl){
 
    CSCSimHitCollection *hitCollPtr = new CSCSimHitCollection(*iColl->second);
    PileUpTimeEventIndex timeIndex(iColl->first);
 
    ATH_MSG_DEBUG("CSCSimHitCollection found with " << hitCollPtr->size() <<
                  " hits");
    ATH_MSG_VERBOSE("time index info. time: " << timeIndex.time()
                    << " index: " << timeIndex.index()
                    << " type: " << timeIndex.type());
 
    m_thpcCSC->insert(timeIndex, hitCollPtr);
    m_cscHitCollList.push_back(hitCollPtr);
 
  }
 
  return StatusCode::SUCCESS;
}

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

m_amplification

Gaudi::Property<double> CscDigitizationTool::m_amplification {this, "amplification", 0.58e5, ""}

private

Definition at line 103 of file CscDigitizationTool.h.

m_cscDigitContainerKey

SG::WriteHandleKey<CscDigitContainer> CscDigitizationTool::m_cscDigitContainerKey {this,"OutputObjectName","CSC_DIGITS","CSC digit container object"}

private

Definition at line 95 of file CscDigitizationTool.h.

m_cscDigitizer

std::unique_ptr<CSC_Digitizer> CscDigitizationTool::m_cscDigitizer {nullptr}

private

Definition at line 97 of file CscDigitizationTool.h.

m_cscHitCollList

std::list<CSCSimHitCollection*> CscDigitizationTool::m_cscHitCollList

private

Definition at line 107 of file CscDigitizationTool.h.

m_cscSimDataCollectionWriteHandleKey

SG::WriteHandleKey<CscSimDataCollection> CscDigitizationTool::m_cscSimDataCollectionWriteHandleKey {this,"CSCSimDataCollectionOutputName","CSC_SDO","WriteHandleKey for Output CscSimDataCollection"}

private

Definition at line 94 of file CscDigitizationTool.h.

m_driftVelocity

Gaudi::Property<double> CscDigitizationTool::m_driftVelocity {this, "DriftVelocity", 60, ""}

private

Definition at line 115 of file CscDigitizationTool.h.

m_electronEnergy

Gaudi::Property<double> CscDigitizationTool::m_electronEnergy {this, "ElectronEnergy", 66, ""}

private

Definition at line 116 of file CscDigitizationTool.h.

m_filterPassed

bool PileUpToolBase::m_filterPassed {true}

protectedinherited

Definition at line 60 of file PileUpToolBase.h.

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.

m_hitsContainerKey

SG::ReadHandleKey<CSCSimHitCollection> CscDigitizationTool::m_hitsContainerKey {this, "InputObjectName", "CSC_Hits", "name of the input objects"}

private

Definition at line 92 of file CscDigitizationTool.h.

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> CscDigitizationTool::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

private

Definition at line 99 of file CscDigitizationTool.h.

m_includePileUpTruth

Gaudi::Property<bool> CscDigitizationTool::m_includePileUpTruth {this, "IncludePileUpTruth", true, "Include pile-up truth info"}

private

Definition at line 109 of file CscDigitizationTool.h.

m_inputObjectName

std::string CscDigitizationTool::m_inputObjectName {""}

private

Definition at line 93 of file CscDigitizationTool.h.

m_isPileUp

Gaudi::Property<bool> CscDigitizationTool::m_isPileUp {this, "isPileUp", false, ""}

private

Definition at line 113 of file CscDigitizationTool.h.

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.

m_maskBadChannel

Gaudi::Property<bool> CscDigitizationTool::m_maskBadChannel {this, "maskBadChannels", true, ""}

private

Definition at line 102 of file CscDigitizationTool.h.

m_mergeSvc

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

private

Definition at line 119 of file CscDigitizationTool.h.

m_newDigitEDM

Gaudi::Property<bool> CscDigitizationTool::m_newDigitEDM {this, "NewDigitEDM", true, ""}

private

Definition at line 114 of file CscDigitizationTool.h.

m_NInterFixed

Gaudi::Property<bool> CscDigitizationTool::m_NInterFixed {this, "NInterFixed", false, ""}

private

Definition at line 117 of file CscDigitizationTool.h.

m_onlyUseContainerName

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

private

Definition at line 91 of file CscDigitizationTool.h.

m_pcalib

ToolHandle<ICscCalibTool> CscDigitizationTool::m_pcalib {this, "cscCalibTool", "CscCalibTool", "CSC calibration tool"}

private

Definition at line 89 of file CscDigitizationTool.h.

m_pedestal

Gaudi::Property<double> CscDigitizationTool::m_pedestal {this, "pedestal",0.0, ""}

private

Definition at line 101 of file CscDigitizationTool.h.

m_rndmSvc

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

private

Definition at line 121 of file CscDigitizationTool.h.

m_thpcCSC

TimedHitCollection<CSCSimHit>* CscDigitizationTool::m_thpcCSC {nullptr}

private

Definition at line 106 of file CscDigitizationTool.h.

m_timeWindowLowerOffset

Gaudi::Property<double> CscDigitizationTool::m_timeWindowLowerOffset {this, "WindowLowerOffset", -25., ""}

private

Definition at line 111 of file CscDigitizationTool.h.

m_timeWindowUpperOffset

Gaudi::Property<double> CscDigitizationTool::m_timeWindowUpperOffset {this, "WindowUpperOffset", +25., ""}

private

Definition at line 112 of file CscDigitizationTool.h.

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.

---

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

• CscDigitizationTool.h
• CscDigitizationTool.cxx