BGOverlayExecutorModule.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <framework/core/Module.h>
#include <framework/datastore/StoreArray.h>
#include <framework/dataobjects/DigitBase.h>
#include <string>
#include <map>
#include <vector>
 
namespace Belle2 {

  class BGOverlayExecutorModule : public Module {
 
  public:

    BGOverlayExecutorModule();

    virtual void initialize() override;

    virtual void event() override;
 
  private:
 
    std::string m_PXDDigitsName; 
    std::string m_SVDShaperDigitsName; 
    std::string m_CDCHitsName;   
    std::string m_TOPDigitsName; 
    std::string m_ARICHDigitsName; 
    std::string m_KLMDigitsName; 
 
    std::string m_extensionName; 
    std::string m_BackgroundInfoInstanceName = ""; 
 
    std::vector<std::string> m_components; 
 
    bool m_addPXD = false; 
    bool m_addSVD = false; 
    bool m_addCDC = false; 
    bool m_addTOP = false; 
    bool m_addARICH = false; 
    bool m_addKLM = false; 

    template <class Digit>
    void registerDigits(const std::string& name)
    {
      StoreArray<Digit> digits(name);
      digits.isOptional();
      StoreArray<Digit> tmp; // just to get the default name
      std::string nameBG = tmp.getName() + m_extensionName;
      StoreArray<Digit> bgDigits(nameBG);
      bgDigits.isOptional();
      B2DEBUG(20, "optional input: " << digits.getName() << " " << bgDigits.getName());
    }

    template <class Digit>
    void addBGDigits(const std::string& name)
    {
      // simulated digits
      StoreArray<Digit> digits(name);
      if (!digits.isValid()) {
        B2DEBUG(20, digits.getName() << " are not valid");
        return;
      }
 
      // background digits
      StoreArray<Digit> tmp; // just to get the default name
      std::string nameBG = tmp.getName() + m_extensionName;
      StoreArray<Digit> bgDigits(nameBG);
      if (!bgDigits.isValid()) {
        B2DEBUG(20, bgDigits.getName() << " are not valid");
        return;
      }
 
      // map unique channel ID with simulated digits
      std::multimap<unsigned, Digit*> multimap;
      for (auto& digit : digits) {
        unsigned id = digit.getUniqueChannelID();
        // multimap.emplace(id, &digit); /* Clang doesn't know this member! */
        multimap.insert(std::pair<unsigned, Digit*>(id, &digit));
      }
 
      int size = digits.getEntries(); // for debug print
 
      // add BG digits to simulated ones
      typedef typename std::multimap<unsigned, Digit*>::iterator Iterator;
      for (const auto& bgDigit : bgDigits) {
        bool pileup = false;
        unsigned id = bgDigit.getUniqueChannelID();
        std::pair<Iterator, Iterator> range = multimap.equal_range(id);
        for (Iterator it = range.first; it != range.second; ++it) {
          auto* digit = it->second;
          pileup = digit->addBGDigit(&bgDigit) == DigitBase::c_DontAppend;
          if (pileup) break; // BG digit merged with simulated one
        }
        if (!pileup) digits.appendNew(bgDigit)->adjustAppendedBGDigit(); // BG digit not merged, therefore append and possibly modify
      }
 
      // debug printout
      B2DEBUG(20, digits.getName() << ": before " << size
              << " + " << bgDigits.getEntries() << "(BG)"
              << ", after " << digits.getEntries()
              << ", merged " << size + bgDigits.getEntries() - digits.getEntries());
 
    }
 
  };

} // Belle2 namespace