The CellularAutomaton class This class serves as a functor for the algorithm itself. More...

#include <CellularAutomaton.h>

Inheritance diagram for CellularAutomaton< ContainerType, ValidatorType >:

Collaboration diagram for CellularAutomaton< ContainerType, ValidatorType >:

Public Types
using	BaseClass = TrackerAlgorithmBase< ContainerType, ValidatorType >
	typedef for the baseClass to get rid of the template arguments

Public Member Functions
	CellularAutomaton ()
	constructor

int	apply (ContainerType &aNetworkContainer) override final
	actual algorithm of Cellular Automaton, returns number of rounds needed to finish or -1 if CA was aborted More...

unsigned int	findSeeds (ContainerType &aNetworkContainer, bool strictSeeding=false) override final
	checks network given for seeds, returns number of seeds found (if strictSeeding is set to true, no subset of paths are stored, only unique ones). More...

virtual ValidatorType &	getValidator ()
	getter More...

virtual std::string	printStatistics ()
	returns current logging info of the algorithm (some stuff one wants to log about that algorithm

virtual void	setValidator (ValidatorType &aValidator)
	setter More...

Public Attributes
unsigned int	stopInRound = BaseClass::m_validator.nMaxIterations + 2
	aborts CA after stopInRound iterations - mainly for debugging purposes:

Protected Attributes
ValidatorType	m_validator
	something which checks the quality of the test so far (will be applied by the apply-function

Detailed Description

template<class ContainerType, class ValidatorType>
class Belle2::CellularAutomaton< ContainerType, ValidatorType >

The CellularAutomaton class This class serves as a functor for the algorithm itself.

Definition at line 31 of file CellularAutomaton.h.

Member Function Documentation

◆ apply()

int apply ( ContainerType & aNetworkContainer )

inlinefinaloverridevirtual

actual algorithm of Cellular Automaton, returns number of rounds needed to finish or -1 if CA was aborted

REDESIGNCOMMENT CELLULARAUTOMATON: optimization tip:

at the moment for each round the number of active cells is reduced, but the loop runs over all nodes/cells. TODO: Test Jakob's idea: Maybe its faster to recreate/refill an ActiveCell-List each round.

CAstep:

Updatestep:

catch bad case

Reimplemented from TrackerAlgorithmBase< ContainerType, ValidatorType >.

Definition at line 46 of file CellularAutomaton.h.

                                                          {
         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;

◆ findSeeds()

unsigned int findSeeds	(	ContainerType &	aNetworkContainer,
		bool	strictSeeding = `false`
	)

inlinefinaloverridevirtual

checks network given for seeds, returns number of seeds found (if strictSeeding is set to true, no subset of paths are stored, only unique ones).

WARNING: requires outerNodes to be set! (bidirectional network, not only directed to inner!).

Reimplemented from TrackerAlgorithmBase< ContainerType, ValidatorType >.

Definition at line 114 of file CellularAutomaton.h.

◆ getValidator()

virtual ValidatorType& getValidator ( )

inlinevirtualinherited

getter

returns the validator of the algorithm

Definition at line 38 of file TrackerAlgorithmBase.h.

40 { return 0; }

◆ setValidator()

virtual void setValidator ( ValidatorType & aValidator )

inlinevirtualinherited

setter

allows to set some condition for validating the algorithm

Definition at line 45 of file TrackerAlgorithmBase.h.

The documentation for this class was generated from the following file:

tracking/trackFindingVXD/algorithms/include/CellularAutomaton.h

Public Types

Public Member Functions

Public Attributes

Protected Attributes