MultipassCellularPathFinder.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/trackFindingCDC/ca/CellularAutomaton.h>
#include <tracking/trackFindingCDC/ca/CellularPathFollower.h>
 
#include <tracking/trackFindingCDC/ca/Path.h>
#include <tracking/trackFindingCDC/ca/CellHolder.h>
 
#include <tracking/trackFindingCDC/utilities/StringManipulation.h>
 
#include <framework/core/ModuleParamList.h>
#include <framework/logging/Logger.h>
 
#include <vector>
 
namespace Belle2 {
  namespace TrackFindingCDC {
    template <class ACellHolder>
    class MultipassCellularPathFinder {
    public:
      MultipassCellularPathFinder()
      {
        // Experiment in how to specify the requirements of the template parameters
        // Somewhat incomplete
        static_assert_isCellHolder<ACellHolder>();
      }
 
    public:
      void exposeParameters(ModuleParamList* moduleParamList, const std::string& prefix)
      {
        moduleParamList->addParameter(prefixed(prefix, "caMode"),
                                      m_param_caMode,
                                      "Mode for the cellular automaton application"
                                      "*  * 'normal'    normal path search for high value paths"
                                      "*  * 'cells'     make path for each individual cell for debugging"
                                      "*  * 'relations' make path for each individual relation for debugging",
                                      m_param_caMode);
 
        moduleParamList->addParameter(prefixed(prefix, "minState"),
                                      m_param_minState,
                                      "The minimal accumulated state to follow",
                                      m_param_minState);
 
        moduleParamList->addParameter(prefixed(prefix, "minPathLength"),
                                      m_param_minPathLength,
                                      "The minimal path length to that is written to output",
                                      m_param_minPathLength);
 
      }
 
      void apply(const std::vector<ACellHolder*>& cellHolders,
                 const std::vector<WeightedRelation<ACellHolder>>& cellHolderRelations,
                 std::vector<Path<ACellHolder> >& paths)
      {
        B2ASSERT("Expected the relations to be sorted",
                 std::is_sorted(cellHolderRelations.begin(), cellHolderRelations.end()));
 
        // Forward all cells as paths
        if (m_param_caMode == "cells") {
          for (ACellHolder* cellHolder : cellHolders) {
            paths.push_back({cellHolder});
          }
          return;
        }
 
        // Forward all relations as paths
        if (m_param_caMode == "relations") {
          for (const WeightedRelation<ACellHolder>& cellHolderRelation : cellHolderRelations) {
            paths.push_back({cellHolderRelation.getFrom(), cellHolderRelation.getTo()});
          }
          return;
        }
 
        // Everything else is just normal
        if (m_param_caMode != "normal") {
          B2WARNING("Unrecognised caMode parameter value " << m_param_caMode);
          m_param_caMode = "normal";
        }
 
        // Multiple passes of the cellular automaton. One path is created
        // at a time denying all knots it picked up, applying the
        // cellular automaton again and so on. No best candidate
        // analysis needed
        for (ACellHolder* cellHolder : cellHolders) {
          cellHolder->unsetAndForwardMaskedFlag();
        }
 
        B2DEBUG(25, "Apply multipass cellular automat");
        do {
          m_cellularAutomaton.applyTo(cellHolders, cellHolderRelations);
 
          auto lessStartCellState = [this](ACellHolder * lhs, ACellHolder * rhs) {
            const AutomatonCell& lhsCell = lhs->getAutomatonCell();
            const AutomatonCell& rhsCell = rhs->getAutomatonCell();
 
            // Cells with state lower than the minimal cell state are one lowest category
            if (rhsCell.getCellState() < m_param_minState) return false;
            if (lhsCell.getCellState() < m_param_minState) return true;
 
            return (std::make_tuple(lhsCell.hasPriorityPathFlag(),
                                    lhsCell.hasStartFlag(),
                                    lhsCell.getCellState()) <
                    std::make_tuple(rhsCell.hasPriorityPathFlag(),
                                    rhsCell.hasStartFlag(),
                                    rhsCell.getCellState()));
          };
 
          auto itStartCellHolder =
            std::max_element(cellHolders.begin(), cellHolders.end(), lessStartCellState);
          if (itStartCellHolder == cellHolders.end()) break;
          else if (not(*itStartCellHolder)->getAutomatonCell().hasStartFlag()) break;
          else if ((*itStartCellHolder)->getAutomatonCell().getCellState() < m_param_minState) break;
 
          const ACellHolder* highestCellHolder = *itStartCellHolder;
 
          Path<ACellHolder> newPath = m_cellularPathFollower.followSingle(highestCellHolder,
                                      cellHolderRelations,
                                      m_param_minState);
 
          if (newPath.empty()) break;
 
          // Block the used items
          for (ACellHolder* cellHolderPtr : newPath) {
            cellHolderPtr->setAndForwardMaskedFlag();
          }
 
          // Block the items that have already used components
          for (ACellHolder* cellHolder : cellHolders) {
            cellHolder->receiveMaskedFlag();
          }
 
          if (static_cast<int>(newPath.size()) >= m_param_minPathLength) {
            paths.push_back(std::move(newPath));
          }
 
        } while (true);
      }
 
    private:
      std::string m_param_caMode{"normal"};
 
      Weight m_param_minState = -INFINITY;
 
      int m_param_minPathLength = 0;
 
      CellularAutomaton<ACellHolder> m_cellularAutomaton;
 
      CellularPathFollower<ACellHolder> m_cellularPathFollower;
    };
  }
}