DAS  3.0
Das Analysis System
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
LazyTiling25
+ Collaboration diagram for LazyTiling25:

Public Member Functions

 LazyTiling25 (ClusterSequence &cs)
 
void run ()
 

Protected Member Functions

void _initialise_tiles ()
 
int _tile_index (int ieta, int iphi) const
 
void _bj_remove_from_tiles (TiledJet *const jet)
 
int _tile_index (const double eta, const double phi) const
 
void _tj_set_jetinfo (TiledJet *const jet, const int _jets_index)
 
void _print_tiles (TiledJet *briefjets) const
 
void _add_neighbours_to_tile_union (const int tile_index, std::vector< int > &tile_union, int &n_near_tiles) const
 
void _add_untagged_neighbours_to_tile_union (const int tile_index, std::vector< int > &tile_union, int &n_near_tiles)
 
void _add_untagged_neighbours_to_tile_union_using_max_info (const TiledJet *const jet, std::vector< int > &tile_union, int &n_near_tiles)
 
double _distance_to_tile (const TiledJet *bj, const Tile25 *) const
 
void _update_jetX_jetI_NN (TiledJet *jetX, TiledJet *jetI, std::vector< TiledJet * > &jets_for_minheap)
 
void _set_NN (TiledJet *jetI, std::vector< TiledJet * > &jets_for_minheap)
 
template<class J >
double _bj_diJ (const J *const jet) const
 
template<class J >
void _bj_set_jetinfo (J *const jetA, const int _jets_index) const
 
template<class J >
double _bj_dist (const J *const jetA, const J *const jetB) const
 
template<class J >
double _bj_dist_not_periodic (const J *const jetA, const J *const jetB) const
 

Protected Attributes

ClusterSequence & _cs
 
const std::vector< PseudoJet > & _jets
 
std::vector< Tile25 > _tiles
 
double _Rparam
 
double _R2
 
double _invR2
 
double _tiles_eta_min
 
double _tiles_eta_max
 
double _tile_size_eta
 
double _tile_size_phi
 
double _tile_half_size_eta
 
double _tile_half_size_phi
 
int _n_tiles_phi
 
int _tiles_ieta_min
 
int _tiles_ieta_max
 
std::vector< TiledJet * > _jets_for_minheap
 

Constructor & Destructor Documentation

◆ LazyTiling25()

FJCORE_BEGIN_NAMESPACE LazyTiling25 ( ClusterSequence &  cs)
4953  :
4954  _cs(cs), _jets(cs.jets())
4955 {
4956 #ifdef INSTRUMENT2
4957  _ncall = 0; // gps tmp
4958  _ncall_dtt = 0; // gps tmp
4959 #endif // INSTRUMENT2
4960  _Rparam = cs.jet_def().R();
4961  _R2 = _Rparam * _Rparam;
4962  _invR2 = 1.0 / _R2;
4963  _initialise_tiles();
4964 }

Member Function Documentation

◆ _add_neighbours_to_tile_union()

void _add_neighbours_to_tile_union ( const int  tile_index,
std::vector< int > &  tile_union,
int &  n_near_tiles 
) const
protected
5120  {
5121  for (Tile25 * const * near_tile = _tiles[tile_index].begin_tiles;
5122  near_tile != _tiles[tile_index].end_tiles; near_tile++){
5123  tile_union[n_near_tiles] = *near_tile - & _tiles[0];
5124  n_near_tiles++;
5125  }
5126 }

◆ _add_untagged_neighbours_to_tile_union()

void _add_untagged_neighbours_to_tile_union ( const int  tile_index,
std::vector< int > &  tile_union,
int &  n_near_tiles 
)
inlineprotected
5129  {
5130  for (Tile25 ** near_tile = _tiles[tile_index].begin_tiles;
5131  near_tile != _tiles[tile_index].end_tiles; near_tile++){
5132  if (! (*near_tile)->tagged) {
5133  (*near_tile)->tagged = true;
5134  tile_union[n_near_tiles] = *near_tile - & _tiles[0];
5135  n_near_tiles++;
5136  }
5137  }
5138 }

◆ _add_untagged_neighbours_to_tile_union_using_max_info()

void _add_untagged_neighbours_to_tile_union_using_max_info ( const TiledJet *const  jet,
std::vector< int > &  tile_union,
int &  n_near_tiles 
)
inlineprotected
5141  {
5142  Tile25 & tile = _tiles[jet->tile_index];
5143  for (Tile25 ** near_tile = tile.begin_tiles; near_tile != tile.end_tiles; near_tile++){
5144  if ((*near_tile)->tagged) continue;
5145  double dist = _distance_to_tile(jet, *near_tile) - tile_edge_security_margin;
5146  if (dist > (*near_tile)->max_NN_dist) continue;
5147  (*near_tile)->tagged = true;
5148  tile_union[n_near_tiles] = *near_tile - & _tiles[0];
5149  n_near_tiles++;
5150  }
5151 }

◆ _bj_diJ()

double _bj_diJ ( const J *const  jet) const
inlineprotected
1106  {
1107  double kt2 = jet->kt2;
1108  if (jet->NN != NULL) {if (jet->NN->kt2 < kt2) {kt2 = jet->NN->kt2;}}
1109  return jet->NN_dist * kt2;
1110  }

◆ _bj_dist()

double _bj_dist ( const J *const  jetA,
const J *const  jetB 
) const
inlineprotected
1123  {
1124  _ncall++; // GPS tmp
1125 #else
1126  const {
1127 #endif
1128  double dphi = std::abs(jetA->phi - jetB->phi);
1129  double deta = (jetA->eta - jetB->eta);
1130  if (dphi > pi) {dphi = twopi - dphi;}
1131  return dphi*dphi + deta*deta;
1132  }

◆ _bj_dist_not_periodic()

double _bj_dist_not_periodic ( const J *const  jetA,
const J *const  jetB 
) const
inlineprotected
1136  {
1137  _ncall++; // GPS tmp
1138 #else
1139  const {
1140 #endif
1141  double dphi = jetA->phi - jetB->phi;
1142  double deta = (jetA->eta - jetB->eta);
1143  return dphi*dphi + deta*deta;
1144  }

◆ _bj_remove_from_tiles()

void _bj_remove_from_tiles ( TiledJet *const  jet)
protected
5093  {
5094  Tile25 * tile = & _tiles[jet->tile_index];
5095  if (jet->previous == NULL) {
5096  tile->head = jet->next;
5097  } else {
5098  jet->previous->next = jet->next;
5099  }
5100  if (jet->next != NULL) {
5101  jet->next->previous = jet->previous;
5102  }
5103 }

◆ _bj_set_jetinfo()

void _bj_set_jetinfo ( J *const  jetA,
const int  _jets_index 
) const
inlineprotected
1112  {
1113  jetA->eta = _jets[_jets_index].rap();
1114  jetA->phi = _jets[_jets_index].phi_02pi();
1115  jetA->kt2 = _cs.jet_scale_for_algorithm(_jets[_jets_index]);
1116  jetA->_jets_index = _jets_index;
1117  jetA->NN_dist = _R2;
1118  jetA->NN = NULL;
1119  }

◆ _distance_to_tile()

double _distance_to_tile ( const TiledJet *  bj,
const Tile25 *  tile 
) const
inlineprotected
5154  {
5155  _ncall_dtt++; // GPS tmp
5156 #else
5157  const {
5158 #endif // INSTRUMENT2
5159  double deta;
5160  if (_tiles[bj->tile_index].eta_centre == tile->eta_centre) deta = 0;
5161  else deta = std::abs(bj->eta - tile->eta_centre) - _tile_half_size_eta;
5162  double dphi = std::abs(bj->phi - tile->phi_centre);
5163  if (dphi > pi) dphi = twopi-dphi;
5164  dphi -= _tile_half_size_phi;
5165  if (dphi < 0) dphi = 0;
5166  return dphi*dphi + deta*deta;
5167 }

◆ _initialise_tiles()

void _initialise_tiles ( )
protected
4965  {
4966  double default_size = max(0.1,_Rparam)/2;
4967  _tile_size_eta = default_size;
4968  _n_tiles_phi = max(5,int(floor(twopi/default_size)));
4969  _tile_size_phi = twopi / _n_tiles_phi; // >= _Rparam and fits in 2pi
4970 #define _FJCORE_TILING25_USE_TILING_ANALYSIS_
4971 #ifdef _FASTJET_TILING25_USE_TILING_ANALYSIS_
4972  TilingExtent tiling_analysis(_cs);
4973  _tiles_eta_min = tiling_analysis.minrap();
4974  _tiles_eta_max = tiling_analysis.maxrap();
4975 #else // not _FASTJET_TILING25_USE_TILING_ANALYSIS_
4976  _tiles_eta_min = 0.0;
4977  _tiles_eta_max = 0.0;
4978  const double maxrap = 7.0;
4979  for(unsigned int i = 0; i < _jets.size(); i++) {
4980  double eta = _jets[i].rap();
4981  if (abs(eta) < maxrap) {
4982  if (eta < _tiles_eta_min) {_tiles_eta_min = eta;}
4983  if (eta > _tiles_eta_max) {_tiles_eta_max = eta;}
4984  }
4985  }
4986 #endif // _FASTJET_TILING25_USE_TILING_ANALYSIS_
4987 # define FJCORE_LAZY25_MIN3TILESY
4988 #ifdef FJCORE_LAZY25_MIN3TILESY
4989  if (_tiles_eta_max - _tiles_eta_min < 3*_tile_size_eta) {
4990  _tile_size_eta = (_tiles_eta_max - _tiles_eta_min)/3;
4991  _tiles_ieta_min = 0;
4992  _tiles_ieta_max = 2;
4993  _tiles_eta_max -= _tile_size_eta;
4994  } else {
4995 #endif //FASTJET_LAZY25_MIN3TILESY
4996  _tiles_ieta_min = int(floor(_tiles_eta_min/_tile_size_eta));
4997  _tiles_ieta_max = int(floor( _tiles_eta_max/_tile_size_eta));
4998  _tiles_eta_min = _tiles_ieta_min * _tile_size_eta;
4999  _tiles_eta_max = _tiles_ieta_max * _tile_size_eta;
5000 #ifdef FJCORE_LAZY25_MIN3TILESY
5001  }
5002 #endif
5003  _tile_half_size_eta = _tile_size_eta * 0.5;
5004  _tile_half_size_phi = _tile_size_phi * 0.5;
5005  vector<bool> use_periodic_delta_phi(_n_tiles_phi, false);
5006  if (_n_tiles_phi <= 5) {
5007  fill(use_periodic_delta_phi.begin(), use_periodic_delta_phi.end(), true);
5008  } else {
5009  use_periodic_delta_phi[0] = true;
5010  use_periodic_delta_phi[1] = true;
5011  use_periodic_delta_phi[_n_tiles_phi-2] = true;
5012  use_periodic_delta_phi[_n_tiles_phi-1] = true;
5013  }
5014  _tiles.resize((_tiles_ieta_max-_tiles_ieta_min+1)*_n_tiles_phi);
5015  for (int ieta = _tiles_ieta_min; ieta <= _tiles_ieta_max; ieta++) {
5016  for (int iphi = 0; iphi < _n_tiles_phi; iphi++) {
5017  Tile25 * tile = & _tiles[_tile_index(ieta,iphi)];
5018  tile->head = NULL; // first element of tiles points to itself
5019  tile->begin_tiles[0] = tile;
5020  Tile25 ** pptile = & (tile->begin_tiles[0]);
5021  pptile++;
5022  tile->surrounding_tiles = pptile;
5023  if (ieta > _tiles_ieta_min) {
5024  // with the itile subroutine, we can safely run tiles from
5025  // idphi=-1 to idphi=+1, because it takes care of
5026  // negative and positive boundaries
5027  for (int idphi = -2; idphi <=+2; idphi++) {
5028  *pptile = & _tiles[_tile_index(ieta-1,iphi+idphi)];
5029  pptile++;
5030  }
5031  }
5032  if (ieta > _tiles_ieta_min + 1) {
5033  // with the itile subroutine, we can safely run tiles from
5034  // idphi=-1 to idphi=+1, because it takes care of
5035  // negative and positive boundaries
5036  for (int idphi = -2; idphi <= +2; idphi++) {
5037  *pptile = & _tiles[_tile_index(ieta-2,iphi+idphi)];
5038  pptile++;
5039  }
5040  }
5041  *pptile = & _tiles[_tile_index(ieta,iphi-1)];
5042  pptile++;
5043  *pptile = & _tiles[_tile_index(ieta,iphi-2)];
5044  pptile++;
5045  tile->RH_tiles = pptile;
5046  *pptile = & _tiles[_tile_index(ieta,iphi+1)];
5047  pptile++;
5048  *pptile = & _tiles[_tile_index(ieta,iphi+2)];
5049  pptile++;
5050  if (ieta < _tiles_ieta_max) {
5051  for (int idphi = -2; idphi <= +2; idphi++) {
5052  *pptile = & _tiles[_tile_index(ieta+1,iphi+idphi)];
5053  pptile++;
5054  }
5055  }
5056  if (ieta < _tiles_ieta_max - 1) {
5057  for (int idphi = -2; idphi <= +2; idphi++) {
5058  *pptile = & _tiles[_tile_index(ieta+2,iphi+idphi)];
5059  pptile++;
5060  }
5061  }
5062  tile->end_tiles = pptile;
5063  tile->tagged = false;
5064  tile->use_periodic_delta_phi = use_periodic_delta_phi[iphi];
5065  tile->max_NN_dist = 0;
5066  tile->eta_centre = (ieta-_tiles_ieta_min+0.5)*_tile_size_eta + _tiles_eta_min;
5067  tile->phi_centre = (iphi+0.5)*_tile_size_phi;
5068  }
5069  }
5070 }

◆ _print_tiles()

void _print_tiles ( TiledJet *  briefjets) const
protected
5104  {
5105  for (vector<Tile25>::const_iterator tile = _tiles.begin();
5106  tile < _tiles.end(); tile++) {
5107  cout << "Tile " << tile - _tiles.begin()
5108  << " at " << setw(10) << tile->eta_centre << "," << setw(10) << tile->phi_centre
5109  << " = ";
5110  vector<int> list;
5111  for (TiledJet * jetI = tile->head; jetI != NULL; jetI = jetI->next) {
5112  list.push_back(jetI-briefjets);
5113  }
5114  sort(list.begin(),list.end());
5115  for (unsigned int i = 0; i < list.size(); i++) {cout <<" "<<list[i];}
5116  cout <<"\n";
5117  }
5118 }

◆ _set_NN()

void _set_NN ( TiledJet *  jetI,
std::vector< TiledJet * > &  jets_for_minheap 
)
inlineprotected
5187  {
5188  jetI->NN_dist = _R2;
5189  jetI->NN = NULL;
5190  if (!jetI->minheap_update_needed()) {
5191  jetI->label_minheap_update_needed();
5192  jets_for_minheap.push_back(jetI);}
5193  Tile25 * tile_ptr = &_tiles[jetI->tile_index];
5194  for (Tile25 ** near_tile = tile_ptr->begin_tiles;
5195  near_tile != tile_ptr->end_tiles; near_tile++) {
5196  if (jetI->NN_dist < _distance_to_tile(jetI, *near_tile)) continue;
5197  for (TiledJet * jetJ = (*near_tile)->head;
5198  jetJ != NULL; jetJ = jetJ->next) {
5199  double dist = _bj_dist(jetI,jetJ);
5200  if (dist < jetI->NN_dist && jetJ != jetI) {
5201  jetI->NN_dist = dist; jetI->NN = jetJ;
5202  }
5203  }
5204  }
5205 }

◆ _tile_index() [1/2]

int _tile_index ( const double  eta,
const double  phi 
) const
protected
5071  {
5072  int ieta, iphi;
5073  if (eta <= _tiles_eta_min) {ieta = 0;}
5074  else if (eta >= _tiles_eta_max) {ieta = _tiles_ieta_max-_tiles_ieta_min;}
5075  else {
5076  ieta = int(((eta - _tiles_eta_min) / _tile_size_eta));
5077  if (ieta > _tiles_ieta_max-_tiles_ieta_min) {
5078  ieta = _tiles_ieta_max-_tiles_ieta_min;}
5079  }
5080  iphi = int((phi+twopi)/_tile_size_phi) % _n_tiles_phi;
5081  return (iphi + ieta * _n_tiles_phi);
5082 }

◆ _tile_index() [2/2]

int _tile_index ( int  ieta,
int  iphi 
) const
inlineprotected
1084  {
1085  return (ieta-_tiles_ieta_min)*_n_tiles_phi
1086  + (iphi+_n_tiles_phi) % _n_tiles_phi;
1087  }

◆ _tj_set_jetinfo()

void _tj_set_jetinfo ( TiledJet *const  jet,
const int  _jets_index 
)
inlineprotected
5084  {
5085  _bj_set_jetinfo<>(jet, _jets_index);
5086  jet->tile_index = _tile_index(jet->eta, jet->phi);
5087  Tile25 * tile = &_tiles[jet->tile_index];
5088  jet->previous = NULL;
5089  jet->next = tile->head;
5090  if (jet->next != NULL) {jet->next->previous = jet;}
5091  tile->head = jet;
5092 }

◆ _update_jetX_jetI_NN()

void _update_jetX_jetI_NN ( TiledJet *  jetX,
TiledJet *  jetI,
std::vector< TiledJet * > &  jets_for_minheap 
)
inlineprotected
5168  {
5169  double dist = _bj_dist(jetI,jetX);
5170  if (dist < jetI->NN_dist) {
5171  if (jetI != jetX) {
5172  jetI->NN_dist = dist;
5173  jetI->NN = jetX;
5174  if (!jetI->minheap_update_needed()) {
5175  jetI->label_minheap_update_needed();
5176  jets_for_minheap.push_back(jetI);
5177  }
5178  }
5179  }
5180  if (dist < jetX->NN_dist) {
5181  if (jetI != jetX) {
5182  jetX->NN_dist = dist;
5183  jetX->NN = jetI;}
5184  }
5185 }

◆ run()

void run ( )
5206  {
5207  int n = _jets.size();
5208  if (n == 0) return;
5209  TiledJet * briefjets = new TiledJet[n];
5210  TiledJet * jetA = briefjets, * jetB;
5211  TiledJet oldB = briefjets[0];
5212  vector<int> tile_union(3*25);
5213  for (int i = 0; i< n; i++) {
5214  _tj_set_jetinfo(jetA, i);
5215  jetA++; // move on to next entry of briefjets
5216  }
5217  TiledJet * head = briefjets; // a nicer way of naming start
5218  vector<Tile25>::iterator tile;
5219  for (tile = _tiles.begin(); tile != _tiles.end(); tile++) {
5220  for (jetA = tile->head; jetA != NULL; jetA = jetA->next) {
5221  for (jetB = tile->head; jetB != jetA; jetB = jetB->next) {
5222  double dist = _bj_dist_not_periodic(jetA,jetB);
5223  if (dist < jetA->NN_dist) {jetA->NN_dist = dist; jetA->NN = jetB;}
5224  if (dist < jetB->NN_dist) {jetB->NN_dist = dist; jetB->NN = jetA;}
5225  }
5226  }
5227  for (jetA = tile->head; jetA != NULL; jetA = jetA->next) {
5228  if (jetA->NN_dist > tile->max_NN_dist) tile->max_NN_dist = jetA->NN_dist;
5229  }
5230  }
5231  for (tile = _tiles.begin(); tile != _tiles.end(); tile++) {
5232  if (tile->use_periodic_delta_phi) {
5233  for (Tile25 ** RTile = tile->RH_tiles; RTile != tile->end_tiles; RTile++) {
5234  for (jetA = tile->head; jetA != NULL; jetA = jetA->next) {
5235  double dist_to_tile = _distance_to_tile(jetA, *RTile);
5236  bool relevant_for_jetA = dist_to_tile <= jetA->NN_dist;
5237  bool relevant_for_RTile = dist_to_tile <= (*RTile)->max_NN_dist;
5238  if (relevant_for_jetA || relevant_for_RTile) {
5239  for (jetB = (*RTile)->head; jetB != NULL; jetB = jetB->next) {
5240  double dist = _bj_dist(jetA,jetB);
5241  if (dist < jetA->NN_dist) {jetA->NN_dist = dist; jetA->NN = jetB;}
5242  if (dist < jetB->NN_dist) {jetB->NN_dist = dist; jetB->NN = jetA;}
5243  }
5244  }
5245  }
5246  }
5247  } else {
5248  for (Tile25 ** RTile = tile->RH_tiles; RTile != tile->end_tiles; RTile++) {
5249  for (jetA = tile->head; jetA != NULL; jetA = jetA->next) {
5250  double dist_to_tile = _distance_to_tile(jetA, *RTile);
5251  bool relevant_for_jetA = dist_to_tile <= jetA->NN_dist;
5252  bool relevant_for_RTile = dist_to_tile <= (*RTile)->max_NN_dist;
5253  if (relevant_for_jetA || relevant_for_RTile) {
5254  for (jetB = (*RTile)->head; jetB != NULL; jetB = jetB->next) {
5255  double dist = _bj_dist_not_periodic(jetA,jetB);
5256  if (dist < jetA->NN_dist) {jetA->NN_dist = dist; jetA->NN = jetB;}
5257  if (dist < jetB->NN_dist) {jetB->NN_dist = dist; jetB->NN = jetA;}
5258  }
5259  }
5260  }
5261  }
5262  }
5263  }
5264  for (tile = _tiles.begin(); tile != _tiles.end(); tile++) {
5265  tile->max_NN_dist = 0;
5266  for (jetA = tile->head; jetA != NULL; jetA = jetA->next) {
5267  if (jetA->NN_dist > tile->max_NN_dist) tile->max_NN_dist = jetA->NN_dist;
5268  }
5269  }
5270 #ifdef INSTRUMENT2
5271  cout << "intermediate ncall, dtt = " << _ncall << " " << _ncall_dtt << endl; // GPS tmp
5272 #endif // INSTRUMENT2
5273  vector<double> diJs(n);
5274  for (int i = 0; i < n; i++) {
5275  diJs[i] = _bj_diJ(&briefjets[i]);
5276  briefjets[i].label_minheap_update_done();
5277  }
5278  MinHeap minheap(diJs);
5279  vector<TiledJet *> jets_for_minheap;
5280  jets_for_minheap.reserve(n);
5281  int history_location = n-1;
5282  while (n > 0) {
5283  double diJ_min = minheap.minval() *_invR2;
5284  jetA = head + minheap.minloc();
5285  history_location++;
5286  jetB = jetA->NN;
5287  if (jetB != NULL) {
5288  if (jetA < jetB) {std::swap(jetA,jetB);}
5289  int nn; // new jet index
5290  _cs.plugin_record_ij_recombination(jetA->_jets_index, jetB->_jets_index, diJ_min, nn);
5291  _bj_remove_from_tiles(jetA);
5292  oldB = * jetB; // take a copy because we will need it...
5293  _bj_remove_from_tiles(jetB);
5294  _tj_set_jetinfo(jetB, nn); // cause jetB to become _jets[nn]
5295  } else {
5296  _cs.plugin_record_iB_recombination(jetA->_jets_index, diJ_min);
5297  _bj_remove_from_tiles(jetA);
5298  }
5299  minheap.remove(jetA-head);
5300  int n_near_tiles = 0;
5301  if (jetB != NULL) {
5302  Tile25 & jetB_tile = _tiles[jetB->tile_index];
5303  for (Tile25 ** near_tile = jetB_tile.begin_tiles;
5304  near_tile != jetB_tile.end_tiles; near_tile++) {
5305  double dist_to_tile = _distance_to_tile(jetB, *near_tile);
5306  bool relevant_for_jetB = dist_to_tile <= jetB->NN_dist;
5307  bool relevant_for_near_tile = dist_to_tile <= (*near_tile)->max_NN_dist;
5308  bool relevant = relevant_for_jetB || relevant_for_near_tile;
5309  if (! relevant) continue;
5310  tile_union[n_near_tiles] = *near_tile - & _tiles[0];
5311  (*near_tile)->tagged = true;
5312  n_near_tiles++;
5313  for (TiledJet * jetI = (*near_tile)->head; jetI != NULL; jetI = jetI->next) {
5314  if (jetI->NN == jetA || jetI->NN == jetB) _set_NN(jetI, jets_for_minheap);
5315  _update_jetX_jetI_NN(jetB, jetI, jets_for_minheap);
5316  }
5317  }
5318  }
5319  int n_done_tiles = n_near_tiles;
5320  _add_untagged_neighbours_to_tile_union_using_max_info(jetA,
5321  tile_union, n_near_tiles);
5322  if (jetB != NULL) {
5323  _add_untagged_neighbours_to_tile_union_using_max_info(&oldB,
5324  tile_union,n_near_tiles);
5325  jetB->label_minheap_update_needed();
5326  jets_for_minheap.push_back(jetB);
5327  }
5328  for (int itile = 0; itile < n_done_tiles; itile++) {
5329  _tiles[tile_union[itile]].tagged = false;
5330  }
5331  for (int itile = n_done_tiles; itile < n_near_tiles; itile++) {
5332  Tile25 * tile_ptr = &_tiles[tile_union[itile]];
5333  tile_ptr->tagged = false;
5334  for (TiledJet * jetI = tile_ptr->head; jetI != NULL; jetI = jetI->next) {
5335  if (jetI->NN == jetA || (jetI->NN == jetB && jetB != NULL)) {
5336  _set_NN(jetI, jets_for_minheap);
5337  }
5338  }
5339  }
5340  while (jets_for_minheap.size() > 0) {
5341  TiledJet * jetI = jets_for_minheap.back();
5342  jets_for_minheap.pop_back();
5343  minheap.update(jetI-head, _bj_diJ(jetI));
5344  jetI->label_minheap_update_done();
5345  Tile25 & tile_I = _tiles[jetI->tile_index];
5346  if (tile_I.max_NN_dist < jetI->NN_dist) tile_I.max_NN_dist = jetI->NN_dist;
5347  }
5348  n--;
5349  }
5350  delete[] briefjets;
5351 #ifdef INSTRUMENT2
5352  cout << "ncall, dtt = " << _ncall << " " << _ncall_dtt << endl; // GPS tmp
5353 #endif // INSTRUMENT2
5354 }

Member Data Documentation

◆ _cs

ClusterSequence& _cs
protected

◆ _invR2

double _invR2
protected

◆ _jets

const std::vector<PseudoJet>& _jets
protected

◆ _jets_for_minheap

std::vector<TiledJet *> _jets_for_minheap
protected

◆ _n_tiles_phi

int _n_tiles_phi
protected

◆ _R2

double _R2
protected

◆ _Rparam

double _Rparam
protected

◆ _tile_half_size_eta

double _tile_half_size_eta
protected

◆ _tile_half_size_phi

double _tile_half_size_phi
protected

◆ _tile_size_eta

double _tile_size_eta
protected

◆ _tile_size_phi

double _tile_size_phi
protected

◆ _tiles

std::vector<Tile25> _tiles
protected

◆ _tiles_eta_max

double _tiles_eta_max
protected

◆ _tiles_eta_min

double _tiles_eta_min
protected

◆ _tiles_ieta_max

int _tiles_ieta_max
protected

◆ _tiles_ieta_min

int _tiles_ieta_min
protected
The documentation for this class was generated from the following file:
LazyTiling25::_tile_half_size_phi
double _tile_half_size_phi
Definition: fjcore.cc:1080
TiledJet
Definition: fjcore.cc:829
LazyTiling25::_invR2
double _invR2
Definition: fjcore.cc:1077
Darwin::Tools::fill
@ fill
activate -f to fill the tree
Definition: Options.h:27
TiledJet::phi
double phi
Definition: fjcore.cc:831
LazyTiling25::_tile_half_size_eta
double _tile_half_size_eta
Definition: fjcore.cc:1080
LazyTiling25::_bj_remove_from_tiles
void _bj_remove_from_tiles(TiledJet *const jet)
Definition: fjcore.cc:5093
MinHeap
Definition: fjcore.cc:647
pi
FJCORE_BEGIN_NAMESPACE const double pi
Definition: fjcore.hh:191
LazyTiling25::_tj_set_jetinfo
void _tj_set_jetinfo(TiledJet *const jet, const int _jets_index)
Definition: fjcore.cc:5083
TiledJet::label_minheap_update_done
void label_minheap_update_done()
Definition: fjcore.cc:836
LazyTiling25::_bj_dist
double _bj_dist(const J *const jetA, const J *const jetB) const
Definition: fjcore.cc:1120
LazyTiling25::_update_jetX_jetI_NN
void _update_jetX_jetI_NN(TiledJet *jetX, TiledJet *jetI, std::vector< TiledJet * > &jets_for_minheap)
Definition: fjcore.cc:5168
LazyTiling25::_set_NN
void _set_NN(TiledJet *jetI, std::vector< TiledJet * > &jets_for_minheap)
Definition: fjcore.cc:5186
TiledJet::NN_dist
double NN_dist
Definition: fjcore.cc:831
LazyTiling25::_Rparam
double _Rparam
Definition: fjcore.cc:1077
ClusterSequence::plugin_record_iB_recombination
void plugin_record_iB_recombination(int jet_i, double diB)
Definition: fjcore.hh:1450
TiledJet::_jets_index
int _jets_index
Definition: fjcore.cc:833
TiledJet::next
TiledJet * next
Definition: fjcore.cc:832
TiledJet::tile_index
int tile_index
Definition: fjcore.cc:833
LazyTiling25::_add_untagged_neighbours_to_tile_union_using_max_info
void _add_untagged_neighbours_to_tile_union_using_max_info(const TiledJet *const jet, std::vector< int > &tile_union, int &n_near_tiles)
Definition: fjcore.cc:5139
tile_edge_security_margin
FJCORE_BEGIN_NAMESPACE const double tile_edge_security_margin
Definition: fjcore.cc:828
TiledJet::minheap_update_needed
bool minheap_update_needed() const
Definition: fjcore.cc:837
LazyTiling25::_R2
double _R2
Definition: fjcore.cc:1077
LazyTiling25::_tiles
std::vector< Tile25 > _tiles
Definition: fjcore.cc:1072
LazyTiling25::_tile_index
int _tile_index(int ieta, int iphi) const
Definition: fjcore.cc:1084
ClusterSequence::plugin_record_ij_recombination
void plugin_record_ij_recombination(int jet_i, int jet_j, double dij, int &newjet_k)
Definition: fjcore.hh:1442
TiledJet::previous
TiledJet * previous
Definition: fjcore.cc:832
swap
void swap(SharedPtr< T > &a, SharedPtr< T > &b)
Definition: fjcore.hh:412
LazyTiling25::_distance_to_tile
double _distance_to_tile(const TiledJet *bj, const Tile25 *) const
Definition: fjcore.cc:5152
ClusterSequence::jets
const std::vector< PseudoJet > & jets() const
Definition: fjcore.hh:1673
LazyTiling25::_bj_dist_not_periodic
double _bj_dist_not_periodic(const J *const jetA, const J *const jetB) const
Definition: fjcore.cc:1133
LazyTiling25::_tiles_eta_max
double _tiles_eta_max
Definition: fjcore.cc:1078
LazyTiling25::_jets
const std::vector< PseudoJet > & _jets
Definition: fjcore.cc:1071
JetDefinition::R
double R() const
Definition: fjcore.hh:1149
LazyTiling25::_cs
ClusterSequence & _cs
Definition: fjcore.cc:1070
ClusterSequence::jet_scale_for_algorithm
double jet_scale_for_algorithm(const PseudoJet &jet) const
Definition: fjcore.cc:1656
TiledJet::label_minheap_update_needed
void label_minheap_update_needed()
Definition: fjcore.cc:835
TiledJet::NN
TiledJet * NN
Definition: fjcore.cc:832
twopi
const double twopi
Definition: fjcore.hh:192
LazyTiling25::_tile_size_eta
double _tile_size_eta
Definition: fjcore.cc:1079
TiledJet::eta
double eta
Definition: fjcore.cc:831
LazyTiling25::_tile_size_phi
double _tile_size_phi
Definition: fjcore.cc:1079
LazyTiling25::_tiles_ieta_min
int _tiles_ieta_min
Definition: fjcore.cc:1081
LazyTiling25::_bj_diJ
double _bj_diJ(const J *const jet) const
Definition: fjcore.cc:1106
LazyTiling25::_tiles_ieta_max
int _tiles_ieta_max
Definition: fjcore.cc:1081
ClusterSequence::jet_def
const JetDefinition & jet_def() const
Definition: fjcore.hh:1437
LazyTiling25::_n_tiles_phi
int _n_tiles_phi
Definition: fjcore.cc:1081
TilingExtent
Definition: fjcore.cc:1151
jmarExample.eta
eta
DeepAK8/ParticleNet tagging.
Definition: jmarExample.py:19
Tile25
FJCORE_BEGIN_NAMESPACE typedef Tile2Base< 25 > Tile25
Definition: fjcore.cc:1064
LazyTiling25::_tiles_eta_min
double _tiles_eta_min
Definition: fjcore.cc:1078
LazyTiling25::_initialise_tiles
void _initialise_tiles()
Definition: fjcore.cc:4965