StackTreeSearcher.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/findlets/base/Findlet.h>
 
#include <tracking/ckf/cdc/findlets/CDCCKFStateCreator.h>
#include <tracking/ckf/cdc/findlets/CDCCKFStateFilter.h>
#include <tracking/ckf/cdc/findlets/CDCCKFPathMerger.h>
#include <tracking/ckf/cdc/findlets/CDCCKFPathSelector.h>
 
#include <tracking/ckf/cdc/entities/CDCCKFState.h>
#include <tracking/ckf/cdc/entities/CDCCKFPath.h>
 
#include <tracking/trackingUtilities/utilities/StringManipulation.h>
#include <framework/core/ModuleParamList.h>
 
 
namespace Belle2 {
  class StackTreeSearcher : public
    TrackingUtilities::Findlet<CDCCKFPath, const TrackingUtilities::CDCWireHit* const> {
  public:
    StackTreeSearcher()
    {
      addProcessingSignalListener(&m_stateCreator);
      addProcessingSignalListener(&m_stateFilter);
      addProcessingSignalListener(&m_pathMerger);
      addProcessingSignalListener(&m_pathSelector);
    }

    void exposeParameters(ModuleParamList* moduleParamList, const std::string& prefix) override
    {
      m_stateCreator.exposeParameters(moduleParamList, prefix);
      m_stateFilter.exposeParameters(moduleParamList, TrackingUtilities::prefixed("state", prefix));
      m_pathMerger.exposeParameters(moduleParamList, prefix);
      m_pathSelector.exposeParameters(moduleParamList, TrackingUtilities::prefixed("path", prefix));
    }

    void setMaximalDeltaPhi(double maximalDeltaPhi) { m_stateCreator.setMaximalDeltaPhi(maximalDeltaPhi); }

    void setMaximalLayerJump(int maximalLayerJump) { m_stateCreator.setMaximalLayerJump(maximalLayerJump); }

    void setMaximalLayerJumpBackwardSeed(int maximalLayerJumpBackwardSeed)
    {
      m_stateCreator.setMaximalLayerJumpBackwardSeed(maximalLayerJumpBackwardSeed);
    }

    void setHitFindingDirection(const std::string& hitFindingDirection)
    {
      m_stateCreator.setHitFindingDirection(hitFindingDirection);
    }

    void setPathMaximalCandidatesInFlight(size_t pathMaximalCandidatesInFlight)
    {
      m_pathSelector.setMaximalCandidatesInFlight(pathMaximalCandidatesInFlight);
    }

    void setStateMaximalHitCandidates(size_t stateMaximalHitCandidates)
    {
      m_stateFilter.setMaximalHitCandidates(stateMaximalHitCandidates);
    }

    void apply(std::vector<CDCCKFPath>& paths,
               const std::vector<const TrackingUtilities::CDCWireHit*>& wireHits) override
    {
 
      if (paths.empty()) {
        return;
      }
 
      std::vector<CDCCKFPath> newPaths;
      std::vector<CDCCKFState> nextStates;
 
      for (CDCCKFPath& path : paths) {
        B2DEBUG(29, "Testing one path from " << path.back());
        m_stateCreator.apply(nextStates, path, wireHits);
        m_stateFilter.apply(path, nextStates);
 
        // TODO: Attention: if there is no hit anymore, the path will not be added to the final set!
        for (const auto& nextState : nextStates) {
          path.push_back(nextState);
 
          B2DEBUG(29, "will go to " << nextState);
          newPaths.push_back(path);
          path.pop_back();
        }
        B2DEBUG(29, "Now having " << newPaths.size() << " in flight");
        nextStates.clear();
      }
 
      B2DEBUG(29, "Having found " << newPaths.size() << " new paths");
      for (const auto& path : newPaths) {
        B2DEBUG(29, path);
      }
 
      m_pathMerger.apply(newPaths);
      B2DEBUG(29, "Having found " << newPaths.size() << " new paths after merging");
      for (const auto& path : newPaths) {
        B2DEBUG(29, path);
      }
 
      m_pathSelector.apply(newPaths);
      B2DEBUG(29, "Having found " << newPaths.size() << " new paths after selection");
      for (const auto& path : newPaths) {
        B2DEBUG(29, path);
      }
 
      if (newPaths.empty()) {
        return;
      }
 
      paths.swap(newPaths);
      newPaths.clear();
 
      apply(paths, wireHits);
    }
 
  private:
    CDCCKFStateCreator m_stateCreator;
    CDCCKFStateFilter m_stateFilter;
    CDCCKFPathMerger m_pathMerger;
    CDCCKFPathSelector m_pathSelector;
  };

}