CellularAutomaton Class Reference

#include <CellularAutomaton.h>

Public Member Functions
	CellularAutomaton (CAGraph &graph)
void	createAndConnectCells (const std::vector< const HitDoublets * > &, const TrackingRegion &, const float, const float, const float)
void	evolve (const unsigned int)
void	findNtuplets (std::vector< CACell::CAntuplet > &, const unsigned int)
void	findTriplets (const std::vector< const HitDoublets * > &hitDoublets, std::vector< CACell::CAntuplet > &foundTriplets, const TrackingRegion &region, const float thetaCut, const float phiCut, const float hardPtCut)
std::vector< CACell > &	getAllCells ()

Private Attributes
std::vector< CACell >	allCells
std::vector< CACellStatus >	allStatus
CAGraph &	theLayerGraph
std::vector< std::vector< CACell * > >	theNtuplets
std::vector< unsigned int >	theRootCells

Detailed Description

Definition at line 12 of file CellularAutomaton.h.

Constructor & Destructor Documentation

CellularAutomaton()

CellularAutomaton::CellularAutomaton ( CAGraph &  graph )

inline

Definition at line 14 of file CellularAutomaton.h.

: theLayerGraph(graph) {}

Member Function Documentation

createAndConnectCells()

void CellularAutomaton::createAndConnectCells	(	const std::vector< const HitDoublets * > &	hitDoublets,
		const TrackingRegion &	region,
		const float	thetaCut,
		const float	phiCut,
		const float	hardPtCut
	)

Definition at line 5 of file CellularAutomaton.cc.

                                                                     {
  int tsize = 0;
  for (auto hd : hitDoublets) {
    tsize += hd->size();
  }
  allCells.reserve(tsize);
  unsigned int cellId = 0;
  float ptmin = region.ptMin();
  float region_origin_x = region.origin().x();
  float region_origin_y = region.origin().y();
  float region_origin_radius = region.originRBound();
 
  std::vector<bool> alreadyVisitedLayerPairs;
  alreadyVisitedLayerPairs.resize(theLayerGraph.theLayerPairs.size());
  for (auto visited : alreadyVisitedLayerPairs) {
    visited = false;
  }
  for (int rootVertex : theLayerGraph.theRootLayers) {
    std::queue<int> LayerPairsToVisit;
 
    for (int LayerPair : theLayerGraph.theLayers[rootVertex].theOuterLayerPairs) {
      LayerPairsToVisit.push(LayerPair);
    }
 
    unsigned int numberOfLayerPairsToVisitAtThisDepth = LayerPairsToVisit.size();
 
    while (not LayerPairsToVisit.empty()) {
      auto currentLayerPair = LayerPairsToVisit.front();
      auto &currentLayerPairRef = theLayerGraph.theLayerPairs[currentLayerPair];
      auto &currentInnerLayerRef = theLayerGraph.theLayers[currentLayerPairRef.theLayers[0]];
      auto &currentOuterLayerRef = theLayerGraph.theLayers[currentLayerPairRef.theLayers[1]];
      bool allInnerLayerPairsAlreadyVisited{true};
 
      for (auto innerLayerPair : currentInnerLayerRef.theInnerLayerPairs) {
        allInnerLayerPairsAlreadyVisited &= alreadyVisitedLayerPairs[innerLayerPair];
      }
 
      if (alreadyVisitedLayerPairs[currentLayerPair] == false and allInnerLayerPairsAlreadyVisited) {
        const HitDoublets *doubletLayerPairId = hitDoublets[currentLayerPair];
        auto numberOfDoublets = doubletLayerPairId->size();
        currentLayerPairRef.theFoundCells[0] = cellId;
        currentLayerPairRef.theFoundCells[1] = cellId + numberOfDoublets;
        for (unsigned int i = 0; i < numberOfDoublets; ++i) {
          allCells.emplace_back(
              doubletLayerPairId, i, doubletLayerPairId->innerHitId(i), doubletLayerPairId->outerHitId(i));
 
          currentOuterLayerRef.isOuterHitOfCell[doubletLayerPairId->outerHitId(i)].push_back(cellId);
 
          cellId++;
 
          auto &neigCells = currentInnerLayerRef.isOuterHitOfCell[doubletLayerPairId->innerHitId(i)];
          allCells.back().checkAlignmentAndTag(allCells,
                                               neigCells,
                                               ptmin,
                                               region_origin_x,
                                               region_origin_y,
                                               region_origin_radius,
                                               thetaCut,
                                               phiCut,
                                               hardPtCut);
        }
        assert(cellId == currentLayerPairRef.theFoundCells[1]);
        for (auto outerLayerPair : currentOuterLayerRef.theOuterLayerPairs) {
          LayerPairsToVisit.push(outerLayerPair);
        }
 
        alreadyVisitedLayerPairs[currentLayerPair] = true;
      }
      LayerPairsToVisit.pop();
      numberOfLayerPairsToVisitAtThisDepth--;
      if (numberOfLayerPairsToVisitAtThisDepth == 0) {
        numberOfLayerPairsToVisitAtThisDepth = LayerPairsToVisit.size();
      }
    }
  }
}

References allCells, cms::cuda::assert(), mps_fire::i, HitDoublets::innerHitId(), HitDoublets::outerHitId(), ptmin, HLT_2018_cff::region, HitDoublets::size(), theLayerGraph, CAGraph::theLayerPairs, CAGraph::theLayers, CAGraph::theRootLayers, and class-composition::visited.

Referenced by CAHitQuadrupletGenerator::hitNtuplets().

evolve()

void CellularAutomaton::evolve

(

const unsigned int

minHitsPerNtuplet

)

Definition at line 86 of file CellularAutomaton.cc.

                                                                   {
  allStatus.resize(allCells.size());
 
  unsigned int numberOfIterations = minHitsPerNtuplet - 2;
  // keeping the last iteration for later
  for (unsigned int iteration = 0; iteration < numberOfIterations - 1; ++iteration) {
    for (auto &layerPair : theLayerGraph.theLayerPairs) {
      for (auto i = layerPair.theFoundCells[0]; i < layerPair.theFoundCells[1]; ++i) {
        allCells[i].evolve(i, allStatus);
      }
    }
 
    for (auto &layerPair : theLayerGraph.theLayerPairs) {
      for (auto i = layerPair.theFoundCells[0]; i < layerPair.theFoundCells[1]; ++i) {
        allStatus[i].updateState();
      }
    }
  }
 
  // last iteration
 
  for (int rootLayerId : theLayerGraph.theRootLayers) {
    for (int rootLayerPair : theLayerGraph.theLayers[rootLayerId].theOuterLayerPairs) {
      auto foundCells = theLayerGraph.theLayerPairs[rootLayerPair].theFoundCells;
      for (auto i = foundCells[0]; i < foundCells[1]; ++i) {
        auto &cell = allStatus[i];
        allCells[i].evolve(i, allStatus);
        cell.updateState();
        if (cell.isRootCell(minHitsPerNtuplet - 2)) {
          theRootCells.push_back(i);
        }
      }
    }
  }
}

References allCells, allStatus, mps_fire::i, align_cfg::iteration, theLayerGraph, CAGraph::theLayerPairs, CAGraph::theLayers, theRootCells, and CAGraph::theRootLayers.

Referenced by CAHitQuadrupletGenerator::hitNtuplets().

findNtuplets()

void CellularAutomaton::findNtuplets	(	std::vector< CACell::CAntuplet > &	foundNtuplets,
		const unsigned int	minHitsPerNtuplet
	)

Definition at line 122 of file CellularAutomaton.cc.

                                                                           {
  CACell::CAntuple tmpNtuplet;
  tmpNtuplet.reserve(minHitsPerNtuplet);
 
  for (auto root_cell : theRootCells) {
    tmpNtuplet.clear();
    tmpNtuplet.push_back(root_cell);
    allCells[root_cell].findNtuplets(allCells, foundNtuplets, tmpNtuplet, minHitsPerNtuplet);
  }
}

References allCells, and theRootCells.

Referenced by CAHitQuadrupletGenerator::hitNtuplets().

findTriplets()

void CellularAutomaton::findTriplets	(	const std::vector< const HitDoublets * > &	hitDoublets,
		std::vector< CACell::CAntuplet > &	foundTriplets,
		const TrackingRegion &	region,
		const float	thetaCut,
		const float	phiCut,
		const float	hardPtCut
	)

Definition at line 134 of file CellularAutomaton.cc.

                                                            {
  int tsize = 0;
  for (auto hd : hitDoublets) {
    tsize += hd->size();
  }
  allCells.reserve(tsize);
 
  unsigned int cellId = 0;
  float ptmin = region.ptMin();
  float region_origin_x = region.origin().x();
  float region_origin_y = region.origin().y();
  float region_origin_radius = region.originRBound();
 
  std::vector<bool> alreadyVisitedLayerPairs;
  alreadyVisitedLayerPairs.resize(theLayerGraph.theLayerPairs.size());
  for (auto visited : alreadyVisitedLayerPairs) {
    visited = false;
  }
  for (int rootVertex : theLayerGraph.theRootLayers) {
    std::queue<int> LayerPairsToVisit;
 
    for (int LayerPair : theLayerGraph.theLayers[rootVertex].theOuterLayerPairs) {
      LayerPairsToVisit.push(LayerPair);
    }
 
    unsigned int numberOfLayerPairsToVisitAtThisDepth = LayerPairsToVisit.size();
 
    while (not LayerPairsToVisit.empty()) {
      auto currentLayerPair = LayerPairsToVisit.front();
      auto &currentLayerPairRef = theLayerGraph.theLayerPairs[currentLayerPair];
      auto &currentInnerLayerRef = theLayerGraph.theLayers[currentLayerPairRef.theLayers[0]];
      auto &currentOuterLayerRef = theLayerGraph.theLayers[currentLayerPairRef.theLayers[1]];
      bool allInnerLayerPairsAlreadyVisited{true};
 
      for (auto innerLayerPair : currentInnerLayerRef.theInnerLayerPairs) {
        allInnerLayerPairsAlreadyVisited &= alreadyVisitedLayerPairs[innerLayerPair];
      }
 
      if (alreadyVisitedLayerPairs[currentLayerPair] == false and allInnerLayerPairsAlreadyVisited) {
        const HitDoublets *doubletLayerPairId = hitDoublets[currentLayerPair];
        auto numberOfDoublets = doubletLayerPairId->size();
        currentLayerPairRef.theFoundCells[0] = cellId;
        currentLayerPairRef.theFoundCells[1] = cellId + numberOfDoublets;
        for (unsigned int i = 0; i < numberOfDoublets; ++i) {
          allCells.emplace_back(
              doubletLayerPairId, i, doubletLayerPairId->innerHitId(i), doubletLayerPairId->outerHitId(i));
 
          currentOuterLayerRef.isOuterHitOfCell[doubletLayerPairId->outerHitId(i)].push_back(cellId);
 
          cellId++;
 
          auto &neigCells = currentInnerLayerRef.isOuterHitOfCell[doubletLayerPairId->innerHitId(i)];
          allCells.back().checkAlignmentAndPushTriplet(allCells,
                                                       neigCells,
                                                       foundTriplets,
                                                       ptmin,
                                                       region_origin_x,
                                                       region_origin_y,
                                                       region_origin_radius,
                                                       thetaCut,
                                                       phiCut,
                                                       hardPtCut);
        }
        assert(cellId == currentLayerPairRef.theFoundCells[1]);
        for (auto outerLayerPair : currentOuterLayerRef.theOuterLayerPairs) {
          LayerPairsToVisit.push(outerLayerPair);
        }
 
        alreadyVisitedLayerPairs[currentLayerPair] = true;
      }
      LayerPairsToVisit.pop();
      numberOfLayerPairsToVisitAtThisDepth--;
      if (numberOfLayerPairsToVisitAtThisDepth == 0) {
        numberOfLayerPairsToVisitAtThisDepth = LayerPairsToVisit.size();
      }
    }
  }
}

References allCells, cms::cuda::assert(), mps_fire::i, HitDoublets::innerHitId(), HitDoublets::outerHitId(), ptmin, HLT_2018_cff::region, HitDoublets::size(), theLayerGraph, CAGraph::theLayerPairs, CAGraph::theLayers, CAGraph::theRootLayers, and class-composition::visited.

Referenced by CAHitTripletGenerator::hitNtuplets().

getAllCells()

std::vector<CACell>& CellularAutomaton::getAllCells ( )

inline

Definition at line 16 of file CellularAutomaton.h.

{ return allCells; }

References allCells.

Referenced by CAHitTripletGenerator::hitNtuplets(), and CAHitQuadrupletGenerator::hitNtuplets().

Member Data Documentation

allCells

std::vector<CACell> CellularAutomaton::allCells

private

Definition at line 33 of file CellularAutomaton.h.

Referenced by createAndConnectCells(), evolve(), findNtuplets(), findTriplets(), and getAllCells().

allStatus

std::vector<CACellStatus> CellularAutomaton::allStatus

private

Definition at line 34 of file CellularAutomaton.h.

Referenced by evolve().

theLayerGraph

CAGraph& CellularAutomaton::theLayerGraph

private

Definition at line 31 of file CellularAutomaton.h.

Referenced by createAndConnectCells(), evolve(), and findTriplets().

theNtuplets

std::vector<std::vector<CACell*> > CellularAutomaton::theNtuplets

private

Definition at line 37 of file CellularAutomaton.h.

theRootCells

std::vector<unsigned int> CellularAutomaton::theRootCells

private

Definition at line 36 of file CellularAutomaton.h.

Referenced by evolve(), and findNtuplets().