TilingExtent

Public Member Functions
	TilingExtent (ClusterSequence &cs)
	TilingExtent (const std::vector< PseudoJet > &particles)
double	minrap () const
double	maxrap () const
double	sum_of_binned_squared_multiplicity () const

Private Member Functions
void	_determine_rapidity_extent (const std::vector< PseudoJet > &particles)

Private Attributes
double	_minrap
double	_maxrap
double	_cumul2

Constructor & Destructor Documentation

TilingExtent() [1/2]

FJCORE_BEGIN_NAMESPACE TilingExtent

(

ClusterSequence &

cs

)

                                               {
  _determine_rapidity_extent(cs.jets());
}

TilingExtent() [2/2]

TilingExtent

(

const std::vector< PseudoJet > &

particles

)

                                                             {
  _determine_rapidity_extent(particles);
}

Member Function Documentation

_determine_rapidity_extent()

void _determine_rapidity_extent ( const std::vector< PseudoJet > &  particles )

private

                                                                                 {
  int nrap = 20;
  int nbins = 2*nrap;
  vector<double> counts(nbins, 0);
  _minrap =  numeric_limits<double>::max();
  _maxrap = -numeric_limits<double>::max();
  int ibin;
  for (unsigned i = 0; i < particles.size(); i++) {
    if (particles[i].E() == abs(particles[i].pz())) continue;
    double rap = particles[i].rap();
    if (rap < _minrap) _minrap = rap;
    if (rap > _maxrap) _maxrap = rap;
    ibin = int(rap+nrap);
    if (ibin < 0) ibin = 0;
    if (ibin >= nbins) ibin = nbins - 1;
    counts[ibin]++;
  }
  double max_in_bin = 0;
  for (ibin = 0; ibin < nbins; ibin++) {
    if (max_in_bin < counts[ibin]) max_in_bin = counts[ibin];
  }
  const double allowed_max_fraction = 0.25;
  const double min_multiplicity = 4;
  double allowed_max_cumul = floor(max(max_in_bin * allowed_max_fraction, min_multiplicity));
  if (allowed_max_cumul > max_in_bin) allowed_max_cumul = max_in_bin;
  double cumul_lo = 0;
  _cumul2 = 0;
  for (ibin = 0; ibin < nbins; ibin++) {
    cumul_lo += counts[ibin];
    if (cumul_lo >= allowed_max_cumul) {
      double y = ibin-nrap;
      if (y > _minrap) _minrap = y;
      break;
    }
  }
  assert(ibin != nbins); // internal consistency check that you found a bin
  _cumul2 += cumul_lo*cumul_lo;
  int ibin_lo = ibin;
  double cumul_hi = 0;
  for (ibin = nbins-1; ibin >= 0; ibin--) {
    cumul_hi += counts[ibin];
    if (cumul_hi >= allowed_max_cumul) {
      double y = ibin-nrap+1; // +1 here is the rapidity bin width
      if (y < _maxrap) _maxrap = y;
      break;
    }
  }
  assert(ibin >= 0); // internal consistency check that you found a bin
  int ibin_hi = ibin;
  assert(ibin_hi >= ibin_lo);
  if (ibin_hi == ibin_lo) {
    _cumul2 = pow(double(cumul_lo + cumul_hi - counts[ibin_hi]), 2);
  } else {
    _cumul2 += cumul_hi*cumul_hi;
    for (ibin = ibin_lo+1; ibin < ibin_hi; ibin++) {
      _cumul2 += counts[ibin]*counts[ibin];
    }
  }
}

maxrap()

double maxrap ( ) const

inline

{return _maxrap;}

minrap()

double minrap ( ) const

inline

{return _minrap;}

sum_of_binned_squared_multiplicity()

double sum_of_binned_squared_multiplicity ( ) const

inline

{return _cumul2;}

Member Data Documentation

_cumul2

double _cumul2

private

_maxrap

double _maxrap

private

_minrap

double _minrap

private

---

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

• /builds/cms-analysis/general/DasAnalysisSystem/Core/Installer/Core/JetObservables/src/fjcore.cc