Like ClusterSequence with computation of the active jet area. More...

#include <ClusterSequenceActiveArea.hh>

Inheritance diagram for fastjet::ClusterSequenceActiveArea:

Collaboration diagram for fastjet::ClusterSequenceActiveArea:

Public Types
enum	mean_pt_strategies { median = 0, non_ghost_median, pttot_over_areatot, pttot_over_areatot_cut, mean_ratio_cut, play, median_4vector }
	enum providing a variety of tentative strategies for estimating the background (e.g. More...
Public Member Functions
	ClusterSequenceActiveArea ()
	default constructor
template<class L >
	ClusterSequenceActiveArea (const std::vector< L > &pseudojets, const JetDefinition &jet_def, const GhostedAreaSpec &ghost_spec, const bool &writeout_combinations=false)
	constructor based on JetDefinition and GhostedAreaSpec
virtual double	area (const PseudoJet &jet) const
	return the area associated with the given jet; this base class returns 0.
virtual double	area_error (const PseudoJet &jet) const
	return the error (uncertainty) associated with the determination of the area of this jet; this base class returns 0.
virtual PseudoJet	area_4vector (const PseudoJet &jet) const
	return a PseudoJet whose 4-vector is defined by the following integral
double	pt_per_unit_area (mean_pt_strategies strat=median, double range=2.0) const
	return the transverse momentum per unit area according to one of the above strategies; for some strategies (those with "cut" in their name) the parameter "range" allows one to exclude a subset of the jets for the background estimation, those that have pt/area > median(pt/area)*range.
virtual double	empty_area (const RangeDefinition &range) const
	rewrite the empty area from the parent class, so as to use all info at our disposal return the total area, in the given y-phi range, that consists of ghost jets or unclustered ghosts
virtual double	n_empty_jets (const RangeDefinition &range) const
	return the true number of empty jets (replaces ClusterSequenceAreaBase::n_empty_jets(...))
Protected Member Functions
void	_resize_and_zero_AA ()
void	_initialise_AA (const JetDefinition &jet_def, const GhostedAreaSpec &ghost_spec, const bool &writeout_combinations, bool &continue_running)
void	_run_AA (const GhostedAreaSpec &ghost_spec)
void	_postprocess_AA (const GhostedAreaSpec &ghost_spec)
	run the postprocessing for the active area (and derived classes)
void	_initialise_and_run_AA (const JetDefinition &jet_def, const GhostedAreaSpec &ghost_spec, const bool &writeout_combinations=false)
	does the initialisation and running specific to the active areas class
void	_transfer_ghost_free_history (const ClusterSequenceActiveAreaExplicitGhosts &clust_seq)
	transfer the history (and jet-momenta) from clust_seq to our own internal structure while removing ghosts
void	_transfer_areas (const std::vector< int > &unique_hist_order, const ClusterSequenceActiveAreaExplicitGhosts &)
	transfer areas from the ClusterSequenceActiveAreaExplicitGhosts object into our internal area bookkeeping...
bool	has_dangerous_particles () const
	returns true if there are any particles whose transverse momentum if so low that there's a risk of the ghosts having modified the clustering sequence
Protected Attributes
std::valarray< double >	_average_area
	child classes benefit from having these at their disposal
std::valarray< double >	_average_area2
std::valarray< PseudoJet >	_average_area_4vector

Detailed Description

Like ClusterSequence with computation of the active jet area.

Class that behaves essentially like ClusterSequence except that it also provides access to the area of a jet (which will be a random quantity... Figure out what to do about seeds later...)

This class should not be used directly. Rather use ClusterSequenceArea with the appropriate AreaDefinition

Definition at line 63 of file ClusterSequenceActiveArea.hh.

Member Enumeration Documentation

enum fastjet::ClusterSequenceActiveArea::mean_pt_strategies

enum providing a variety of tentative strategies for estimating the background (e.g.

non-jet) activity in a highly populated event; the one that has been most extensively tested is median.

Definition at line 87 of file ClusterSequenceActiveArea.hh.

                         {median=0, non_ghost_median, pttot_over_areatot, 
                          pttot_over_areatot_cut, mean_ratio_cut, play,
                          median_4vector};

Member Function Documentation

virtual double fastjet::ClusterSequenceActiveArea::area ( const PseudoJet & ) const [inline, virtual]

return the area associated with the given jet; this base class returns 0.

Reimplemented from fastjet::ClusterSequenceAreaBase.

Definition at line 76 of file ClusterSequenceActiveArea.hh.

References fastjet::PseudoJet::cluster_hist_index().

Referenced by pt_per_unit_area().

                                                    {
                             return _average_area[jet.cluster_hist_index()];};

virtual double fastjet::ClusterSequenceActiveArea::area_error ( const PseudoJet & ) const [inline, virtual]

return the error (uncertainty) associated with the determination of the area of this jet; this base class returns 0.

Reimplemented from fastjet::ClusterSequenceAreaBase.

Definition at line 78 of file ClusterSequenceActiveArea.hh.

References fastjet::PseudoJet::cluster_hist_index().

                                                          {
                             return _average_area2[jet.cluster_hist_index()];};

virtual PseudoJet fastjet::ClusterSequenceActiveArea::area_4vector ( const PseudoJet & ) const [inline, virtual]

return a PseudoJet whose 4-vector is defined by the following integral

drap d PseudoJet("rap,phi,pt=one") * Theta("rap,phi inside jet boundary")

where PseudoJet("rap,phi,pt=one") is a 4-vector with the given rapidity (rap), azimuth (phi) and pt=1, while Theta("rap,phi inside jet boundary") is a function that is 1 when rap,phi define a direction inside the jet boundary and 0 otherwise.

This base class returns a null 4-vector.

Reimplemented from fastjet::ClusterSequenceAreaBase.

Definition at line 81 of file ClusterSequenceActiveArea.hh.

References fastjet::PseudoJet::cluster_hist_index().

Referenced by pt_per_unit_area().

                                                               {
                    return _average_area_4vector[jet.cluster_hist_index()];};

double fastjet::ClusterSequenceActiveArea::pt_per_unit_area	(	mean_pt_strategies	strat = `median`,
		double	range = `2.0`
	)			const

return the transverse momentum per unit area according to one of the above strategies; for some strategies (those with "cut" in their name) the parameter "range" allows one to exclude a subset of the jets for the background estimation, those that have pt/area > median(pt/area)*range.

NB: This call is OBSOLETE; use media_pt_per_unit_area from the

Definition at line 276 of file ClusterSequenceActiveArea.cc.

References area(), area_4vector(), fastjet::ClusterSequence::inclusive_jets(), and fastjet::PseudoJet::perp().

                                                                     {
  
  vector<PseudoJet> incl_jets = inclusive_jets();
  vector<double> pt_over_areas;

  for (unsigned i = 0; i < incl_jets.size(); i++) {
    if (abs(incl_jets[i].rap()) < _safe_rap_for_area) {
      double this_area;
      if ( strat == median_4vector ) {
          this_area = area_4vector(incl_jets[i]).perp();
      } else {
          this_area = area(incl_jets[i]);
      }
      pt_over_areas.push_back(incl_jets[i].perp()/this_area);
    }
  }
  
  // there is nothing inside our region, so answer will always be zero
  if (pt_over_areas.size() == 0) {return 0.0;}
  
  // get median (pt/area) [this is the "old" median definition. It considers
  // only the "real" jets in calculating the median, i.e. excluding the
  // only-ghost ones]
  sort(pt_over_areas.begin(), pt_over_areas.end());
  double non_ghost_median_ratio = pt_over_areas[pt_over_areas.size()/2];

  // new median definition that takes into account non-jet area (i.e.
  // jets composed only of ghosts), and for fractional median position 
  // interpolates between the corresponding entries in the pt_over_areas array
  double nj_median_pos = (pt_over_areas.size()-1 - _non_jet_number)/2.0;
  double nj_median_ratio;
  if (nj_median_pos >= 0 && pt_over_areas.size() > 1) {
    int int_nj_median = int(nj_median_pos);
    nj_median_ratio = 
      pt_over_areas[int_nj_median] * (int_nj_median+1-nj_median_pos)
      + pt_over_areas[int_nj_median+1] * (nj_median_pos - int_nj_median);
  } else {
    nj_median_ratio = 0.0;
  }


  // get various forms of mean (pt/area)
  double pt_sum = 0.0, pt_sum_with_cut = 0.0;
  double area_sum = _non_jet_area, area_sum_with_cut = _non_jet_area;
  double ratio_sum = 0.0; 
  double ratio_n = _non_jet_number;
  for (unsigned i = 0; i < incl_jets.size(); i++) {
    if (abs(incl_jets[i].rap()) < _safe_rap_for_area) {
      double this_area;
      if ( strat == median_4vector ) {
          this_area = area_4vector(incl_jets[i]).perp();
      } else {
          this_area = area(incl_jets[i]);
      }
      pt_sum   += incl_jets[i].perp();
      area_sum += this_area;
      double ratio = incl_jets[i].perp()/this_area;
      if (ratio < range*nj_median_ratio) {
        pt_sum_with_cut   += incl_jets[i].perp();
        area_sum_with_cut += this_area;
        ratio_sum += ratio; ratio_n++;
      }
    }
  }
  
  if (strat == play) {
    double trunc_sum = 0, trunc_sumsqr = 0;
    vector<double> means(pt_over_areas.size()), sd(pt_over_areas.size());
    for (unsigned i = 0; i < pt_over_areas.size() ; i++ ) {
      double ratio = pt_over_areas[i];
      trunc_sum += ratio;
      trunc_sumsqr += ratio*ratio;
      means[i] = trunc_sum / (i+1);
      sd[i]    = sqrt(abs(means[i]*means[i]  - trunc_sumsqr/(i+1)));
      cerr << "i, means, sd: " <<i<<", "<< means[i] <<", "<<sd[i]<<", "<<
        sd[i]/sqrt(i+1.0)<<endl;
    }
    cout << "-----------------------------------"<<endl;
    for (unsigned i = 0; i <= pt_over_areas.size()/2 ; i++ ) {
      cout << "Median "<< i <<" = " << pt_over_areas[i]<<endl;
    }
    cout << "Number of non-jets: "<<_non_jet_number<<endl;
    cout << "Area of non-jets: "<<_non_jet_area<<endl;
    cout << "Default median position: " << (pt_over_areas.size()-1)/2.0<<endl;
    cout << "NJ median position: " << nj_median_pos <<endl;
    cout << "NJ median value: " << nj_median_ratio <<endl;
    return 0.0;
  }

  switch(strat) {
  case median:
  case median_4vector:
    return nj_median_ratio;
  case non_ghost_median:
    return non_ghost_median_ratio; 
  case pttot_over_areatot:
    return pt_sum / area_sum;
  case pttot_over_areatot_cut:
    return pt_sum_with_cut / area_sum_with_cut;
  case mean_ratio_cut:
    return ratio_sum/ratio_n;
  default:
    return nj_median_ratio;
  }

}

void fastjet::ClusterSequenceActiveArea::_initialise_and_run_AA	(	const JetDefinition &	jet_def,
		const GhostedAreaSpec &	ghost_spec,
		const bool &	writeout_combinations = `false`
	)			`[protected]`

does the initialisation and running specific to the active areas class

global routine for running active area

Definition at line 53 of file ClusterSequenceActiveArea.cc.

References _postprocess_AA().

                                                    {

  bool continue_running;
  _initialise_AA(jet_def,  ghost_spec, writeout_combinations, continue_running);
  if (continue_running) {
    _run_AA(ghost_spec);
    _postprocess_AA(ghost_spec);
  }
}

void fastjet::ClusterSequenceActiveArea::_transfer_areas	(	const std::vector< int > &	unique_hist_order,
		const ClusterSequenceActiveAreaExplicitGhosts &
	)			`[protected]`

transfer areas from the ClusterSequenceActiveAreaExplicitGhosts object into our internal area bookkeeping...

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

include/fastjet/ClusterSequenceActiveArea.hh
src/ClusterSequenceActiveArea.cc

fastjet::ClusterSequenceActiveArea Class Reference [Secondary area-related classes]

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Member Enumeration Documentation

Member Function Documentation

fastjet::ClusterSequenceActiveArea Class Reference
[Secondary area-related classes]