NNH< BJ, I >

#include <fjcore.hh>

Inheritance diagram for NNH< BJ, I >:

Collaboration diagram for NNH< BJ, I >:

Classes
class	NNBJ

Public Member Functions
	NNH (const std::vector< PseudoJet > &jets)
	NNH (const std::vector< PseudoJet > &jets, I *info)
void	start (const std::vector< PseudoJet > &jets)
double	dij_min (int &iA, int &iB)
void	remove_jet (int iA)
void	merge_jets (int iA, int iB, const PseudoJet &jet, int jet_index)
	~NNH ()
Public Member Functions inherited from NNBase< _NoInfo >
	NNBase ()
	NNBase (_NoInfo *info)
virtual	~NNBase ()
Public Member Functions inherited from NNInfo< _NoInfo >
	NNInfo ()
	NNInfo (_NoInfo *)
template<class BJ >
void	init_jet (BJ *briefjet, const fjcore::PseudoJet &jet, int index)

Private Member Functions
void	set_NN_crosscheck (NNBJ *jet, NNBJ *begin, NNBJ *end)
void	set_NN_nocross (NNBJ *jet, NNBJ *begin, NNBJ *end)

Private Attributes
NNBJ *	briefjets
NNBJ *	head
NNBJ *	tail
int	n
std::vector< NNBJ * >	where_is

Constructor & Destructor Documentation

NNH() [1/2]

NNH ( const std::vector< PseudoJet > &  jets )

inline

: NNBase<I>()     {start(jets);}

NNH() [2/2]

NNH ( const std::vector< PseudoJet > &  jets, I *  info  )

inline

: NNBase<I>(info) {start(jets);}

~NNH()

~NNH ( )

inline

         {
    delete[] briefjets;
  }

Member Function Documentation

dij_min()

double dij_min ( int &  iA, int &  iB  )

virtual

Implements NNBase< _NoInfo >.

                                                                        {
  double diJ_min = briefjets[0].NN_dist;
  int diJ_min_jet = 0;
  for (int i = 1; i < n; i++) {
    if (briefjets[i].NN_dist < diJ_min) {
      diJ_min_jet = i;
      diJ_min  = briefjets[i].NN_dist;
    }
  }
  NNBJ * jetA = & briefjets[diJ_min_jet];
  iA = jetA->index();
  iB = jetA->NN ? jetA->NN->index() : -1;
  return diJ_min;
}

merge_jets()

void merge_jets ( int  iA, int  iB, const PseudoJet &  jet, int  jet_index  )

virtual

Implements NNBase< _NoInfo >.

                                                      {
  NNBJ * jetA = where_is[iA];
  NNBJ * jetB = where_is[iB];
  if (jetA < jetB) std::swap(jetA,jetB);
  this->init_jet(jetB, jet, index);
  if (index >= int(where_is.size())) where_is.resize(2*index);
  where_is[jetB->index()] = jetB;
  tail--; n--;
  *jetA = *tail;
  where_is[jetA->index()] = jetA;
  for (NNBJ * jetI = head; jetI != tail; jetI++) {
    if (jetI->NN == jetA || jetI->NN == jetB) {
      set_NN_nocross(jetI, head, tail);
    }
    double dist = jetI->distance(jetB);
    if (dist < jetI->NN_dist) {
      if (jetI != jetB) {
    jetI->NN_dist = dist;
    jetI->NN = jetB;
      }
    }
    if (dist < jetB->NN_dist) {
      if (jetI != jetB) {
    jetB->NN_dist = dist;
    jetB->NN      = jetI;
      }
    }
    if (jetI->NN == tail) {jetI->NN = jetA;}
  }
}

remove_jet()

void remove_jet ( int  iA )

virtual

Implements NNBase< _NoInfo >.

                                                             {
  NNBJ * jetA = where_is[iA];
  tail--; n--;
  *jetA = *tail;
  where_is[jetA->index()] = jetA;
  for (NNBJ * jetI = head; jetI != tail; jetI++) {
    if (jetI->NN == jetA) set_NN_nocross(jetI, head, tail);
    if (jetI->NN == tail) {jetI->NN = jetA;}
  }
}

set_NN_crosscheck()

void set_NN_crosscheck ( NNBJ *  jet, NNBJ *  begin, NNBJ *  end  )

private

                                      {
  double NN_dist = jet->beam_distance();
  NNBJ * NN      = NULL;
  for (NNBJ * jetB = begin; jetB != end; jetB++) {
    double dist = jet->distance(jetB);
    if (dist < NN_dist) {
      NN_dist = dist;
      NN = jetB;
    }
    if (dist < jetB->NN_dist) {
      jetB->NN_dist = dist;
      jetB->NN = jet;
    }
  }
  jet->NN = NN;
  jet->NN_dist = NN_dist;
}

set_NN_nocross()

void set_NN_nocross ( NNBJ *  jet, NNBJ *  begin, NNBJ *  end  )

private

                                                       {
  double NN_dist = jet->beam_distance();
  NNBJ * NN      = NULL;
  if (begin < jet) {
    for (NNBJ * jetB = begin; jetB != jet; jetB++) {
      double dist = jet->distance(jetB);
      if (dist < NN_dist) {
    NN_dist = dist;
    NN = jetB;
      }
    }
  }
  if (end > jet) {
    for (NNBJ * jetB = jet+1; jetB != end; jetB++) {
      double dist = jet->distance (jetB);
      if (dist < NN_dist) {
    NN_dist = dist;
    NN = jetB;
      }
    }
  }
  jet->NN = NN;
  jet->NN_dist = NN_dist;
}

start()

void start ( const std::vector< PseudoJet > &  jets )

virtual

Implements NNBase< _NoInfo >.

                                                                                   {
  n = jets.size();
  briefjets = new NNBJ[n];
  where_is.resize(2*n);
  NNBJ * jetA = briefjets;
  for (int i = 0; i< n; i++) {
    this->init_jet(jetA, jets[i], i);
    where_is[i] = jetA;
    jetA++; // move on to next entry of briefjets
  }
  tail = jetA; // a semaphore for the end of briefjets
  head = briefjets; // a nicer way of naming start
  for (jetA = head + 1; jetA != tail; jetA++) {
    set_NN_crosscheck(jetA, head, jetA);
  }
}

Member Data Documentation

briefjets

NNBJ* briefjets

private

head

NNBJ* head

private

n

int n

private

tail

NNBJ * tail

private

where_is

std::vector<NNBJ *> where_is

private

---

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

• /builds/cms-analysis/general/DasAnalysisSystem/Core/Installer/Core/JetObservables/interface/fjcore.hh