Concrete tool for coping Calo cells. More...

#include <CaloCellFastCopyTool.h>

Inheritance diagram for CaloCellFastCopyTool:

Collaboration diagram for CaloCellFastCopyTool:

Public Member Functions
virtual StatusCode	initialize () override
virtual StatusCode	process (CaloCellContainer *theCellContainer, const EventContext &ctx) const override
virtual StatusCode	process (CaloConstCellContainer *theCellContainer, const EventContext &ctx) const override

Private Member Functions
StatusCode	viewNotAvoidingDuplicatesFindCellIsFast (const CaloCellContainer srcCont, CaloConstCellContainer destCont) const
StatusCode	viewAvoidingDuplicatesFindCellIsFast (const CaloCellContainer srcCont, CaloConstCellContainer destCont) const
StatusCode	viewNotAvoidingDuplicatesFindCellIsNotFast (const CaloCellContainer srcCont, CaloConstCellContainer destCont) const
StatusCode	viewAvoidingDuplicatesFindCellIsNotFast (const CaloCellContainer srcCont, CaloConstCellContainer destCont) const
template<class CONTAINER>
StatusCode	cloneNotAvoidingDuplicatesFindCellIsFast (const CaloCellContainer srcCont, CONTAINER destCont) const
template<class CONTAINER>
StatusCode	cloneAvoidingDuplicatesFindCellIsFast (const CaloCellContainer srcCont, CONTAINER destCont) const
template<class CONTAINER>
StatusCode	cloneNotAvoidingDuplicatesFindCellIsNotFast (const CaloCellContainer srcCont, CONTAINER destCont) const
template<class CONTAINER>
StatusCode	cloneAvoidingDuplicatesFindCellIsNotFast (const CaloCellContainer srcCont, CONTAINER destCont) const
StatusCode	dispatchCopy (const CaloCellContainer srcCont, CaloCellContainer destCont) const
StatusCode	dispatchCopyConst (const CaloCellContainer srcCont, CaloConstCellContainer destCont) const

Private Attributes
SG::ReadHandleKey< CaloCellContainer >	m_srcCellContainerKey {this, "InputName", "AllCalo"}
Gaudi::Property< bool >	m_avoidDuplicates {this, "AvoidDuplicates", false}
Gaudi::Property< bool >	m_isFindCellFast {this, "IsFindCellFast", false}
IdentifierHash	m_hashMax
const CaloCell_ID *	m_caloID = nullptr
	Pointer to CaloID helper.
Gaudi::Property< std::vector< std::string > >	m_acceptedSampleNames {this, "includeSamplings", {}}
std::vector< CaloCell_ID::SUBCALO >	m_acceptedCalos
std::vector< IdentifierHash >	m_acceptedCellHashes
std::vector< bool >	m_cellsToBeCopied

Detailed Description

Concrete tool for coping Calo cells.

CaloCellFastCopyTool to be used by CaloCellMaker algorithms. The tool copies Calo cells from an existing CaloCellContainer to the one processed by the CaloCellMaker algorithm. Properties of the tool: InputName - source cell container (default: "AllCalo") IncludeSamplings - name of CaloSampling to be copied into new CaloCellContainer AvoidDuplicates - indicates if this tool should avoid duplicates in new CaloCellContainer. IsFindCellFast - indicates if source CaloCellContainer find CaloCell fast (i.e. source CaloCellContainer is complete and ordered or has already initialized internal lookUpTable). In this case this tool can be very fast.

Definition at line 52 of file CaloCellFastCopyTool.h.

Member Function Documentation

◆ cloneAvoidingDuplicatesFindCellIsFast()

template<class CONTAINER>

StatusCode CaloCellFastCopyTool::cloneAvoidingDuplicatesFindCellIsFast	(	const CaloCellContainer *	srcCont,
		CONTAINER *	destCont ) const

private

Definition at line 228 of file CaloCellFastCopyTool.cxx.

{
 
  std::vector<bool> notInContainer(m_hashMax, true);
  CaloCellContainer::const_iterator itCell = destCont->begin();
  for (; itCell != destCont->end(); ++itCell) {
    notInContainer[(*itCell)->caloDDE()->calo_hash()] = false;
  }
 
  const CaloCell* cell;
  std::vector<IdentifierHash>::const_iterator it = m_acceptedCellHashes.begin();
  for (; it != m_acceptedCellHashes.end(); ++it) {
    if (notInContainer[*it]) {
      cell = srcCont->findCell(*it);
      if (cell) destCont->push_back_fast(cell->clone());
    }
  }
 
  destCont->resetLookUpTable();
  return StatusCode::SUCCESS;
}

◆ cloneAvoidingDuplicatesFindCellIsNotFast()

template<class CONTAINER>

StatusCode CaloCellFastCopyTool::cloneAvoidingDuplicatesFindCellIsNotFast	(	const CaloCellContainer *	srcCont,
		CONTAINER *	destCont ) const

private

Definition at line 274 of file CaloCellFastCopyTool.cxx.

{
  std::vector<bool> notInContainer(m_hashMax, true);
  CaloCellContainer::const_iterator itCell = destCont->begin();
  for (; itCell != destCont->end(); ++itCell) {
    notInContainer[(*itCell)->caloDDE()->calo_hash()] = false;
  }
 
  IdentifierHash cellHash;
  const CaloCell* cell;
  CaloCellContainer::const_iterator itSrcCell = srcCont->begin();
  for (; itSrcCell != srcCont->end(); ++itSrcCell) {
    cell = (*itSrcCell);
    cellHash = cell->caloDDE()->calo_hash();
    if (m_cellsToBeCopied[cellHash] && notInContainer[cellHash])
      destCont->push_back_fast(cell->clone());
  }
 
  destCont->resetLookUpTable();
  return StatusCode::SUCCESS;
}

◆ cloneNotAvoidingDuplicatesFindCellIsFast()

template<class CONTAINER>

StatusCode CaloCellFastCopyTool::cloneNotAvoidingDuplicatesFindCellIsFast	(	const CaloCellContainer *	srcCont,
		CONTAINER *	destCont ) const

private

Definition at line 211 of file CaloCellFastCopyTool.cxx.

{
  const CaloCell* cell;
  std::vector<IdentifierHash>::const_iterator it = m_acceptedCellHashes.begin();
  for (; it != m_acceptedCellHashes.end(); ++it) {
    cell = srcCont->findCell(*it);
    if (cell) destCont->push_back_fast(cell->clone());
  }
 
  destCont->resetLookUpTable();
  return StatusCode::SUCCESS;
}

◆ cloneNotAvoidingDuplicatesFindCellIsNotFast()

template<class CONTAINER>

StatusCode CaloCellFastCopyTool::cloneNotAvoidingDuplicatesFindCellIsNotFast	(	const CaloCellContainer *	srcCont,
		CONTAINER *	destCont ) const

private

Definition at line 254 of file CaloCellFastCopyTool.cxx.

{
  IdentifierHash cellHash;
  const CaloCell* cell;
  CaloCellContainer::const_iterator itSrcCell = srcCont->begin();
  for (; itSrcCell != srcCont->end(); ++itSrcCell) {
    cell = (*itSrcCell);
    cellHash = cell->caloDDE()->calo_hash();
    if (m_cellsToBeCopied[cellHash])
      destCont->push_back_fast(cell->clone());
  }
 
  destCont->resetLookUpTable();
  return StatusCode::SUCCESS;
}

◆ dispatchCopy()

StatusCode CaloCellFastCopyTool::dispatchCopy	(	const CaloCellContainer *	srcCont,
		CaloCellContainer *	destCont ) const

private

Definition at line 300 of file CaloCellFastCopyTool.cxx.

{
  using COPY_CELLS = StatusCode (CaloCellFastCopyTool::*)(const CaloCellContainer *, CaloCellContainer *) const;
 
  COPY_CELLS copyCells;
  if (m_isFindCellFast) {
    if (destCont->ownPolicy() == SG::OWN_ELEMENTS) {
      copyCells = (m_avoidDuplicates) ?
        (&CaloCellFastCopyTool::cloneAvoidingDuplicatesFindCellIsFast<CaloCellContainer>) :
        (&CaloCellFastCopyTool::cloneNotAvoidingDuplicatesFindCellIsFast<CaloCellContainer>);
    }
    else {
      REPORT_ERROR(StatusCode::FAILURE) << "Can't copy to a non-const view container.";
      return StatusCode::FAILURE;
    }
  }
  else {
    if (destCont->ownPolicy() == SG::OWN_ELEMENTS) {
      copyCells = (m_avoidDuplicates) ?
        (&CaloCellFastCopyTool::cloneAvoidingDuplicatesFindCellIsNotFast<CaloCellContainer>) :
        (&CaloCellFastCopyTool::cloneNotAvoidingDuplicatesFindCellIsNotFast<CaloCellContainer>);
    }
    else {
      REPORT_ERROR(StatusCode::FAILURE) << "Can't copy to a non-const view container.";
      return StatusCode::FAILURE;
    }
  }
 
  return (this->*copyCells)(srcCont, destCont);
}

◆ dispatchCopyConst()

StatusCode CaloCellFastCopyTool::dispatchCopyConst	(	const CaloCellContainer *	srcCont,
		CaloConstCellContainer *	destCont ) const

private

Definition at line 334 of file CaloCellFastCopyTool.cxx.

{
  using COPY_CONST_CELLS = StatusCode (CaloCellFastCopyTool::*)(const CaloCellContainer *, CaloConstCellContainer *) const;
 
  COPY_CONST_CELLS copyConstCells;
  if (m_isFindCellFast) {
    if (destCont->ownPolicy() == SG::OWN_ELEMENTS) {
      copyConstCells = (m_avoidDuplicates) ?
        (&CaloCellFastCopyTool::cloneAvoidingDuplicatesFindCellIsFast<CaloConstCellContainer>) :
        (&CaloCellFastCopyTool::cloneNotAvoidingDuplicatesFindCellIsFast<CaloConstCellContainer>);
    } else {
      copyConstCells = (m_avoidDuplicates) ? 
        (&CaloCellFastCopyTool::viewAvoidingDuplicatesFindCellIsFast) :
        (&CaloCellFastCopyTool::viewNotAvoidingDuplicatesFindCellIsFast);
    }
  } else {
    if (destCont->ownPolicy() == SG::OWN_ELEMENTS) {
      copyConstCells = (m_avoidDuplicates) ?
        (&CaloCellFastCopyTool::cloneAvoidingDuplicatesFindCellIsNotFast<CaloConstCellContainer>) :
        (&CaloCellFastCopyTool::cloneNotAvoidingDuplicatesFindCellIsNotFast<CaloConstCellContainer>);
    } else {
      copyConstCells = (m_avoidDuplicates) ?
        (&CaloCellFastCopyTool::viewAvoidingDuplicatesFindCellIsNotFast) :
        (&CaloCellFastCopyTool::viewNotAvoidingDuplicatesFindCellIsNotFast);
    }
  }
 
  return (this->*copyConstCells)(srcCont, destCont);
}

◆ initialize()

StatusCode CaloCellFastCopyTool::initialize ( )

overridevirtual

Definition at line 31 of file CaloCellFastCopyTool.cxx.

                                            {
 
  ATH_MSG_INFO( "In initialize ");
 
  ATH_CHECK( detStore()->retrieve(m_caloID));
  ATH_CHECK(m_srcCellContainerKey.initialize());
  std::vector<bool> acceptedSamplings(m_caloID->Unknown, false);
  std::vector<CaloSampling::CaloSample> acceptedSamples;
 
  std::vector<std::string>::const_iterator fName = m_acceptedSampleNames.begin();
  for (; fName != m_acceptedSampleNames.end(); ++fName) {
    CaloSampling::CaloSample sampInd = CaloSamplingHelper::getSamplingId(*fName);
    if (sampInd != CaloSampling::Unknown) {
      acceptedSamplings[sampInd] = true;
      acceptedSamples.push_back(sampInd);
    }
  }
 
  CaloSamplingHelper::getCalos(acceptedSamples, m_acceptedCalos);
 
  if (msgLvl(MSG::DEBUG)) {
 
    msg(MSG::DEBUG) << "Accepted calo samplings: ";
    std::vector<CaloSampling::CaloSample>::iterator itSampling = acceptedSamples.begin();
    for (; itSampling < acceptedSamples.end(); ++itSampling) {
      msg(MSG::DEBUG) << (int) (*itSampling) << "; ";
    }
    msg(MSG::DEBUG) << endmsg;
 
    msg(MSG::DEBUG) << "Accepted sub calos: ";
    std::vector<CaloCell_ID::SUBCALO>::iterator itCalo = m_acceptedCalos.begin();
    for (; itCalo < m_acceptedCalos.end(); ++itCalo) {
      msg(MSG::DEBUG) << (int) (*itCalo) << "; ";
    }
    msg(MSG::DEBUG) << endmsg;
  }
 
  m_hashMax = m_caloID->calo_cell_hash_max();
  ATH_MSG_DEBUG( "CaloCell hash max: " << m_hashMax);
 
  if (m_isFindCellFast) {
    for (IdentifierHash cellHash = 0; cellHash < m_hashMax; cellHash += 1) {
      if (acceptedSamplings[m_caloID->calo_sample(cellHash)]) {
        m_acceptedCellHashes.push_back(cellHash);
      }
    }
  } else {
    m_cellsToBeCopied.resize(m_hashMax, false);
    for (IdentifierHash cellHash = 0; cellHash < m_hashMax; cellHash += 1) {
      if (acceptedSamplings[m_caloID->calo_sample(cellHash)]) {
        m_cellsToBeCopied[cellHash] = true;
      }
    }
  }
 
  ATH_MSG_DEBUG( "Number of accepted hashes: " << m_acceptedCellHashes.size() );
 
 
  return StatusCode::SUCCESS;
}

◆ process() [1/2]

StatusCode CaloCellFastCopyTool::process	(	CaloCellContainer *	theCellContainer,
		const EventContext &	ctx ) const

overridevirtual

Definition at line 93 of file CaloCellFastCopyTool.cxx.

{
  // Retrieve source cell container
  SG::ReadHandle<CaloCellContainer> srcCont(m_srcCellContainerKey, ctx);
 
  ATH_CHECK( dispatchCopy (srcCont.cptr(), theCont) );
 
  std::vector<CaloCell_ID::SUBCALO>::const_iterator it = m_acceptedCalos.begin();
  for (; it != m_acceptedCalos.end(); ++it) {
    if (srcCont->hasCalo(*it)) theCont->setHasCalo(*it);
  }
 
  return StatusCode::SUCCESS;
}

◆ process() [2/2]

StatusCode CaloCellFastCopyTool::process	(	CaloConstCellContainer *	theCellContainer,
		const EventContext &	ctx ) const

overridevirtual

Definition at line 110 of file CaloCellFastCopyTool.cxx.

{
  // Retrieve source cell container
  SG::ReadHandle<CaloCellContainer> srcCont(m_srcCellContainerKey, ctx);
 
  ATH_CHECK( dispatchCopyConst (srcCont.cptr(), theCont) );
 
  std::vector<CaloCell_ID::SUBCALO>::const_iterator it = m_acceptedCalos.begin();
  for (; it != m_acceptedCalos.end(); ++it) {
    if (srcCont->hasCalo(*it)) theCont->setHasCalo(*it);
  }
 
  return StatusCode::SUCCESS;
}

◆ viewAvoidingDuplicatesFindCellIsFast()

StatusCode CaloCellFastCopyTool::viewAvoidingDuplicatesFindCellIsFast	(	const CaloCellContainer *	srcCont,
		CaloConstCellContainer *	destCont ) const

private

Definition at line 143 of file CaloCellFastCopyTool.cxx.

{
  std::vector<bool> notInContainer(m_hashMax, true);
  CaloCellContainer::const_iterator itCell = destCont->begin();
  for (; itCell != destCont->end(); ++itCell) {
    notInContainer[(*itCell)->caloDDE()->calo_hash()] = false;
  }
 
  const CaloCell* cell;
  std::vector<IdentifierHash>::const_iterator it = m_acceptedCellHashes.begin();
  for (; it != m_acceptedCellHashes.end(); ++it) {
    if (notInContainer[*it]) {
      cell = srcCont->findCell(*it);
      if (cell) destCont->push_back_fast(cell);
    }
  }
 
  destCont->resetLookUpTable();
  return StatusCode::SUCCESS;
}

◆ viewAvoidingDuplicatesFindCellIsNotFast()

StatusCode CaloCellFastCopyTool::viewAvoidingDuplicatesFindCellIsNotFast	(	const CaloCellContainer *	srcCont,
		CaloConstCellContainer *	destCont ) const

private

Definition at line 185 of file CaloCellFastCopyTool.cxx.

{
  std::vector<bool> notInContainer(m_hashMax, true);
  CaloCellContainer::const_iterator itCell = destCont->begin();
  for (; itCell != destCont->end(); ++itCell) {
    notInContainer[(*itCell)->caloDDE()->calo_hash()] = false;
  }
 
  IdentifierHash cellHash;
  const CaloCell* cell;
  CaloCellContainer::const_iterator itSrcCell = srcCont->begin();
  for (; itSrcCell != srcCont->end(); ++itSrcCell) {
    cell = (*itSrcCell);
    cellHash = cell->caloDDE()->calo_hash();
    if (m_cellsToBeCopied[cellHash] && notInContainer[cellHash])
      destCont->push_back_fast(cell);
  }
 
  destCont->resetLookUpTable();
  return StatusCode::SUCCESS;
}

◆ viewNotAvoidingDuplicatesFindCellIsFast()

StatusCode CaloCellFastCopyTool::viewNotAvoidingDuplicatesFindCellIsFast	(	const CaloCellContainer *	srcCont,
		CaloConstCellContainer *	destCont ) const

private

Definition at line 127 of file CaloCellFastCopyTool.cxx.

{
  const CaloCell* cell;
  std::vector<IdentifierHash>::const_iterator it = m_acceptedCellHashes.begin();
  for (; it != m_acceptedCellHashes.end(); ++it) {
    cell = srcCont->findCell(*it);
    if (cell) destCont->push_back_fast(cell);
  }
 
  destCont->resetLookUpTable();
  return StatusCode::SUCCESS;
}

◆ viewNotAvoidingDuplicatesFindCellIsNotFast()

StatusCode CaloCellFastCopyTool::viewNotAvoidingDuplicatesFindCellIsNotFast	(	const CaloCellContainer *	srcCont,
		CaloConstCellContainer *	destCont ) const

private

Definition at line 167 of file CaloCellFastCopyTool.cxx.

{
  IdentifierHash cellHash;
  const CaloCell* cell;
  CaloCellContainer::const_iterator itSrcCell = srcCont->begin();
  for (; itSrcCell != srcCont->end(); ++itSrcCell) {
    cell = (*itSrcCell);
    cellHash = cell->caloDDE()->calo_hash();
    if (m_cellsToBeCopied[cellHash])
      destCont->push_back_fast(cell);
  }
  destCont->resetLookUpTable();
  return StatusCode::SUCCESS;
}

Member Data Documentation

◆ m_acceptedCalos

std::vector<CaloCell_ID::SUBCALO> CaloCellFastCopyTool::m_acceptedCalos

private

Definition at line 102 of file CaloCellFastCopyTool.h.

◆ m_acceptedCellHashes

std::vector<IdentifierHash> CaloCellFastCopyTool::m_acceptedCellHashes

private

Definition at line 105 of file CaloCellFastCopyTool.h.

◆ m_acceptedSampleNames

Gaudi::Property<std::vector<std::string> > CaloCellFastCopyTool::m_acceptedSampleNames {this, "includeSamplings", {}}

private

Definition at line 101 of file CaloCellFastCopyTool.h.

101{this, "includeSamplings", {}};

◆ m_avoidDuplicates

Gaudi::Property<bool> CaloCellFastCopyTool::m_avoidDuplicates {this, "AvoidDuplicates", false}

private

Definition at line 96 of file CaloCellFastCopyTool.h.

96{this, "AvoidDuplicates", false};

◆ m_caloID

const CaloCell_ID* CaloCellFastCopyTool::m_caloID = nullptr

private

Pointer to CaloID helper.

Definition at line 99 of file CaloCellFastCopyTool.h.

◆ m_cellsToBeCopied

std::vector<bool> CaloCellFastCopyTool::m_cellsToBeCopied

private

Definition at line 106 of file CaloCellFastCopyTool.h.

◆ m_hashMax

IdentifierHash CaloCellFastCopyTool::m_hashMax

private

Definition at line 98 of file CaloCellFastCopyTool.h.

◆ m_isFindCellFast

Gaudi::Property<bool> CaloCellFastCopyTool::m_isFindCellFast {this, "IsFindCellFast", false}

private

Definition at line 97 of file CaloCellFastCopyTool.h.

97{this, "IsFindCellFast", false};

◆ m_srcCellContainerKey

SG::ReadHandleKey<CaloCellContainer> CaloCellFastCopyTool::m_srcCellContainerKey {this, "InputName", "AllCalo"}

private

Definition at line 95 of file CaloCellFastCopyTool.h.

95{this, "InputName", "AllCalo"};

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Function Documentation

◆ cloneAvoidingDuplicatesFindCellIsFast()

◆ cloneAvoidingDuplicatesFindCellIsNotFast()

◆ cloneNotAvoidingDuplicatesFindCellIsFast()

◆ cloneNotAvoidingDuplicatesFindCellIsNotFast()

◆ dispatchCopy()

◆ dispatchCopyConst()

◆ initialize()

◆ process() [1/2]

◆ process() [2/2]

◆ viewAvoidingDuplicatesFindCellIsFast()

◆ viewAvoidingDuplicatesFindCellIsNotFast()

◆ viewNotAvoidingDuplicatesFindCellIsFast()

◆ viewNotAvoidingDuplicatesFindCellIsNotFast()

Member Data Documentation

◆ m_acceptedCalos

◆ m_acceptedCellHashes

◆ m_acceptedSampleNames

◆ m_avoidDuplicates

◆ m_caloID

◆ m_cellsToBeCopied

◆ m_hashMax

◆ m_isFindCellFast

◆ m_srcCellContainerKey