FilterMill.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/logging/Logger.h>
#include <string>
#include <vector>
#include <utility> // std::pair, std::move
#include <functional>
 
namespace Belle2 {
  template <class PointType>
  class FilterMill {
  public:
 
 
    using TwoHitFunction = typename std::function<double(const PointType&, const PointType&)>;
 
 
    using ThreeHitFunction = typename std::function<double(const PointType&, const PointType&, const PointType&)>;
 
 
    using FourHitFunction = typename std::function<double(const PointType&, const PointType&, const PointType&, const PointType&)>;
 
 
 
  protected:
    std::vector<std::pair<std::string, TwoHitFunction> > m_2Hitfilters;
 
 
    std::vector<std::pair<std::string, ThreeHitFunction> > m_3Hitfilters;
 
 
    std::vector<std::pair<std::string, FourHitFunction> > m_4Hitfilters;
 
 
    bool m_locked = false;
 
 
    void checkLocked(const std::string& name) const
    {
      if (!m_locked) {
        B2WARNING("FilterMill-checkLocked: Function " << name <<
                  " was executed although the Mill was not locked yet. This might be unintended...");
      }
    }
 
 
 
  public:
 
    struct HitPair {
      const PointType* outer; 
      const PointType* inner; 
    };
 
    struct HitTriplet {
      const PointType* outer; 
      const PointType* center; 
      const PointType* inner; 
    };
 
    struct HitQuadruplet {
      const PointType* outer; 
      const PointType* outerCenter; 
      const PointType* innerCenter; 
      const PointType* inner; 
    };
 
    FilterMill() :
      m_locked(false) {}
 
 
    void lockMill() { m_locked = true; }
 
 
    void add2HitFilter(std::pair<const std::string, TwoHitFunction> newFilter)
    {
      if (m_locked) {
        B2ERROR("FilterMill-add2HitFilter: someone tried to add filter " << newFilter.first <<
                " after lockdown! This is unintended behavior - doing nothing instead...");
        return;
      }
      B2DEBUG(20, "FilterMill::add2HitFilter: filter " << newFilter.first << " added");
      m_2Hitfilters.push_back(std::move(newFilter));
    }
 
 
    void add3HitFilter(std::pair<std::string, ThreeHitFunction> newFilter)
    {
      if (m_locked) {
        B2ERROR("FilterMill-add3HitFilter: someone tried to add filter " << newFilter.first <<
                " after lockdown! This is unintended behavior - doing nothing instead...");
        return;
      }
      B2DEBUG(20, "FilterMill::add3HitFilter: filter " << newFilter.first << " added");
      m_3Hitfilters.push_back(std::move(newFilter));
    }
 
 
    void add4HitFilter(std::pair<std::string, FourHitFunction> newFilter)
    {
      if (m_locked) {
        B2ERROR("FilterMill-add4HitFilter: someone tried to add filter " << newFilter.first <<
                " after lockdown! This is unintended behavior - doing nothing instead...");
        return;
      }
      B2DEBUG(20, "FilterMill::add4HitFilter: filter " << newFilter.first << " added");
      m_4Hitfilters.push_back(std::move(newFilter));
    }
 
 
    void grindData2Hit(const HitPair& dataSet,
                       std::vector<std::pair<std::string, double> >& collectedData) const
    {
      checkLocked("grindData2Hit");
      if (m_2Hitfilters.empty()) { B2DEBUG(20, "there are no 2-hit-filters stored, skipping grinding"); return; }
 
      std::vector<std::pair<std::string, double>> tempData;
      try {
        for (const auto& filterPack : m_2Hitfilters) {
 
          double result = filterPack.second(
                            *(dataSet.outer),
                            *(dataSet.inner));
          tempData.push_back({filterPack.first, result});
        }
      } catch (...) {
        std::string filterNames;
        for (const auto& filterPack : m_2Hitfilters) {
          filterNames += filterPack.first + " ";
        }
        B2WARNING("FilterMill:grindData2Hit: an exception was thrown by one of the Filters/SelectionVariables, that indicates strange input data, no data collected! Filters "
                  << filterNames << " were used and one of them did not work.");
        return;
      }
 
      collectedData.insert(collectedData.end(), tempData.begin(), tempData.end());
 
      B2DEBUG(20, "FilterMill::grindData2Hit: collectedData has now " << collectedData.size() << " entries");
    }
 
 
    void grindData3Hit(const HitTriplet& dataSet,
                       std::vector<std::pair<std::string, double> >& collectedData) const
    {
      checkLocked("grindData3Hit");
      if (m_3Hitfilters.empty()) { B2DEBUG(20, "there are no 3-hit-filters stored, skipping grinding"); return; }
 
      std::vector<std::pair<std::string, double>> tempData;
      try {
        for (const auto& filterPack : m_3Hitfilters) {
 
          double result = filterPack.second(
                            *(dataSet.outer),
                            *(dataSet.center),
                            *(dataSet.inner));
          tempData.push_back({filterPack.first, result});
        }
      } catch (...) {
        std::string filterNames;
        for (const auto& filterPack : m_2Hitfilters) {
          filterNames += filterPack.first + " ";
        }
        B2WARNING("FilterMill:grindData3Hit: an exception was thrown by one of the Filters/SelectionVariables, that indicates strange input data, no data collected! Filters "
                  << filterNames << " were used and one of them did not work.");
        return;
      }
      collectedData.insert(collectedData.end(), tempData.begin(), tempData.end());
 
      B2DEBUG(20, "FilterMill::grindData3Hit: collectedData has now " << collectedData.size() << " entries");
    }
 
 
    void grindData4Hit(const HitQuadruplet& dataSet,
                       std::vector<std::pair<std::string, double> >& collectedData) const
    {
      checkLocked("grindData4Hit");
      if (m_4Hitfilters.empty()) { B2DEBUG(20, "there are no 4-hit-filters stored, skipping grinding"); return; }
 
      std::vector<std::pair<std::string, double>> tempData;
      try {
        for (const auto& filterPack : m_4Hitfilters) {
 
          double result = filterPack.second(
                            *(dataSet.outer),
                            *(dataSet.outerCenter),
                            *(dataSet.innerCenter),
                            *(dataSet.inner));
          tempData.push_back({filterPack.first, result});
        }
      } catch (...) {
        B2WARNING("FilterMill:grindData4Hit: an exception was thrown by one of the Filters/SelectionVariables, that indicates strange input data, no data collected!");
        return;
      }
      collectedData.insert(collectedData.end(), tempData.begin(), tempData.end());
 
      B2DEBUG(20, "FilterMill::grindData4Hit: collectedData has now " << collectedData.size() << " entries");
    }
 
  };
 
}