Overlay Namespace Reference

Helpers for overlaying Identifiable Containers. More...

Functions
template<>
void	mergeChannelData (HGTD_RDO &, const HGTD_RDO &, const IDC_OverlayBase *algorithm)
template<>
std::unique_ptr< HGTD_RDO_Collection >	copyCollection (const IdentifierHash &hashId, const HGTD_RDO_Collection *collection)
template<>
void	mergeChannelData (PixelRDORawData &, const PixelRDORawData &, const IDC_OverlayBase *algorithm)
template<>
std::unique_ptr< PixelRDO_Collection >	copyCollection (const IdentifierHash &hashId, const PixelRDO_Collection *collection, DataPool< Pixel1RawData > &dataItems)
template<>
std::unique_ptr< SCT_RDO_Collection >	copyCollection (const IdentifierHash &hashId, const SCT_RDO_Collection *collection, DataPool< SCT3_RawData > &dataItems)
template<>
void	mergeCollections (SCT_RDO_Collection *bkgCollection, SCT_RDO_Collection *signalCollection, SCT_RDO_Collection *outputCollection, const IDC_OverlayBase *algorithm, DataPool< SCT3_RawData > &dataItems)
template<>
void	mergeChannelData (MdtDigit &signalDigit, const MdtDigit &bkgDigit, const IDC_MuonOverlayBase *algorithm)
	template specialization function to add 2 MDT Digits - basically the operator+= A declaration of the specialization must happen before the template is used from the overlayContainer() method. More...
template<>
void	mergeChannelData (MmDigit &signalDigit, const MmDigit &bkgDigit, const IDC_MuonOverlayBase *algorithm)
	template specialization function to add 2 MM Digits - basically the operator+= A declaration of the specialization must happen before the template is used from the overlayContainer() method. More...
template<class Datum >
void	mergeMultiHits (const std::vector< Datum * > &bkgHits, const std::vector< Datum * > &signalHits, std::vector< Datum * > &outputHits)
	Merging of hits on the same channel. More...
template<class Collection >
void	mergeMultiHitCollections (Collection *bkgCollection, Collection *signalCollection, Collection *outputCollection)
template<>
void	mergeChannelData (sTgcDigit &signalDigit, const sTgcDigit &bkgDigit, const IDC_MuonOverlayBase *algorithm)
	template specialization function to add 2 sTGC Digits - basically the operator+= A declaration of the specialization must happen before the template is used from the overlayContainer() method. More...
template<class Collection >
std::unique_ptr< Collection >	copyCollection (const IdentifierHash &hashId, const Collection *collection)
template<typename Collection , typename Type >
std::unique_ptr< Collection >	copyCollection (const IdentifierHash &hashId, const Collection *collection, DataPool< Type > &dataItems)
template<typename Collection , typename Alg >
void	mergeCollections (Collection *bkgCollection, Collection *signalCollection, Collection *outputCollection, const Alg *algorithm)
template<typename Type , typename Collection , typename Alg >
void	mergeCollections (Collection *bkgCollection, Collection *signalCollection, Collection *outputCollection, const Alg *algorithm, DataPool< Type > &dataItems)
template<class Datum , class Alg >
void	mergeChannelData (Datum &baseDatum, const Datum &additionalDatum, const Alg *algorithm)
template<class IDC_Container >
std::string	debugPrint (const IDC_Container *container, unsigned numprint=25)
	Diagnostic output of Identifiable Containers. More...

Detailed Description

Helpers for overlaying Identifiable Containers.

Author

Tadej Novak

Function Documentation

copyCollection() [1/5]

template<class Collection >

std::unique_ptr<Collection> Overlay::copyCollection	(	const IdentifierHash &	hashId,
		const Collection *	collection
	)

copyCollection() [2/5]

template<typename Collection , typename Type >

std::unique_ptr<Collection> Overlay::copyCollection	(	const IdentifierHash &	hashId,
		const Collection *	collection,
		DataPool< Type > &	dataItems
	)

copyCollection() [3/5]

template<>

std::unique_ptr<HGTD_RDO_Collection> Overlay::copyCollection	(	const IdentifierHash &	hashId,
		const HGTD_RDO_Collection *	collection
	)

Definition at line 24 of file HGTD_Overlay.cxx.

  {
    auto outputCollection = std::make_unique<HGTD_RDO_Collection>(hashId);
    outputCollection->setIdentifier(collection->identify());
 
    for (const HGTD_RDO *existingDatum : *collection) {
      // Owned by the collection
      auto *datumCopy = new HGTD_RDO(existingDatum->identify(), existingDatum->getTOA(), existingDatum->getTOT(),
                                     existingDatum->getBCID(), existingDatum->getL1ID(), existingDatum->getL1A());
      outputCollection->push_back(datumCopy);
    }
 
    return outputCollection;
  }

copyCollection() [4/5]

template<>

std::unique_ptr<PixelRDO_Collection> Overlay::copyCollection	(	const IdentifierHash &	hashId,
		const PixelRDO_Collection *	collection,
		DataPool< Pixel1RawData > &	dataItems
	)

Definition at line 30 of file PixelOverlay.cxx.

                                        {
  auto outputCollection = std::make_unique<PixelRDO_Collection>(hashId);
  outputCollection->setIdentifier(collection->identify());
  outputCollection->clear(SG::VIEW_ELEMENTS);
  outputCollection->reserve(collection->size());
  for (const PixelRDORawData *existingDatum : *collection) {
    Pixel1RawData *datumCopy = dataItems.nextElementPtr();
    (*datumCopy) =
        Pixel1RawData(existingDatum->identify(), existingDatum->getWord());
    outputCollection->push_back(datumCopy);
  }
  return outputCollection;
}

copyCollection() [5/5]

template<>

std::unique_ptr<SCT_RDO_Collection> Overlay::copyCollection	(	const IdentifierHash &	hashId,
		const SCT_RDO_Collection *	collection,
		DataPool< SCT3_RawData > &	dataItems
	)

Definition at line 19 of file SCTOverlay.cxx.

  {
    auto outputCollection = std::make_unique<SCT_RDO_Collection>(hashId);
    outputCollection->setIdentifier(collection->identify());
 
    // Elements created here are owned by the DataPool
    outputCollection->clear(SG::VIEW_ELEMENTS);
    outputCollection->reserve(collection->size());
 
    for (const SCT_RDORawData *existingDatum : *collection) {
      auto *oldDatum = dynamic_cast<const SCT3_RawData *>(existingDatum);
      if (not oldDatum) {
        throw std::runtime_error("Dynamic cast to SCT3_RawData failed in SCTOverlay.cxx, Overlay::copyCollection");
      }
      SCT3_RawData* datumCopy = dataItems.nextElementPtr();
      (*datumCopy) = SCT3_RawData(oldDatum->identify(), oldDatum->getWord(),
                                  &oldDatum->getErrorCondensedHit());
      outputCollection->push_back(datumCopy);
    }
 
    return outputCollection;
  }

debugPrint()

template<class IDC_Container >

std::string Overlay::debugPrint	(	const IDC_Container *	container,
		unsigned	numprint = 25
	)

Diagnostic output of Identifiable Containers.

mergeChannelData() [1/6]

template<class Datum , class Alg >

void Overlay::mergeChannelData	(	Datum &	baseDatum,
		const Datum &	additionalDatum,
		const Alg *	algorithm
	)

mergeChannelData() [2/6]

template<>

void Overlay::mergeChannelData	(	HGTD_RDO &	,
		const HGTD_RDO &	,
		const IDC_OverlayBase *	algorithm
	)

Definition at line 14 of file HGTD_Overlay.cxx.

  {
    algorithm->msg(MSG::DEBUG) << "Overlay::mergeChannelData<HGTD_RDORawData>(): "
      << "Merging of data on the same channel is not explicitly implemented for HGTD_RDORawData" << endmsg;
  }

mergeChannelData() [3/6]

template<>

void Overlay::mergeChannelData	(	MdtDigit &	signalDigit,
		const MdtDigit &	bkgDigit,
		const IDC_MuonOverlayBase *	algorithm
	)

template specialization function to add 2 MDT Digits - basically the operator+= A declaration of the specialization must happen before the template is used from the overlayContainer() method.

So we just put this implementation at the beginning of this file.

signal masks the background - no correction to the ADC FIXME: Probably should return the masked hit as well

Physics hit masks the background hit - no correct to the AOD FIXME: Probably should return the masked hit as well

the 2 hits overlap withing the ADC integration window the ADC will add partially the TDC is from the first hit that crosses the threshold FIXME: how to add partially for correct - for now just add the ADD total

Definition at line 26 of file MdtOverlay.cxx.

  {
    // We want to use the integration window provided by MdtOverlay, thus the constraint
    const MdtOverlay *parent = dynamic_cast<const MdtOverlay *>(algorithm);
    if (!parent) {
      throw std::runtime_error("mergeChannelData<MdtDigit>() called by a wrong parent algorithm? Must be MdtOverlay.");
    }
 
    int sig_tdc = signalDigit.tdc();
    int bkg_tdc = bkgDigit.tdc();
 
    if ( abs(sig_tdc - bkg_tdc) > parent->adcIntegrationWindow() && sig_tdc < bkg_tdc ) {
      // do nothing - keep baseDigit.
    }
    else if ( abs(sig_tdc - bkg_tdc) > parent->adcIntegrationWindow() && sig_tdc > bkg_tdc ) {
      // Use the background digit as the final answer
      signalDigit = bkgDigit;
    }
    else if ( abs(sig_tdc - bkg_tdc) < parent->adcIntegrationWindow() )  {
      int tdc = std::min( signalDigit.tdc(), bkgDigit.tdc() );
      int adc = signalDigit.adc() + bkgDigit.adc();
      signalDigit = MdtDigit(signalDigit.identify(), tdc, adc);
    }
  }

mergeChannelData() [4/6]

template<>

void Overlay::mergeChannelData	(	MmDigit &	signalDigit,
		const MmDigit &	bkgDigit,
		const IDC_MuonOverlayBase *	algorithm
	)

template specialization function to add 2 MM Digits - basically the operator+= A declaration of the specialization must happen before the template is used from the overlayContainer() method.

So we just put this implementation at the beginning of this file.

signal masks the background

Background hit masks the signal hit

the 2 hits overlap withing the time integration window For now, just add total charge

Definition at line 27 of file MM_Overlay.cxx.

  {
    // We want to use the integration window provided by MmOverlay, thus the constraint
    const MM_Overlay *parent = dynamic_cast<const MM_Overlay *>(algorithm);
    if (!parent) {
      throw std::runtime_error("mergeChannelData<MmDigit>() called by a wrong parent algorithm? Must be MM_Overlay.");
    }
    float sig_time = signalDigit.stripResponseTime(); 
    float bkg_time = bkgDigit.stripResponseTime(); 
 
 
    // As of now, we need to decide how to overlay MM digits
    // NEEDS TO BE ADDRESSED
    // For this preliminary version of July 2019, use only the data from the 1st digit in vector. 
    if ( std::abs(sig_time - bkg_time) > parent->timeIntegrationWindow() && sig_time < bkg_time ) {
      // do nothing - keep baseDigit.
    }
    else if ( std::abs(sig_time - bkg_time) > parent->timeIntegrationWindow() && sig_time > bkg_time ) {
      // Use the background digit as the final answer
      signalDigit = bkgDigit;
    }
    else if ( std::abs(sig_time - bkg_time) < parent->timeIntegrationWindow() )  {
      // Use the earliest time
      // And use all the other values of the signal digit.
      float time = std::min( sig_time, bkg_time );
      float charge = signalDigit.stripResponseCharge() + bkgDigit.stripResponseCharge();
      signalDigit = MmDigit(signalDigit.identify(), time,  charge);
    }
  }

mergeChannelData() [5/6]

template<>

void Overlay::mergeChannelData	(	PixelRDORawData &	,
		const PixelRDORawData &	,
		const IDC_OverlayBase *	algorithm
	)

Definition at line 19 of file PixelOverlay.cxx.

                                                        {
  algorithm->msg(MSG::DEBUG) << "Overlay::mergeChannelData<PixelRDORawData>(): "
                             << "Merging of data on the same channel is not "
                                "explicitly implemented for PixelRDORawData"
                             << endmsg;
}

mergeChannelData() [6/6]

template<>

void Overlay::mergeChannelData	(	sTgcDigit &	signalDigit,
		const sTgcDigit &	bkgDigit,
		const IDC_MuonOverlayBase *	algorithm
	)

template specialization function to add 2 sTGC Digits - basically the operator+= A declaration of the specialization must happen before the template is used from the overlayContainer() method.

So we just put this implementation at the beginning of this file.

signal masks the background

Background hit masks the signal hit

the 2 hits overlap withing the time integration window For now, just add total charge

Definition at line 27 of file STGC_Overlay.cxx.

  {
    // We want to use the integration window provided by sTgcOverlay, thus the constraint
    const STGC_Overlay *parent = dynamic_cast<const STGC_Overlay *>(algorithm);
    if (!parent) {
      throw std::runtime_error("mergeChannelData<sTgcDigit>() called by a wrong parent algorithm? Must be STGC_Overlay.");
    }
 
    float sig_time = signalDigit.time();
    float bkg_time = bkgDigit.time();
 
    if ( abs(sig_time - bkg_time) > parent->timeIntegrationWindow() && sig_time < bkg_time ) {
      // do nothing - keep baseDigit.
    }
    else if ( abs(sig_time - bkg_time) > parent->timeIntegrationWindow() && sig_time > bkg_time ) {
      // Use the background digit as the final answer
      signalDigit = bkgDigit;
    }
    else if ( abs(sig_time - bkg_time) < parent->timeIntegrationWindow() )  {
      // Use the earliest time
      float time = std::min( signalDigit.time(), bkgDigit.time() );
      float charge = signalDigit.charge() + bkgDigit.charge();
      //signalDigit = sTgcDigit(signalDigit.identify(), time, charge);
      signalDigit = sTgcDigit(signalDigit.identify(), signalDigit.bcTag(), time, charge, signalDigit.isDead(), signalDigit.isPileup());
    }
  }

mergeCollections() [1/3]

template<typename Collection , typename Alg >

void Overlay::mergeCollections	(	Collection *	bkgCollection,
		Collection *	signalCollection,
		Collection *	outputCollection,
		const Alg *	algorithm
	)

mergeCollections() [2/3]

template<typename Type , typename Collection , typename Alg >

void Overlay::mergeCollections	(	Collection *	bkgCollection,
		Collection *	signalCollection,
		Collection *	outputCollection,
		const Alg *	algorithm,
		DataPool< Type > &	dataItems
	)

mergeCollections() [3/3]

template<>

void Overlay::mergeCollections	(	SCT_RDO_Collection *	bkgCollection,
		SCT_RDO_Collection *	signalCollection,
		SCT_RDO_Collection *	outputCollection,
		const IDC_OverlayBase *	algorithm,
		DataPool< SCT3_RawData > &	dataItems
	)

Definition at line 48 of file SCTOverlay.cxx.

  {
    // We want to use the SCT_ID helper provided by SCTOverlay, thus the constraint
    const SCTOverlay *parent = dynamic_cast<const SCTOverlay *>(algorithm);
    if (!parent) {
      throw std::runtime_error("mergeCollections<SCT_RDORawData>() called by a wrong parent algorithm? Must be SCTOverlay.");
    }
 
    if (bkgCollection->identify() != signalCollection->identify()) {
      throw std::runtime_error("mergeCollections<SCT_RDO_Collection>(): collection Id mismatch");
    }
 
    outputCollection->reserve(
        std::max(bkgCollection->size(), signalCollection->size()));
    const Identifier idColl =
        parent->get_sct_id()->wafer_id(signalCollection->identifyHash());
 
    // Strip hit timing information for Next, Current, Previous and Any BCs
    // Prepare one more strip to create the last one. The additional strip has no hits.
    std::bitset<SCTOverlay::NumberOfStrips+1> stripInfo[SCTOverlay::NumberOfBitSets];
    // Process background and signal in the wafer
    for (unsigned source = SCTOverlay::BkgSource; source < SCTOverlay::NumberOfSources; source++) {
      SCT_RDO_Collection::const_iterator rdo;
      SCT_RDO_Collection::const_iterator rdoEnd;
      if (source == SCTOverlay::BkgSource) { // background
        rdo = bkgCollection->begin();
        rdoEnd = bkgCollection->end();
      } else { // signal
        rdo = signalCollection->begin();
        rdoEnd = signalCollection->end();
      }
      // Loop over all RDOs in the wafer
      for (; rdo!=rdoEnd; ++rdo) {
        // Here  we'll just go with SCT3.
        const SCT3_RawData* rdo3 = dynamic_cast<const SCT3_RawData*>(*rdo);
        if (!rdo3) {
          std::ostringstream os;
          const auto& elt = **rdo;
          os << "mergeCollection<SCT_RDO_Collection>(): wrong datum format. Only SCT3_RawData are produced by SCT_RodDecoder and supported by overlay."
             << "For the supplied datum  typeid(datum).name() = " << typeid(elt).name();
          throw std::runtime_error(os.str());
        }
        int strip = parent->get_sct_id()->strip(rdo3->identify());
        int stripEnd = strip + rdo3->getGroupSize();
        int timeBin = rdo3->getTimeBin();
        for (; strip < stripEnd && strip < SCTOverlay::NumberOfStrips; strip++) {
          // Fill timing information for each strips, loop over 3 BCs
          for (unsigned int bc = SCTOverlay::NextBC; bc < SCTOverlay::NumberOfBCs; bc++) {
            if (timeBin & (1 << bc)) stripInfo[bc].set(strip);
          }
        }
      }
    }
    // Get OR for AnyBC, loop over 3 BCs
    for (unsigned int bc = SCTOverlay::NextBC; bc < SCTOverlay::NumberOfBCs; bc++) {
      stripInfo[SCTOverlay::AnyBC] |= stripInfo[bc];
    }
    // Check if we need to use Expanded mode by checking if there is at least one hit in Next BC or Previous BC
    bool anyNextBCHits = stripInfo[SCTOverlay::NextBC].any();
    bool anyPreivousBCHits = stripInfo[SCTOverlay::PreviousBC].any();
    bool isExpandedMode = (anyNextBCHits or anyPreivousBCHits);
    // No error information is recorded because this information is not filled in data and no errors are assumed in MC.
    const int ERRORS = 0;
    const std::vector<int> errvec{};
    if (isExpandedMode) {
      // Expanded mode (record strip one by one)
      const int groupSize = 1;
      int tbin = 0;
      for (unsigned int strip = 0; strip < SCTOverlay::NumberOfStrips; strip++) {
        if (stripInfo[SCTOverlay::AnyBC][strip]) {
          tbin = 0;
          for (unsigned int bc = SCTOverlay::NextBC; bc < SCTOverlay::NumberOfBCs; bc++) {
            if (stripInfo[bc][strip]) {
              tbin |= (1 << bc);
            }
          }
          unsigned int SCT_Word = (groupSize | (strip << 11) | (tbin <<22) | (ERRORS << 25));
          Identifier rdoId = parent->get_sct_id()->strip_id(idColl, strip) ;
          // use the pool
          SCT3_RawData* datum = dataItems.nextElementPtr();
          (*datum) = SCT3_RawData(rdoId, SCT_Word, &errvec);
          outputCollection->push_back(datum);
        }
      }
    } else {
      // We can record consecutive hits into one RDO if all hits have timeBin of 010.
      unsigned int groupSize = 0;
      const int tbin = (1 << SCTOverlay::CurrentBC);
      for (unsigned int strip=0; strip<SCTOverlay::NumberOfStrips+1; strip++) { // Loop over one more strip to create the last one if any
        if (stripInfo[SCTOverlay::AnyBC][strip]) {
          groupSize++;
        } else {
          if (groupSize>0) {
            unsigned int firstStrip = strip - groupSize;
            unsigned int SCT_Word = (groupSize | (firstStrip << 11) | (tbin <<22) | (ERRORS << 25));
            Identifier rdoId = parent->get_sct_id()->strip_id(idColl, firstStrip) ;
            SCT3_RawData* datum = dataItems.nextElementPtr();
            (*datum) = SCT3_RawData(rdoId, SCT_Word, &errvec);
            outputCollection->push_back(datum);
            groupSize = 0;
          }
        }
      }
    }
  } // mergeCollections()

mergeMultiHitCollections()

template<class Collection >

void Overlay::mergeMultiHitCollections	(	Collection *	bkgCollection,
		Collection *	signalCollection,
		Collection *	outputCollection
	)

mergeMultiHits()

template<class Datum >

void Overlay::mergeMultiHits	(	const std::vector< Datum * > &	bkgHits,
		const std::vector< Datum * > &	signalHits,
		std::vector< Datum * > &	outputHits
	)

Merging of hits on the same channel.

Modifies the first argument by adding data from the second.. Implementations can assume that the arguments have the same Id. (That is, correspond to the same readout channel.)

A generic implementation of this template is provided in this package, but subdetectors can provide specializations suitable for their RDO type.

As a Collection is usually based on the DataVector elements are not const.