ChooseableFilter.icc.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 <tracking/trackingUtilities/filters/base/ChooseableFilter.dcl.h>
 
#include <tracking/trackingUtilities/filters/base/FilterFactory.icc.h>
 
#include <framework/core/ModuleParamList.templateDetails.h>
 
#include <tracking/trackingUtilities/utilities/StringManipulation.h>
 
#include <memory>
#include <string>
 
namespace Belle2 {
  namespace TrackingUtilities {
 
    template <class AFilter>
    Chooseable<AFilter>::Chooseable(std::unique_ptr<FilterFactory<AFilter>> filterFactory)
      : m_param_filterName(filterFactory ? filterFactory->getDefaultFilterName() : "")
      , m_param_filterParameters()
      , m_filterFactory(std::move(filterFactory))
    {
      B2ASSERT("Constructing a chooseable filter with no factory", m_filterFactory);
    }
 
    template <class AFilter>
    Chooseable<AFilter>::Chooseable(std::unique_ptr<FilterFactory<AFilter>> filterFactory,
                                    const std::string& filterName)
      : m_param_filterName(filterName)
      , m_param_filterParameters()
      , m_filterFactory(std::move(filterFactory))
    {
      B2ASSERT("Constructing a chooseable filter with no factory", m_filterFactory);
    }
 
    template <class AFilter>
    void Chooseable<AFilter>::exposeParameters(ModuleParamList* moduleParamList, const std::string& prefix)
    {
      Super::exposeParameters(moduleParamList, prefix);
      if (m_param_filterName == "") {
        moduleParamList->addParameter(prefixed(prefix, "filter"),
                                      m_param_filterName,
                                      m_filterFactory->createFiltersNameDescription());
      } else {
        moduleParamList->addParameter(prefixed(prefix, "filter"),
                                      m_param_filterName,
                                      m_filterFactory->createFiltersNameDescription(),
                                      m_param_filterName);
      }
 
      m_param_filterParameters.addParameter(moduleParamList,
                                            prefixed(prefix, "filterParameters"),
                                            m_filterFactory->createFiltersParametersDescription());
    }
 
    template <class AFilter>
    void Chooseable<AFilter>::initialize()
    {
      m_filter = m_filterFactory->create(m_param_filterName);
      if (not m_filter) {
        B2ERROR("Could not create filter with name " << m_param_filterName);
        return;
      }

      const std::string prefix = "";
      m_filter->exposeParameters(&m_filterParamList, prefix);
      m_param_filterParameters.assignTo(&m_filterParamList);
 
      this->addProcessingSignalListener(m_filter.get());
      Super::initialize();
    }
 
    template <class AFilter>
    void Chooseable<AFilter>::beginRun()
    {
 
      if (m_filter) {
        // Re-uses the already-registered T& references — no exposeParameters() call needed
        m_param_filterParameters.assignTo(&m_filterParamList);
      }
      Super::beginRun();
    }
 
 
 
    template <class AFilter>
    bool Chooseable<AFilter>::needsTruthInformation()
    {
      return m_filter->needsTruthInformation();
    }
 
    template <class AFilter>
    Weight Chooseable<AFilter>::operator()(const Object& object)
    {
      return (*m_filter)(object);
    }
 
    template <class AFilter>
    Weight Chooseable<AFilter>::operator()(const Object& object) const
    {
      return (*m_filter)(object);
    }
 
    template <class AFilter>
    std::vector<float> Chooseable<AFilter>::operator()(const std::vector <Object*>& objs)
    {
      return (*m_filter)(objs);
    }
 
    template <class AFilterFactory>
    ChooseableFilter<AFilterFactory>::ChooseableFilter()
      : Super(std::make_unique<AFilterFactory>())
    {
    }
 
    template <class AFilterFactory>
    ChooseableFilter<AFilterFactory>::ChooseableFilter(const std::string& filterName)
      : Super(std::make_unique<AFilterFactory>(), filterName)
    {
    }
  }
}