xAOD::CutFlowHelpers Namespace Reference

Namespace for all helpers. More...

Functions
::TH1 *	nAcceptedEvents (const xAOD::CutBookkeeperContainer *cbkCont, const std::string &histName, int minCycle=0, int maxCycle=-1)
	Make a histogram of the number of accepted events from a container. More...
void	updateContainer (xAOD::CutBookkeeperContainer *contToUpdate, const xAOD::CutBookkeeperContainer *otherCont)
	Helper function to update a container with information from another one. More...

Detailed Description

Namespace for all helpers.

Function Documentation

nAcceptedEvents()

TH1 * xAOD::CutFlowHelpers::nAcceptedEvents	(	const xAOD::CutBookkeeperContainer *	cbkCont,
		const std::string &	histName,
		int	minCycle = 0,
		int	maxCycle = -1
	)

Make a histogram of the number of accepted events from a container.

Definition at line 22 of file xAODCutFlowHelpers.cxx.

                                                                           {
  // Lets first make some checks
  if (!cbkCont) return nullptr;
 
  // Get the maximum cycle number that we need to worry about
  const int cbkMaxCycle = cbkCont->maxCycle();
  if (maxCycle<0) maxCycle = cbkMaxCycle;
 
  // Now, find all xAOD::CutBookkeepers in the container that we care about
  std::vector<const xAOD::CutBookkeeper*> cbks;
  cbks.reserve(cbkCont->size());
  for ( const xAOD::CutBookkeeper* cbk : *cbkCont ){
    const int cycle = cbk->cycle();
    if ( cycle >= minCycle && cycle <= maxCycle ){ cbks.push_back(cbk); }
  }
  const std::size_t nCBK = cbks.size();
 
  // Create the histogram:
  const std::string histTitle = histName + ", minCycle=" + std::to_string(minCycle)
                                         + ", maxCycle=" + std::to_string(maxCycle);
  ::TH1* resultHist = new ::TH1D( histName.c_str(), histTitle.c_str(),
                                  nCBK, 0.0, nCBK );
  // Set some properties of the histogram
  resultHist->GetXaxis()->SetTitle("CutBookkeeper Name");
  resultHist->GetYaxis()->SetTitle("nAcceptedEvents");
 
  // Now, set the bin content for all bins
  for (std::size_t i=0; i<nCBK; ++i){
    const xAOD::CutBookkeeper* cbk = cbks[0];
    const double nEvents = static_cast<double>(cbk->nAcceptedEvents());
    const double error = std::sqrt(nEvents);
    const std::string& name = cbk->name();
    const int binIdx = static_cast<int>(i+1);
    resultHist->SetBinContent(binIdx,nEvents);
    resultHist->SetBinError(binIdx,error);
    resultHist->GetXaxis()->SetBinLabel(binIdx,name.c_str());
  }
 
  // Done
  return resultHist;
}

updateContainer()

void xAOD::CutFlowHelpers::updateContainer	(	xAOD::CutBookkeeperContainer *	contToUpdate,
		const xAOD::CutBookkeeperContainer *	otherCont
	)

Helper function to update a container with information from another one.

Definition at line 105 of file xAODCutFlowHelpers.cxx.

{
  std::size_t origSize = contToUpdate->size();
 
  // Vector of indices in contToUpdate of elements in otherCont.
  std::vector<std::size_t> otherIndexMap(otherCont->size());
  // Loop through otherCont.
  // If element already in contToUpdate, update event counts, otherwise create new element
  for (std::size_t i = 0; i < otherCont->size(); ++i) {
    const xAOD::CutBookkeeper *otherEBK = otherCont->at(i);
 
    // Loop through the container to be updated (contToUpdate) and see if we find a match
    bool foundEBKToUpdate{false};
    for (std::size_t j = 0; j < contToUpdate->size(); ++j) {
      xAOD::CutBookkeeper *ebkToUpdate = contToUpdate->at(j);
      // Check if they are identical, if so, update; else add otherEBK
      if (otherEBK->isEqualTo(ebkToUpdate)) {
        ebkToUpdate->setPayload(ebkToUpdate->payload() + otherEBK->payload());
        otherIndexMap[i] = j;
        foundEBKToUpdate = true;
        break;
      }
    } // End: Inner loop over contToUpdate
    if (!foundEBKToUpdate) {
      xAOD::CutBookkeeper *newEBK = new xAOD::CutBookkeeper(); // will be owned by the container
      if (newEBK->usingPrivateStore()) { newEBK->releasePrivateStore(); }
      newEBK->makePrivateStore(otherEBK);
      contToUpdate->push_back(newEBK);
      std::size_t ebIdx = newEBK->index();
      otherIndexMap[i] = ebIdx;
    }
  } // End: Outer loop over contToUpdate
 
  // Now, we still need to fix the cross-referencing of the newly added CutBookkkeepers
  for (std::size_t i = origSize; i < contToUpdate->size(); ++i) {
    xAOD::CutBookkeeper *ebkToModify = contToUpdate->at(i);
 
    // Parent check
    if (ebkToModify->hasParent()) {
      const xAOD::CutBookkeeper *oldParent = ebkToModify->parent();
      const xAOD::CutBookkeeper *newParent = resolveLink (oldParent,
                                                          *contToUpdate,
                                                          *otherCont,
                                                          otherIndexMap);
      ebkToModify->setParent (newParent);
    } // Done fixing parent
 
    // Children check
    std::vector<xAOD::CutBookkeeper *> newChildren;
    for ( std::size_t oldIdx = 0; oldIdx < ebkToModify->nChildren(); ++oldIdx) {
      const xAOD::CutBookkeeper *oldEBK = ebkToModify->child(oldIdx);
      newChildren.push_back(resolveLink(oldEBK,
                                        *contToUpdate,
                                        *otherCont,
                                        otherIndexMap));
    } // Done fixing children
    ebkToModify->setChildren(newChildren);
 
    // Used others check
    std::vector<xAOD::CutBookkeeper *> newOthers;
    for (std::size_t oldIdx = 0; oldIdx < ebkToModify->nUsedOthers(); ++oldIdx) {
      const xAOD::CutBookkeeper *oldEBK = ebkToModify->usedOther(oldIdx);
      newOthers.push_back(resolveLink(oldEBK,
                                      *contToUpdate,
                                      *otherCont,
                                      otherIndexMap));
    } // Done fixing used others
    ebkToModify->setUsedOthers(newOthers);
 
    // Siblings check
    std::vector<xAOD::CutBookkeeper*> newSiblings;
    for (std::size_t oldIdx = 0; oldIdx < ebkToModify->nSiblings(); ++oldIdx) {
      const xAOD::CutBookkeeper *oldEBK = ebkToModify->sibling(oldIdx);
      newSiblings.push_back(resolveLink(oldEBK,
                                        *contToUpdate,
                                        *otherCont,
                                        otherIndexMap));
    } // Done fixing siblings
    ebkToModify->setSiblings(newSiblings);
  } // Done fixing all cross references
}