FindletModule.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2015 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Oliver Frost                                             *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
#pragma once
 
#include <tracking/trackFindingCDC/rootification/StoreWrappedObjPtr.h>
 
#include <tracking/trackFindingCDC/utilities/EvalVariadic.h>
 
#include <framework/core/Module.h>
#include <framework/core/ModuleParamList.h>
 
#include <utility>
#include <vector>
#include <array>
 
namespace Belle2 {
  namespace TrackFindingCDC {
 
    template<class AFindlet>
    class FindletModule : public Module {
 
    private:
      using Super = Module;
 
      using IOTypes = typename AFindlet::IOTypes;
 
      template<std::size_t I>
      using IOType = typename std::tuple_element<I, IOTypes>::type;
 
      template<class T>
      using Stripped = typename std::remove_reference<typename std::remove_const<T>::type>::type;
 
      template<std::size_t I>
      using StrippedIOType = Stripped<IOType<I>>;
 
      template <std::size_t I>
      using StoreVector = StoreWrappedObjPtr<std::vector<StrippedIOType<I>>>;
 
      template<std::size_t I>
      static constexpr bool isInputStoreVector()
      {
        return std::is_const<IOType<I>>::value or std::is_reference<IOType<I>>::value;
      }
 
      static const std::size_t c_nTypes = std::tuple_size<IOTypes>::value;
 
      using Indices = std::make_index_sequence<c_nTypes>;
 
    public:
      explicit FindletModule(const std::array<std::string, c_nTypes>& storeVectorNames = {})
        : m_param_storeVectorNames(storeVectorNames)
      {
        this->setPropertyFlags(c_ParallelProcessingCertified | c_TerminateInAllProcesses);
        std::string description = "Findlet: ";
        if (std::tuple_size<IOTypes>() == 0) {
          // Drop Findlet prefix for full finders with no IOTypes
          description = "";
        }
 
        description += m_findlet.getDescription();
        this->setDescription(description);
 
        this->addStoreVectorParameters(Indices());
 
        ModuleParamList moduleParamList = this->getParamList();
 
        const std::string prefix = "";
        m_findlet.exposeParameters(&moduleParamList, prefix);
 
        this->setParamList(moduleParamList);
      }
 
      virtual ~FindletModule() = default;
 
      virtual void initialize() override
      {
        Super::initialize();
        this->requireOrRegisterStoreVectors(Indices());
        m_findlet.initialize();
      }
 
      virtual void beginRun() override
      {
        Super::beginRun();
        m_findlet.beginRun();
      }
 
      virtual void event() override
      {
        m_findlet.beginEvent();
        this->createStoreVectors(Indices());
        applyFindlet(Indices());
      }
 
      virtual void endRun() override
      {
        m_findlet.endRun();
        Super::endRun();
      }
 
      virtual void terminate() override
      {
        m_findlet.terminate();
        Super::terminate();
      }
 
    private:
      template <size_t... Is>
      void applyFindlet(std::index_sequence<Is...>)
      {
        m_findlet.apply(*(getStoreVector<Is>())...);
      }
 
      template <size_t... Is>
      void createStoreVectors(std::index_sequence<Is...>)
      {
        evalVariadic((createStoreVector<Is>(), std::ignore)...);
      }
 
      template <size_t... Is>
      void requireOrRegisterStoreVectors(std::index_sequence<Is...>)
      {
        evalVariadic((requireStoreVector<Is>(), std::ignore) ...);
        evalVariadic((registerStoreVector<Is>(), std::ignore) ...);
      }
 
      template <std::size_t I>
      void requireStoreVector()
      {
        if (isInputStoreVector<I>()) {
          getStoreVector<I>().isRequired();
        }
      }
 
      template <std::size_t I>
      void registerStoreVector()
      {
        if (not isInputStoreVector<I>()) {
          getStoreVector<I>().registerInDataStore(DataStore::c_DontWriteOut | DataStore::c_ErrorIfAlreadyRegistered);
        }
      }
 
      template<std::size_t I>
      void createStoreVector()
      {
        if (not getStoreVector<I>().isValid()) {
          getStoreVector<I>().construct();
        }
      }
 
      template<std::size_t I>
      StoreVector<I> getStoreVector()
      {
        StoreVector<I> storeVector(m_param_storeVectorNames[I]);
        return storeVector;
      }
 
      template<size_t ... Is>
      void addStoreVectorParameters(std::index_sequence<Is...>)
      {
        evalVariadic((addStoreVectorParameter<Is>(), std::ignore)...);
      }
 
      template<std::size_t I>
      void addStoreVectorParameter()
      {
        std::string name = getStoreVectorParameterName<I>();
        std::string description = getStoreVectorParameterDescription<I>();
        if (m_param_storeVectorNames[I] == "") {
          // Make a forced parameter
          this->addParam(name,
                         m_param_storeVectorNames[I],
                         description);
        } else {
          // Make an unforced parameter
          this->addParam(name,
                         m_param_storeVectorNames[I],
                         description,
                         m_param_storeVectorNames[I]);
        }
      }
 
      template <std::size_t I>
      std::string getStoreVectorParameterName() const
      {
        bool primary = I == GetIndexInTuple<IOType<I>, IOTypes>::value;
        int order = primary ? 1 : 2;
        bool input = isInputStoreVector<I>();
 
        // Just a little bit of ADL
        std::string classParameterName = getClassMnemomicParameterName(static_cast<StrippedIOType<I>*>(nullptr));
        return getStoreVectorParameterName(classParameterName, order, input);
      }
 
      template<std::size_t I>
      std::string getStoreVectorParameterDescription() const
      {
        bool primary = I == GetIndexInTuple<IOType<I>, IOTypes>::value;
        int order = primary ? 1 : 2;
        bool input = isInputStoreVector<I>();
 
        // Just a little bit of ADL
        std::string classParameterDescription = getClassMnemomicParameterDescription(static_cast<StrippedIOType<I>*>(nullptr));
        return getStoreVectorParameterDescription(classParameterDescription, order, input);
      }
 
      std::string
      getStoreVectorParameterName(std::string classMnenomic, int order, bool input) const
      {
        std::string orderPrefix;
        if (order == 1) {
          orderPrefix = "";
        } else if (order == 2) {
          orderPrefix = "secondary";
        } else {
          B2ERROR("More than two inputs of the same type are not supported");
        }
        std::string inputPrefix = input ? "input" : "";
 
        if (input or order > 1) {
          classMnenomic[0] = ::toupper(classMnenomic.at(0));
        }
        if (input and order > 1) {
          inputPrefix[0] = ::toupper(inputPrefix.at(0));
        }
 
        return orderPrefix + inputPrefix + classMnenomic + "s";
      }
 
      std::string getStoreVectorParameterDescription(const std::string& classMnenomic, int order, bool input) const
      {
        std::string orderPrefix;
        if (order == 1) {
          orderPrefix = "";
        } else if (order == 2) {
          orderPrefix = "secondary ";
        } else {
          B2ERROR("More than two inputs of the same type are not supported");
        }
        std::string inputPrefix = input ? "input " : "";
        return "Name of the " + orderPrefix + inputPrefix + classMnenomic + " vector.";
      }
 
    private:
      std::array<std::string, c_nTypes> m_param_storeVectorNames;
 
      AFindlet m_findlet;
    };
  }
}