#include <ClusterSequenceAreaBase.hh>
Inheritance diagram for fastjet::ClusterSequenceAreaBase:
Public Member Functions | |
| template<class L> | |
| ClusterSequenceAreaBase (const std::vector< L > &pseudojets, const JetDefinition &jet_def, const bool &writeout_combinations=false) | |
| a constructor which just carries out the construction of the parent class | |
| ClusterSequenceAreaBase () | |
| default constructor | |
| virtual | ~ClusterSequenceAreaBase () |
| destructor | |
| 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 | |
| virtual bool | is_pure_ghost (const PseudoJet &jet) const |
| true if a jet is made exclusively of ghosts | |
| virtual double | empty_area (const RangeDefinition &range) const |
| return the total area, within range, that is free of jets. | |
| virtual double | n_empty_jets (const RangeDefinition &range) const |
| return something similar to the number of pure ghost jets in the given range in an active area case. | |
| double | median_pt_per_unit_area (const RangeDefinition &range) const |
| the median of (pt/area) for jets contained within range, making use also of the info on n_empty_jets | |
| double | median_pt_per_unit_area_4vector (const RangeDefinition &range) const |
| the median of (pt/area_4vector) for jets contained within making use also of the info on n_empty_jets | |
| double | median_pt_per_unit_something (const RangeDefinition &range, bool use_area_4vector) const |
| the median of (pt/area) for jets contained within range, counting the empty area as if it were made up of a collection of empty jets each of area (0.55 * pi R^2). | |
| virtual void | get_median_rho_and_sigma (const RangeDefinition &range, bool use_area_4vector, double &median, double &sigma, double &mean_area) const |
| using jets withing range (and with 4-vector areas if use_area_4vector), calculate the median pt/area, as well as an "error" (uncertainty), which is defined as the 1-sigma half-width of the distribution of pt/A, obtained by looking for the point below which we have (1-0.6827)/2 of the jets (including empty jets). | |
| virtual void | get_median_rho_and_sigma (const RangeDefinition &range, bool use_area_4vector, double &median, double &sigma) const |
| same as the full version of get_median_rho_and_error, but without access to the mean_area | |
| virtual void | parabolic_pt_per_unit_area (double &a, double &b, const RangeDefinition &range, double exclude_above=-1.0, bool use_area_4vector=false) const |
| fits a form pt_per_unit_area(y) = a + b*y^2 for jets in range. | |
| std::vector< PseudoJet > | subtracted_jets (const double rho, const double ptmin=0.0) const |
| return a vector of all subtracted jets, using area_4vector, given rho. | |
| std::vector< PseudoJet > | subtracted_jets (const RangeDefinition &range, const double ptmin=0.0) const |
| return a vector of subtracted jets, using area_4vector. | |
| PseudoJet | subtracted_jet (const PseudoJet &jet, const double rho) const |
| return a subtracted jet, using area_4vector, given rho | |
| PseudoJet | subtracted_jet (const PseudoJet &jet, const RangeDefinition &range) const |
| return a subtracted jet, using area_4vector; note that this is potentially inefficient if repeatedly used for many different jets, because rho will be recalculated each time around. | |
| double | subtracted_pt (const PseudoJet &jet, const double rho, bool use_area_4vector=false) const |
| return the subtracted pt, given rho | |
| double | subtracted_pt (const PseudoJet &jet, const RangeDefinition &range, bool use_area_4vector=false) const |
| return the subtracted pt; note that this is potentially inefficient if repeatedly used for many different jets, because rho will be recalculated each time around. | |
Private Member Functions | |
| void | _check_jet_alg_good_for_median () const |
| check the jet algorithm is suitable (and if not issue a warning) | |
Static Private Attributes | |
| static LimitedWarning | _warnings |
| allow for warnings | |
the virtual functions here all return 0, since no area determination is implemented.
Definition at line 45 of file ClusterSequenceAreaBase.hh.
|
||||||||||||||||||||
|
a constructor which just carries out the construction of the parent class
Definition at line 51 of file ClusterSequenceAreaBase.hh. 00053 : 00054 ClusterSequence(pseudojets, jet_def, writeout_combinations) {}
|
|
|
default constructor
Definition at line 58 of file ClusterSequenceAreaBase.hh. 00058 {}
|
|
|
destructor
Definition at line 62 of file ClusterSequenceAreaBase.hh. 00062 {}
|
|
|
check the jet algorithm is suitable (and if not issue a warning)
Definition at line 296 of file ClusterSequenceAreaBase.cc. References _warnings, fastjet::cambridge_algorithm, fastjet::cambridge_for_passive_algorithm, fastjet::ClusterSequence::jet_def(), fastjet::kt_algorithm, and LimitedWarning::warn(). Referenced by get_median_rho_and_sigma(). 00296 {
00297 if (jet_def().jet_algorithm() != kt_algorithm
00298 && jet_def().jet_algorithm() != cambridge_algorithm
00299 && jet_def().jet_algorithm() != cambridge_for_passive_algorithm) {
00300 _warnings.warn("ClusterSequenceAreaBase: jet_def being used may not be suitable for estimating diffuse backgrounds (good options are kt, cam)");
00301 }
00302 }
|
|
|
return the area associated with the given jet; this base class returns 0.
Reimplemented in fastjet::ClusterSequenceActiveArea, fastjet::ClusterSequenceActiveAreaExplicitGhosts, fastjet::ClusterSequenceArea, and fastjet::ClusterSequenceVoronoiArea. Definition at line 67 of file ClusterSequenceAreaBase.hh. Referenced by empty_area(), get_median_rho_and_sigma(), parabolic_pt_per_unit_area(), print_jets(), and subtracted_pt(). 00067 {return 0.0;}
|
|
|
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 in fastjet::ClusterSequenceActiveArea, fastjet::ClusterSequenceActiveAreaExplicitGhosts, fastjet::ClusterSequenceArea, and fastjet::ClusterSequenceVoronoiArea. Definition at line 84 of file ClusterSequenceAreaBase.hh. Referenced by get_median_rho_and_sigma(), parabolic_pt_per_unit_area(), and subtracted_jet(). 00084 {
00085 return PseudoJet(0.0,0.0,0.0,0.0);}
|
|
|
return the error (uncertainty) associated with the determination of the area of this jet; this base class returns 0.
Reimplemented in fastjet::ClusterSequenceActiveArea, fastjet::ClusterSequenceArea, and fastjet::ClusterSequenceVoronoiArea. Definition at line 71 of file ClusterSequenceAreaBase.hh. Referenced by print_jets(). 00071 {return 0.0;}
|
|
|
return the total area, within range, that is free of jets. Calculate this as (range area) - {i in range} A_i Reimplemented in fastjet::ClusterSequenceActiveArea, fastjet::ClusterSequenceActiveAreaExplicitGhosts, fastjet::ClusterSequenceArea, and fastjet::ClusterSequencePassiveArea. Definition at line 51 of file ClusterSequenceAreaBase.cc. References area(), fastjet::RangeDefinition::area(), fastjet::ClusterSequence::inclusive_jets(), and fastjet::RangeDefinition::is_in_range(). Referenced by fastjet::ClusterSequencePassiveArea::empty_area(), and get_median_rho_and_sigma(). 00051 {
00052 double empty = range.area();
00053 vector<PseudoJet> incl_jets(inclusive_jets(0.0));
00054 for (unsigned i = 0; i < incl_jets.size(); i++) {
00055 if (range.is_in_range(incl_jets[i])) empty -= area(incl_jets[i]);
00056 }
00057 return empty;
00058 }
|
|
||||||||||||||||||||
|
same as the full version of get_median_rho_and_error, but without access to the mean_area
Reimplemented in fastjet::ClusterSequenceArea. Definition at line 147 of file ClusterSequenceAreaBase.hh. 00149 {
00150 double mean_area;
00151 get_median_rho_and_sigma(range, use_area_4vector,
00152 median, sigma, mean_area);
00153 }
|
|
||||||||||||||||||||||||
|
using jets withing range (and with 4-vector areas if use_area_4vector), calculate the median pt/area, as well as an "error" (uncertainty), which is defined as the 1-sigma half-width of the distribution of pt/A, obtained by looking for the point below which we have (1-0.6827)/2 of the jets (including empty jets). The subtraction for a jet with uncorrected pt pt^U and area A is pt^S = pt^U - median*A +- sigma*sqrt(A) where the error is only that associated with the fluctuations in the noise and not that associated with the noise having caused changes in the hard-particle content of the jet. (NB: subtraction may also be done with 4-vector area of course) Reimplemented in fastjet::ClusterSequenceArea. Definition at line 140 of file ClusterSequenceAreaBase.cc. References _check_jet_alg_good_for_median(), area(), area_4vector(), empty_area(), fastjet::ClusterSequence::inclusive_jets(), fastjet::RangeDefinition::is_in_range(), and n_empty_jets(). Referenced by median_pt_per_unit_something(). 00142 {
00143
00144 _check_jet_alg_good_for_median();
00145
00146 vector<double> pt_over_areas;
00147 vector<PseudoJet> incl_jets = inclusive_jets();
00148 double total_area = 0.0;
00149 double total_njets = 0;
00150
00151 for (unsigned i = 0; i < incl_jets.size(); i++) {
00152 if (range.is_in_range(incl_jets[i])) {
00153 double this_area;
00154 if (use_area_4vector) {
00155 this_area = area_4vector(incl_jets[i]).perp();
00156 } else {
00157 this_area = area(incl_jets[i]);
00158 }
00159 pt_over_areas.push_back(incl_jets[i].perp()/this_area);
00160 total_area += this_area;
00161 total_njets += 1.0;
00162 }
00163 }
00164
00165 // there is nothing inside our region, so answer will always be zero
00166 if (pt_over_areas.size() == 0) {
00167 median = 0.0;
00168 sigma = 0.0;
00169 mean_area = 0.0;
00170 return;
00171 }
00172
00173 // get median (pt/area) [this is the "old" median definition. It considers
00174 // only the "real" jets in calculating the median, i.e. excluding the
00175 // only-ghost ones]
00176 sort(pt_over_areas.begin(), pt_over_areas.end());
00177
00178 // now get the median & error, accounting for empty jets
00179 // define the fractions of distribution at median, median-1sigma
00180 double posn[2] = {0.5, (1.0-0.6827)/2.0};
00181 double res[2];
00182
00183 double n_empty = n_empty_jets(range);
00184 total_njets += n_empty;
00185 total_area += empty_area(range);
00186
00187 for (int i = 0; i < 2; i++) {
00188 double nj_median_pos =
00189 (pt_over_areas.size()-1 + n_empty)*posn[i] - n_empty;
00190 double nj_median_ratio;
00191 if (nj_median_pos >= 0 && pt_over_areas.size() > 1) {
00192 int int_nj_median = int(nj_median_pos);
00193 nj_median_ratio =
00194 pt_over_areas[int_nj_median] * (int_nj_median+1-nj_median_pos)
00195 + pt_over_areas[int_nj_median+1] * (nj_median_pos - int_nj_median);
00196 } else {
00197 nj_median_ratio = 0.0;
00198 }
00199 res[i] = nj_median_ratio;
00200 }
00201 median = res[0];
00202 double error = res[0] - res[1];
00203 mean_area = total_area / total_njets;
00204 sigma = error * sqrt(mean_area);
00205 }
|
|
|
true if a jet is made exclusively of ghosts NB: most area classes do not give any explicit ghost jets, but some do, and they should replace this function with their own version. Reimplemented in fastjet::ClusterSequenceActiveAreaExplicitGhosts, and fastjet::ClusterSequenceArea. Definition at line 92 of file ClusterSequenceAreaBase.hh. 00092 {
00093 return false;
00094 }
|
|
|
the median of (pt/area) for jets contained within range, making use also of the info on n_empty_jets
Definition at line 60 of file ClusterSequenceAreaBase.cc. References median_pt_per_unit_something(). Referenced by subtracted_pt(). 00060 {
00061 return median_pt_per_unit_something(range,false);
00062 }
|
|
|
the median of (pt/area_4vector) for jets contained within making use also of the info on n_empty_jets
Definition at line 64 of file ClusterSequenceAreaBase.cc. References median_pt_per_unit_something(). Referenced by subtracted_jet(), and subtracted_jets(). 00064 {
00065 return median_pt_per_unit_something(range,true);
00066 }
|
|
||||||||||||
|
the median of (pt/area) for jets contained within range, counting the empty area as if it were made up of a collection of empty jets each of area (0.55 * pi R^2).
Definition at line 73 of file ClusterSequenceAreaBase.cc. References get_median_rho_and_sigma(). Referenced by median_pt_per_unit_area(), and median_pt_per_unit_area_4vector(). 00074 {
00075
00076 double median, sigma, mean_area;
00077 get_median_rho_and_sigma(range, use_area_4vector, median, sigma, mean_area);
00078 return median;
00079
00080 }
|
|
|
return something similar to the number of pure ghost jets in the given range in an active area case. For the local implementation we return empty_area/(0.55 pi R^2), based on measured properties of ghost jets with kt and cam. Note that the number returned is a double. Reimplemented in fastjet::ClusterSequence1GhostPassiveArea, fastjet::ClusterSequenceActiveArea, and fastjet::ClusterSequenceArea. Definition at line 104 of file ClusterSequenceAreaBase.hh. References fastjet::pi. Referenced by get_median_rho_and_sigma(). 00104 {
00105 double R = jet_def().R();
00106 return empty_area(range)/(0.55*pi*R*R);
00107 }
|
|
||||||||||||||||||||||||
|
fits a form pt_per_unit_area(y) = a + b*y^2 for jets in range. exclude_above allows one to exclude large values of pt/area from fit. use_area_4vector = true uses the 4vector areas. Reimplemented in fastjet::ClusterSequenceArea. Definition at line 87 of file ClusterSequenceAreaBase.cc. References area(), area_4vector(), fastjet::ClusterSequence::inclusive_jets(), and fastjet::RangeDefinition::is_in_range(). 00089 {
00090
00091 int n=0;
00092 int n_excluded = 0;
00093 double mean_f=0, mean_x2=0, mean_x4=0, mean_fx2=0;
00094
00095 vector<PseudoJet> incl_jets = inclusive_jets();
00096
00097 for (unsigned i = 0; i < incl_jets.size(); i++) {
00098 if (range.is_in_range(incl_jets[i])) {
00099 double this_area;
00100 if ( use_area_4vector ) {
00101 this_area = area_4vector(incl_jets[i]).perp();
00102 } else {
00103 this_area = area(incl_jets[i]);
00104 }
00105 double f = incl_jets[i].perp()/this_area;
00106 if (exclude_above <= 0.0 || f < exclude_above) {
00107 double x = incl_jets[i].rap(); double x2 = x*x;
00108 mean_f += f;
00109 mean_x2 += x2;
00110 mean_x4 += x2*x2;
00111 mean_fx2 += f*x2;
00112 n++;
00113 } else {
00114 n_excluded++;
00115 }
00116 }
00117 }
00118
00119 if (n <= 1) {
00120 // meaningful results require at least two jets inside the
00121 // area -- mind you if there are empty jets we should be in
00122 // any case doing something special...
00123 a = 0.0;
00124 b = 0.0;
00125 } else {
00126 mean_f /= n;
00127 mean_x2 /= n;
00128 mean_x4 /= n;
00129 mean_fx2 /= n;
00130
00131 b = (mean_f*mean_x2 - mean_fx2)/(mean_x2*mean_x2 - mean_x4);
00132 a = mean_f - b*mean_x2;
00133 }
00134 //cerr << "n_excluded = "<< n_excluded << endl;
00135 }
|
|
||||||||||||
|
return a subtracted jet, using area_4vector; note that this is potentially inefficient if repeatedly used for many different jets, because rho will be recalculated each time around.
Definition at line 258 of file ClusterSequenceAreaBase.cc. References median_pt_per_unit_area_4vector(), and subtracted_jet(). 00259 {
00260 double rho = median_pt_per_unit_area_4vector(range);
00261 PseudoJet sub_jet = subtracted_jet(jet, rho);
00262 return sub_jet;
00263 }
|
|
||||||||||||
|
return a subtracted jet, using area_4vector, given rho
Definition at line 238 of file ClusterSequenceAreaBase.cc. References area_4vector(), fastjet::PseudoJet::cluster_hist_index(), fastjet::PseudoJet::perp(), and fastjet::PseudoJet::set_cluster_hist_index(). Referenced by subtracted_jet(), subtracted_jets(), and subtracted_pt(). 00239 {
00240 PseudoJet area4vect = area_4vector(jet);
00241 PseudoJet sub_jet;
00242 // sanity check
00243 if (rho*area4vect.perp() < jet.perp() ) {
00244 sub_jet = jet - rho*area4vect;
00245 } else { sub_jet = PseudoJet(0.0,0.0,0.0,0.0); }
00246
00247 // make sure the subtracted jet has the same index
00248 // (i.e. "looks like") the original jet
00249 sub_jet.set_cluster_hist_index(jet.cluster_hist_index());
00250
00251 return sub_jet;
00252 }
|
|
||||||||||||
|
return a vector of subtracted jets, using area_4vector. Only inclusive_jets above ptmin are subtracted and returned. the ordering is the same as that of sorted_by_pt(cs.inclusive_jets()), i.e. not necessarily ordered in pt once subtracted Definition at line 228 of file ClusterSequenceAreaBase.cc. References median_pt_per_unit_area_4vector(), and subtracted_jets(). 00231 {
00232 double rho = median_pt_per_unit_area_4vector(range);
00233 return subtracted_jets(rho,ptmin);
00234 }
|
|
||||||||||||
|
return a vector of all subtracted jets, using area_4vector, given rho. Only inclusive_jets above ptmin are subtracted and returned. the ordering is the same as that of sorted_by_pt(cs.inclusive_jets()), i.e. not necessarily ordered in pt once subtracted Definition at line 212 of file ClusterSequenceAreaBase.cc. References fastjet::ClusterSequence::inclusive_jets(), fastjet::ClusterSequence::jets(), fastjet::sorted_by_pt(), and subtracted_jet(). Referenced by subtracted_jets(). 00214 {
00215 vector<PseudoJet> sub_jets;
00216 vector<PseudoJet> jets = sorted_by_pt(inclusive_jets(ptmin));
00217 for (unsigned i=0; i<jets.size(); i++) {
00218 PseudoJet sub_jet = subtracted_jet(jets[i],rho);
00219 sub_jets.push_back(sub_jet);
00220 }
00221 return sub_jets;
00222 }
|
|
||||||||||||||||
|
return the subtracted pt; note that this is potentially inefficient if repeatedly used for many different jets, because rho will be recalculated each time around.
Definition at line 282 of file ClusterSequenceAreaBase.cc. References median_pt_per_unit_area(), fastjet::PseudoJet::perp(), subtracted_jet(), and subtracted_pt(). 00284 {
00285 if ( use_area_4vector ) {
00286 PseudoJet sub_jet = subtracted_jet(jet,range);
00287 return sub_jet.perp();
00288 } else {
00289 double rho = median_pt_per_unit_area(range);
00290 return subtracted_pt(jet,rho,false);
00291 }
00292 }
|
|
||||||||||||||||
|
return the subtracted pt, given rho
Definition at line 267 of file ClusterSequenceAreaBase.cc. References area(), fastjet::PseudoJet::perp(), and subtracted_jet(). Referenced by subtracted_pt(). 00269 {
00270 if ( use_area_4vector ) {
00271 PseudoJet sub_jet = subtracted_jet(jet,rho);
00272 return sub_jet.perp();
00273 } else {
00274 return jet.perp() - rho*area(jet);
00275 }
00276 }
|
|
|
allow for warnings
Reimplemented in fastjet::ClusterSequenceActiveAreaExplicitGhosts. Definition at line 44 of file ClusterSequenceAreaBase.cc. Referenced by _check_jet_alg_good_for_median(). |
1.4.2