BGOverlayExecutorModule.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2010 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Marko Staric                                             *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#pragma once
 
#include <framework/core/Module.h>
#include <framework/datastore/StoreArray.h>
#include <framework/dataobjects/DigitBase.h>
#include <string>
#include <map>
 
namespace Belle2 {
  class BGOverlayExecutorModule : public Module {
 
  public:
 
    BGOverlayExecutorModule();
 
    virtual ~BGOverlayExecutorModule();
 
    virtual void initialize() override;
 
    virtual void beginRun() override;
 
    virtual void event() override;
 
    virtual void endRun() override;
 
    virtual void terminate() 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 = ""; 
    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(100, "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(100, 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(100, 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); // BG digit not merged, therefore append
      }
 
      // debug printout
      int diff = size + bgDigits.getEntries() - digits.getEntries();
      B2DEBUG(100, digits.getName() << ": before " << size
              << " + " << bgDigits.getEntries() << "(BG)"
              << ", after " << digits.getEntries()
              << ", merged " << diff);
 
    }
 
  };
 
} // Belle2 namespace