CellularAutomaton.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2015 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Jakob Lettenbichler                                      *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
#pragma once
 
#include <tracking/trackFindingVXD/algorithms/TrackerAlgorithmBase.h>
 
namespace Belle2 {
  template<class ContainerType, class ValidatorType>
  class CellularAutomaton final : public TrackerAlgorithmBase<ContainerType, ValidatorType> {
  public:
    using BaseClass = TrackerAlgorithmBase<ContainerType, ValidatorType>;
 
 
    CellularAutomaton() : BaseClass() {}
 
 
    unsigned int stopInRound = BaseClass::m_validator.nMaxIterations + 2;
 
    // TODO: Check where the -1 is returned, for bad cases as described above.
    int apply(ContainerType& aNetworkContainer) override final
    {
      unsigned int activeCells = 1, // is set 1 because of following while loop.
                   deadCells = 0,
                   caRound = 1,
                   goodNeighbours = 0,
                   highestCellState = 0;
 
      // each iteration of following while loop is one CA-time-step
      while (activeCells != 0 and caRound < stopInRound) {
        activeCells = 0;
 
        // compare cells with inner neighbours:
        for (auto* aNode : aNetworkContainer) {
          auto& currentCell = aNode->getMetaInfo();
          if (currentCell.isActivated() == false) { continue; }
          goodNeighbours = 0;
 
          for (auto* aNeighbour :  aNode->getInnerNodes()) {
            // skip if neighbour has not the same state (NOTE if one wants to improve the versatility of the code,
            // this should actually become a member of the cell-class, which then can add some extra
            // stuff like checking for loops.
            if (currentCell != aNeighbour->getMetaInfo()) continue;
 
            goodNeighbours++;
          }
          if (goodNeighbours != 0) {
            currentCell.setStateUpgrade(true);
            activeCells++;
          } else {
            // WARNING setActivationState does provoke unintended behavior, since sometimes states can not be
            // upgraded in one round, but can in the next round!
            /*currentCell.setActivationState(false);*/
            deadCells++;
          }
        }
 
        for (auto* aNode : aNetworkContainer) {
          auto& currentCell = aNode->getMetaInfo();
          if (currentCell.isActivated() == false or currentCell.isUpgradeAllowed() == false) { continue; }
 
          currentCell.setStateUpgrade(false);
          currentCell.increaseState();
          if (currentCell.getState() > highestCellState) { highestCellState = currentCell.getState(); }
        }
 
        if (BaseClass::m_validator.isValidRound(caRound) == false) {
          break;
        }
 
        caRound++;
      } // CA main-loop
 
      return caRound;
    }
 
 
    unsigned int findSeeds(ContainerType& aNetworkContainer,  bool strictSeeding = false) override final
    {
      unsigned int nSeeds = 0;
      for (auto* aNode : aNetworkContainer) {
        if (strictSeeding && !(aNode->getOuterNodes().empty())) continue;
 
        if (BaseClass::m_validator.checkSeed(aNode->getMetaInfo()) == true) {
          aNode->getMetaInfo().setSeed(true);
          nSeeds++;
        }
      }
      return nSeeds;
    }
  };
}