Page MenuHomeHEPForge
Files F11221944

No OneTemporary
Actions

View Options

Index: contrib/contribs/EnergyCorrelator/trunk/ChangeLog
===================================================================
--- contrib/contribs/EnergyCorrelator/trunk/ChangeLog (revision 976)
+++ contrib/contribs/EnergyCorrelator/trunk/ChangeLog (revision 977)
@@ -1,209 +1,217 @@
2016-09-23 Lina Necib <lnecib@mit.edu>
+ * EnergyCorrelator.cc
+ Made the evaluation of ECFG faster by replacing sort -> partial_sort and simplified multiplication syntax
+ * example.cc/ref
+ Fixed minor typo
+
+
+2016-09-23 Lina Necib <lnecib@mit.edu>
+
* EnergyCorrelator.hh
Fixed minor doxygen typo
* example.cc/ref
Changed EnergyCorrelatorNormalized -> EnergyCorrelatorGeneralized in function explanations
* VERSION
Changed version to 1.2.0-rc2
2016-09-22 Jesse Thaler <jthaler@jthaler.net>
* EnergyCorrelator.cc/hh
Renamed EnergyCorrelatorNormalized -> EnergyCorrelatorGeneralized
Changed order of arguments for EnergyCorrelatorGeneralized
Updated doxygen documentation
* example_basic_usage.cc
Changed EnergyCorrelatorNormalized -> EnergyCorrelatorGeneralized
* README
Updated for EnergyCorrelatorGeneralized
2016-09-15 Lina Necib <lnecib@mit.edu>
*VERSION:
1.2.0-rc1
2016-08-24 Jesse Thaler <jthaler@jthaler.net>
Minor comment fixes throughout.
* EnergyCorrelator.cc/hh
Put in _helper_correlator when defining overall normalization
Removed angle error for result_all_angles()
*NEWS:
Made this more readable.
*README:
Clarified some of the documentation.
2016-08-23 Lina Necib <lnecib@mit.edu>
*VERSION:
*NEWS:
*AUTHORS:
*COPYING:
*README:
*EnergyCorrelator.cc
Added if statement that the ECF and ECFNs return exactly zero
if the number of particles is less than N of the ECF.
*EnergyCorrelator.hh
*example.cc
*example_basic_usage.cc
Updated this example.
2016-08-21 Lina Necib <lnecib@mit.edu>
*VERSION:
*NEWS:
*AUTHORS:
*COPYING:
*README:
*EnergyCorrelator.cc
Added Cseries.
*EnergyCorrelator.hh
Added Cseries.
*example.cc
Added example of Cseries
*example_basic_usage.cc
Simplified examples.
2016-08-17 Lina Necib <lnecib@mit.edu>
*VERSION:
*NEWS:
*AUTHORS:
Added placeholder for new reference
*COPYING:
Added placeholder for new reference
*README:
added information on different measures E_inv
*EnergyCorrelator.cc
Minor text edits + added comments
*EnergyCorrelator.hh
Minor text edits + added comments
*example_basic_usage.cc
added a simplified example file that shows the use of the
different observables.
2016-06-23 Lina Necib <lnecib@mit.edu>
*VERSION:
1.2.0-alpha0
*NEWS:
*AUTHORS:
Lina Necib
*COPYING:
*README:
added descriptions of functions that will appear shortly
arXiv:160X.XXXXX
*EnergyCorrelator.cc
added code to calculate normalized ECFS.
*EnergyCorrelator.hh
added code to calculate normalized ECFS, Nseries, generalized
D2, N2, N3, and M2.
*example.cc
added calculation of normalized ECFS, Nseries, generalized
D2, N2, N3, and M2 to example file.
2014-11-20 Jesse Thaler <jthaler@mit.edu>
* README:
Typos fixed
2014-11-13 Andrew Larkoski <larkoski@mit.edu>
*VERSION:
*NEWS:
release of version 1.1.0
*AUTHORS:
*COPYING:
*README:
added reference to arXiv:1409.6298.
*EnergyCorrelator.cc
*EnergyCorrelator.hh
added code to calculate C1, C2, and D2 observables.
*example.cc
added calculation of C1, C2, and D2 to example file.
2013-05-01 Gavin Salam <gavin.salam@cern.ch>
* VERSION:
* NEWS:
release of version 1.0.1
* README:
updated to reflect v1.0 interface.
2013-05-01 Jesse Thaler
* EnergyCorrelator.cc
Switched from NAN to std::numeric_limits<double>::quiet_NaN()
2013-04-30 Jesse Thaler
* EnergyCorrelator.cc
Implemented Gregory Soyez's suggestions on errors/asserts
2013-04-30 Gavin Salam <gavin.salam@cern.ch>
* VERSION:
* NEWS:
released v. 1.0.0
* EnergyCorrelator.hh:
* example.cc
small changes to documentation to reflect the change below + an
gave an explicit command-line in the example.
2013-04-29 Jesse Thaler
* EnergyCorrelator.cc
- Added support for N = 5
* example.cc|.ref
- Added N = 5 to test suite.
2013-04-29 Gavin Salam <gavin.salam@cern.ch>
* EnergyCorrelator.hh|cc:
- reduced memory usage from roughly 8n^2 to 4n^2 bytes (note that
sums are now performed in a different order, so results may
change to within rounding error).
- Implemented description() for all three classes.
- Worked on doxygen-style comments and moved some bits of code into
the .cc file.
* Doxyfile: *** ADDED ***
* example.cc:
developers' timing component now uses clock(), to get
finer-grained timing, and also outputs a description for some of
the correlators being used.
2013-04-26 + 04-27 Jesse Thaler <jthaler@MIT.EDU>
* EnergyCorrelator.hh|cc:
added temporary storage array for interparticle angles, to speed
up the energy correlator calculation for N>2
* example.cc
has internal option for printing out timing info.
2013-04-26 Gavin Salam <gavin.salam@cern.ch> + Jesse & Andrew
* Makefile:
added explicit dependencies
* example.cc (analyze):
added a little bit of commented code for timing tests.
2013-03-10 <jthaler>
Initial creation
Index: contrib/contribs/EnergyCorrelator/trunk/EnergyCorrelator.cc
===================================================================
--- contrib/contribs/EnergyCorrelator/trunk/EnergyCorrelator.cc (revision 976)
+++ contrib/contribs/EnergyCorrelator/trunk/EnergyCorrelator.cc (revision 977)
@@ -1,1080 +1,1080 @@
// EnergyCorrelator Package
// Questions/Comments? Email the authors:
// larkoski@mit.edu, lnecib@mit.edu,
// gavin.salam@cern.ch jthaler@jthaler.net
//
// Copyright (c) 2013-2016
// Andrew Larkoski, Lina Necib, Gavin Salam, and Jesse Thaler
//
// $Id$
//----------------------------------------------------------------------
// This file is part of FastJet contrib.
//
// It is free software; you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2 of the License, or (at
// your option) any later version.
//
// It is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
// or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
// License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this code. If not, see <http://www.gnu.org/licenses/>.
//----------------------------------------------------------------------
#include "EnergyCorrelator.hh"
#include <sstream>
#include <limits>
using namespace std;
FASTJET_BEGIN_NAMESPACE // defined in fastjet/internal/base.hh
namespace contrib {
double EnergyCorrelator::result(const PseudoJet& jet) const {
// if jet does not have constituents, throw error
if (!jet.has_constituents()) throw Error("EnergyCorrelator called on jet with no constituents.");
// get N = 0 case out of the way
if (_N == 0) return 1.0;
// find constituents
std::vector<fastjet::PseudoJet> particles = jet.constituents();
// return zero if the number of constituents is less than _N
if (particles.size() < _N) return 0.0 ;
double answer = 0.0;
// take care of N = 1 case.
if (_N == 1) {
for (unsigned int i = 0; i < particles.size(); i++) {
answer += energy(particles[i]);
}
return answer;
}
double half_beta = _beta/2.0;
// take care of N = 2 case.
if (_N == 2) {
for (unsigned int i = 0; i < particles.size(); i++) {
for (unsigned int j = i + 1; j < particles.size(); j++) { //note offset by one so that angle is never called on identical pairs
answer += energy(particles[i])
* energy(particles[j])
* pow(angleSquared(particles[i],particles[j]), half_beta);
}
}
return answer;
}
// if N > 5, then throw error
if (_N > 5) {
throw Error("EnergyCorrelator is only hard coded for N = 0,1,2,3,4,5");
}
// Now deal with N = 3,4,5. Different options if storage array is used or not.
if (_strategy == storage_array) {
// For N > 2, fill static storage array to save computation time.
// Make energy storage
std::vector<double> energyStore;
energyStore.resize(particles.size());
// Make angular storage
std::vector< std::vector<double> > angleStore;
angleStore.resize(particles.size());
for (unsigned int i = 0; i < angleStore.size(); i++) {
angleStore[i].resize(i);
}
// Fill storage with energy/angle information
for (unsigned int i = 0; i < particles.size(); i++) {
energyStore[i] = energy(particles[i]);
for (unsigned int j = 0; j < i; j++) {
angleStore[i][j] = pow(angleSquared(particles[i],particles[j]), half_beta);
}
}
// now do recursion
if (_N == 3) {
for (unsigned int i = 2; i < particles.size(); i++) {
for (unsigned int j = 1; j < i; j++) {
double ans_ij = energyStore[i]
* energyStore[j]
* angleStore[i][j];
for (unsigned int k = 0; k < j; k++) {
answer += ans_ij
* energyStore[k]
* angleStore[i][k]
* angleStore[j][k];
}
}
}
} else if (_N == 4) {
for (unsigned int i = 3; i < particles.size(); i++) {
for (unsigned int j = 2; j < i; j++) {
double ans_ij = energyStore[i]
* energyStore[j]
* angleStore[i][j];
for (unsigned int k = 1; k < j; k++) {
double ans_ijk = ans_ij
* energyStore[k]
* angleStore[i][k]
* angleStore[j][k];
for (unsigned int l = 0; l < k; l++) {
answer += ans_ijk
* energyStore[l]
* angleStore[i][l]
* angleStore[j][l]
* angleStore[k][l];
}
}
}
}
} else if (_N == 5) {
for (unsigned int i = 4; i < particles.size(); i++) {
for (unsigned int j = 3; j < i; j++) {
double ans_ij = energyStore[i]
* energyStore[j]
* angleStore[i][j];
for (unsigned int k = 2; k < j; k++) {
double ans_ijk = ans_ij
* energyStore[k]
* angleStore[i][k]
* angleStore[j][k];
for (unsigned int l = 1; l < k; l++) {
double ans_ijkl = ans_ijk
* energyStore[l]
* angleStore[i][l]
* angleStore[j][l]
* angleStore[k][l];
for (unsigned int m = 0; m < l; m++) {
answer += ans_ijkl
* energyStore[m]
* angleStore[i][m]
* angleStore[j][m]
* angleStore[k][m]
* angleStore[l][m];
}
}
}
}
}
} else {
assert(_N <= 5);
}
} else if (_strategy == slow) {
if (_N == 3) {
for (unsigned int i = 0; i < particles.size(); i++) {
for (unsigned int j = i + 1; j < particles.size(); j++) {
double ans_ij = energy(particles[i])
* energy(particles[j])
* pow(angleSquared(particles[i],particles[j]), half_beta);
for (unsigned int k = j + 1; k < particles.size(); k++) {
answer += ans_ij
* energy(particles[k])
* pow(angleSquared(particles[i],particles[k]), half_beta)
* pow(angleSquared(particles[j],particles[k]), half_beta);
}
}
}
} else if (_N == 4) {
for (unsigned int i = 0; i < particles.size(); i++) {
for (unsigned int j = i + 1; j < particles.size(); j++) {
double ans_ij = energy(particles[i])
* energy(particles[j])
* pow(angleSquared(particles[i],particles[j]), half_beta);
for (unsigned int k = j + 1; k < particles.size(); k++) {
double ans_ijk = ans_ij
* energy(particles[k])
* pow(angleSquared(particles[i],particles[k]), half_beta)
* pow(angleSquared(particles[j],particles[k]), half_beta);
for (unsigned int l = k + 1; l < particles.size(); l++) {
answer += ans_ijk
* energy(particles[l])
* pow(angleSquared(particles[i],particles[l]), half_beta)
* pow(angleSquared(particles[j],particles[l]), half_beta)
* pow(angleSquared(particles[k],particles[l]), half_beta);
}
}
}
}
} else if (_N == 5) {
for (unsigned int i = 0; i < particles.size(); i++) {
for (unsigned int j = i + 1; j < particles.size(); j++) {
double ans_ij = energy(particles[i])
* energy(particles[j])
* pow(angleSquared(particles[i],particles[j]), half_beta);
for (unsigned int k = j + 1; k < particles.size(); k++) {
double ans_ijk = ans_ij
* energy(particles[k])
* pow(angleSquared(particles[i],particles[k]), half_beta)
* pow(angleSquared(particles[j],particles[k]), half_beta);
for (unsigned int l = k + 1; l < particles.size(); l++) {
double ans_ijkl = ans_ijk
* energy(particles[l])
* pow(angleSquared(particles[i],particles[l]), half_beta)
* pow(angleSquared(particles[j],particles[l]), half_beta)
* pow(angleSquared(particles[k],particles[l]), half_beta);
for (unsigned int m = l + 1; m < particles.size(); m++) {
answer += ans_ijkl
* energy(particles[m])
* pow(angleSquared(particles[i],particles[m]), half_beta)
* pow(angleSquared(particles[j],particles[m]), half_beta)
* pow(angleSquared(particles[k],particles[m]), half_beta)
* pow(angleSquared(particles[l],particles[m]), half_beta);
}
}
}
}
}
} else {
assert(_N <= 5);
}
} else {
assert(_strategy == slow || _strategy == storage_array);
}
return answer;
}
double EnergyCorrelator::energy(const PseudoJet& jet) const {
if (_measure == pt_R) {
return jet.perp();
} else if (_measure == E_theta || _measure == E_inv) {
return jet.e();
} else {
assert(_measure==pt_R || _measure==E_theta || _measure==E_inv);
return std::numeric_limits<double>::quiet_NaN();
}
}
double EnergyCorrelator::angleSquared(const PseudoJet& jet1, const PseudoJet& jet2) const {
if (_measure == pt_R) {
return jet1.squared_distance(jet2);
} else if (_measure == E_theta) {
// doesn't seem to be a fastjet built in for this
double dot = jet1.px()*jet2.px() + jet1.py()*jet2.py() + jet1.pz()*jet2.pz();
double norm1 = jet1.px()*jet1.px() + jet1.py()*jet1.py() + jet1.pz()*jet1.pz();
double norm2 = jet2.px()*jet2.px() + jet2.py()*jet2.py() + jet2.pz()*jet2.pz();
double costheta = dot/(sqrt(norm1 * norm2));
if (costheta > 1.0) costheta = 1.0; // Need to handle case of numerical overflow
double theta = acos(costheta);
return theta*theta;
} else if (_measure == E_inv) {
if (jet1.E() < 0.0000001 || jet2.E() < 0.0000001) return 0.0;
else {
double dot4 = max(jet1.E()*jet2.E() - jet1.px()*jet2.px() - jet1.py()*jet2.py() - jet1.pz()*jet2.pz(),0.0);
return 2.0 * dot4 / jet1.E() / jet2.E();
}
} else {
assert(_measure==pt_R || _measure==E_theta || _measure==E_inv);
return std::numeric_limits<double>::quiet_NaN();
}
}
double EnergyCorrelatorGeneralized::result(const PseudoJet& jet) const {
// if jet does not have constituents, throw error
if (!jet.has_constituents()) throw Error("EnergyCorrelator called on jet with no constituents.");
// Throw an error if N < 0
if (_N < 0 ) throw Error("N cannot be negative");
// get N = 0 case out of the way
if (_N == 0) return 1.0;
// take care of N = 1 case.
if (_N == 1) return 1.0;
// find constituents
std::vector<fastjet::PseudoJet> particles = jet.constituents();
double answer = 0.0;
// return zero if the number of constituents is less than _N for the ECFG
if (particles.size() < _N) return 0.0 ;
// The normalization is the energy or pt of the jet, which is also ECF(1, beta)
double EJ = _helper_correlator.result(jet);
// The overall normalization
double norm = pow(EJ, _N);
// Find the max number of angles and throw an error if unsuitable
int N_total = int(_N*(_N-1)/2);
if (_angles > N_total) throw Error("Requested number of angles for EnergyCorrelatorGeneralized is larger than number of angles available");
if (_angles < -1) throw Error("Negative number of angles called for EnergyCorrelatorGeneralized");
double half_beta = _beta/2.0;
// take care of N = 2 case.
if (_N == 2) {
for (unsigned int i = 0; i < particles.size(); i++) {
for (unsigned int j = i + 1; j < particles.size(); j++) { //note offset by one so that angle is never called on identical pairs
answer += energy(particles[i])
* energy(particles[j])
* pow(angleSquared(particles[i],particles[j]), half_beta)/norm;
}
}
return answer;
}
// if N > 4, then throw error
if (_N > 5) {
throw Error("EnergyCorrelatorGeneralized is only hard coded for N = 0,1,2,3,4,5");
}
// Now deal with N = 3,4,5. Different options if storage array is used or not.
if (_strategy == EnergyCorrelator::storage_array) {
// For N > 2, fill static storage array to save computation time.
// Make energy storage
std::vector<double> energyStore;
energyStore.resize(particles.size());
// Make angular storage
std::vector < std::vector<double> > angleStore;
angleStore.resize(particles.size());
for (unsigned int i = 0; i < angleStore.size(); i++) {
angleStore[i].resize(i);
}
// Fill storage with energy/angle information
for (unsigned int i = 0; i < particles.size(); i++) {
energyStore[i] = energy(particles[i]);
for (unsigned int j = 0; j < i; j++) {
if (half_beta == 1.0){
angleStore[i][j] = angleSquared(particles[i], particles[j]);
} else {
angleStore[i][j] = pow(angleSquared(particles[i], particles[j]), half_beta);
}
}
}
// now do recursion
if (_N == 3) {
unsigned int N_total = 3;
double angle1, angle2, angle3;
double angle;
for (unsigned int i = 2; i < particles.size(); i++) {
for (unsigned int j = 1; j < i; j++) {
for (unsigned int k = 0; k < j; k++) {
angle1 = angleStore[i][j];
angle2 = angleStore[i][k];
angle3 = angleStore[j][k];
if (_angles == -1){
// When _angles = -1, it defaults to considering all angles.
angle = angle1*angle2*angle3;
} else {
double angle_list[] = {angle1, angle2, angle3};
std::vector<double> angle_vector(angle_list, angle_list + N_total);
- std::sort(angle_vector.begin(), angle_vector.begin() + N_total);
+ std::partial_sort(angle_vector.begin(), angle_vector.begin() + _angles, angle_vector.begin() + N_total);
angle = angle_vector[0];
- for ( int l = 1; l < _angles; l++) { angle = angle * angle_vector[l]; }
+ for ( int l = 1; l < _angles; l++) { angle *= angle_vector[l]; }
}
answer += energyStore[i]
* energyStore[j]
* energyStore[k]
* angle /norm;
}
}
}
} else if (_N == 4) {
double angle1, angle2, angle3, angle4, angle5, angle6;
unsigned int N_total = 6;
double angle;
for (unsigned int i = 3; i < particles.size(); i++) {
for (unsigned int j = 2; j < i; j++) {
for (unsigned int k = 1; k < j; k++) {
for (unsigned int l = 0; l < k; l++) {
angle1 = angleStore[i][j];
angle2 = angleStore[i][k];
angle3 = angleStore[i][l];
angle4 = angleStore[j][k];
angle5 = angleStore[j][l];
angle6 = angleStore[k][l];
if(_angles == -1) {
angle = angle1*angle2*angle3*angle4*angle5*angle6;
} else {
double angle_list[] = {angle1, angle2, angle3, angle4, angle5, angle6};
std::vector<double> angle_vector(angle_list, angle_list + N_total);
- std::sort(angle_vector.begin(), angle_vector.begin() + N_total);
+ std::partial_sort(angle_vector.begin(), angle_vector.begin() + _angles, angle_vector.begin() + N_total);
angle = angle_vector[0];
- for ( int s = 1; s < _angles; s++) { angle = angle * angle_vector[s]; }
+ for ( int s = 1; s < _angles; s++) { angle *= angle_vector[s]; }
}
answer += energyStore[i]
* energyStore[j]
* energyStore[k]
* energyStore[l]
* angle /norm;
}
}
}
}
} else if (_N == 5) {
double angle1, angle2, angle3, angle4, angle5, angle6, angle7, angle8, angle9, angle10;
unsigned int N_total = 10;
double angle;
for (unsigned int i = 4; i < particles.size(); i++) {
for (unsigned int j = 3; j < i; j++) {
for (unsigned int k = 2; k < j; k++) {
for (unsigned int l = 1; l < k; l++) {
for (unsigned int m = 0; m < l; m++) {
angle1 = angleStore[i][j];
angle2 = angleStore[i][k];
angle3 = angleStore[i][l];
angle4 = angleStore[i][m];
angle5 = angleStore[j][k];
angle6 = angleStore[j][l];
angle7 = angleStore[j][m];
angle8 = angleStore[k][l];
angle9 = angleStore[k][m];
angle10 = angleStore[l][m];
if (_angles == -1){
angle = angle1*angle2*angle3*angle4*angle5*angle6*angle7*angle8*angle9*angle10;
} else {
double angle_list[] = {angle1, angle2, angle3, angle4, angle5, angle6,
angle7, angle8, angle9, angle10};
std::vector<double> angle_vector(angle_list, angle_list + N_total);
- std::sort(angle_vector.begin(), angle_vector.begin() + N_total);
+ std::partial_sort(angle_vector.begin(), angle_vector.begin() + _angles, angle_vector.begin() + N_total);
angle = angle_vector[0];
- for ( int s = 1; s < _angles; s++) { angle = angle * angle_vector[s]; }
+ for ( int s = 1; s < _angles; s++) { angle *= angle_vector[s]; }
}
answer += energyStore[i]
* energyStore[j]
* energyStore[k]
* energyStore[l]
* energyStore[m]
* angle /norm;
}
}
}
}
}
} else {
assert(_N <= 5);
}
} else if (_strategy == EnergyCorrelator::slow) {
if (_N == 3) {
unsigned int N_total = 3;
double angle1, angle2, angle3;
double angle;
for (unsigned int i = 0; i < particles.size(); i++) {
for (unsigned int j = i + 1; j < particles.size(); j++) {
for (unsigned int k = j + 1; k < particles.size(); k++) {
angle1 = angleSquared(particles[i], particles[j]);
angle2 = angleSquared(particles[i], particles[k]);
angle3 = angleSquared(particles[j], particles[k]);
if (_angles == -1){
angle = angle1*angle2*angle3;
} else {
double angle_list[] = {angle1, angle2, angle3};
std::vector<double> angle_vector(angle_list, angle_list + N_total);
std::sort(angle_vector.begin(), angle_vector.begin() + N_total);
angle = angle_vector[0];
for ( int l = 1; l < _angles; l++) { angle = angle * angle_vector[l]; }
}
answer += energy(particles[i])
* energy(particles[j])
* energy(particles[k])
* pow(angle, half_beta) /norm;
}
}
}
} else if (_N == 4) {
double angle1, angle2, angle3, angle4, angle5, angle6;
unsigned int N_total = 6;
double angle;
for (unsigned int i = 0; i < particles.size(); i++) {
for (unsigned int j = i + 1; j < particles.size(); j++) {
for (unsigned int k = j + 1; k < particles.size(); k++) {
for (unsigned int l = k + 1; l < particles.size(); l++) {
angle1 = angleSquared(particles[i], particles[j]);
angle2 = angleSquared(particles[i], particles[k]);
angle3 = angleSquared(particles[i], particles[l]);
angle4 = angleSquared(particles[j], particles[k]);
angle5 = angleSquared(particles[j], particles[l]);
angle6 = angleSquared(particles[k], particles[l]);
if(_angles == -1) {
angle = angle1*angle2*angle3*angle4*angle5*angle6;
} else {
double angle_list[] = {angle1, angle2, angle3, angle4, angle5, angle6};
std::vector<double> angle_vector(angle_list, angle_list + N_total);
std::sort(angle_vector.begin(), angle_vector.begin() + N_total);
angle = angle_vector[0];
for ( int s = 1; s < _angles; s++) { angle = angle * angle_vector[s]; }
}
answer += energy(particles[i])
* energy(particles[j])
* energy(particles[k])
* energy(particles[l])
* pow(angle, half_beta)/norm;
}
}
}
}
} else if (_N == 5) {
double angle1, angle2, angle3, angle4, angle5, angle6, angle7, angle8, angle9, angle10;
unsigned int N_total = 10;
double angle;
for (unsigned int i = 0; i < particles.size(); i++) {
for (unsigned int j = i + 1; j < particles.size(); j++) {
for (unsigned int k = j + 1; k < particles.size(); k++) {
for (unsigned int l = k + 1; l < particles.size(); l++) {
for (unsigned int m = l + 1; m < particles.size(); m++) {
angle1 = angleSquared(particles[i], particles[j]);
angle2 = angleSquared(particles[i], particles[k]);
angle3 = angleSquared(particles[i], particles[l]);
angle4 = angleSquared(particles[j], particles[k]);
angle5 = angleSquared(particles[j], particles[l]);
angle6 = angleSquared(particles[k], particles[l]);
angle7 = angleSquared(particles[m], particles[i]);
angle8 = angleSquared(particles[m], particles[j]);
angle9 = angleSquared(particles[m], particles[k]);
angle10 = angleSquared(particles[m], particles[l]);
if (_angles == -1){
angle = angle1*angle2*angle3*angle4*angle5*angle6*angle7*angle8*angle9*angle10;
} else {
double angle_list[] = {angle1, angle2, angle3, angle4, angle5, angle6,
angle7, angle8, angle9, angle10};
std::vector<double> angle_vector(angle_list, angle_list + N_total);
std::sort(angle_vector.begin(), angle_vector.begin() + N_total);
angle = angle_vector[0];
for ( int s = 1; s < _angles; s++) { angle = angle * angle_vector[s]; }
}
answer += energy(particles[i])
* energy(particles[j])
* energy(particles[k])
* energy(particles[l])
* energy(particles[m])
* pow(angle, half_beta) /norm;
}
}
}
}
}
} else {
assert(_N <= 5);
}
} else {
assert(_strategy == EnergyCorrelator::slow || _strategy == EnergyCorrelator::storage_array);
}
return answer;
}
std::vector<double> EnergyCorrelatorGeneralized::result_all_angles(const PseudoJet& jet) const {
// if jet does not have constituents, throw error
if (!jet.has_constituents()) throw Error("EnergyCorrelator called on jet with no constituents.");
// Throw an error if N < 1
if (_N < 1 ) throw Error("N cannot be negative or zero");
// get the N = 1 case out of the way
if (_N == 1) {
std::vector<double> ans (1, 1.0);
return ans;
}
// find constituents
std::vector<fastjet::PseudoJet> particles = jet.constituents();
// return zero if the number of constituents is less than _N for the ECFG
if (particles.size() < _N) {
std::vector<double> ans (_N, 0.0);
return ans;
}
// The normalization is the energy or pt of the jet, which is also ECF(1, beta)
double EJ = _helper_correlator.result(jet);
// The overall normalization
double norm = pow(EJ, _N);
// Find the max number of angles and throw an error if it unsuitable
int N_total = _N * (_N - 1)/2;
double half_beta = _beta/2.0;
// take care of N = 2 case.
if (_N == 2) {
double answer = 0.0;
for (unsigned int i = 0; i < particles.size(); i++) {
for (unsigned int j = i + 1; j < particles.size(); j++) { //note offset by one so that angle is never called on identical pairs
answer += energy(particles[i])
* energy(particles[j])
* pow(angleSquared(particles[i],particles[j]), half_beta)/norm;
}
}
std::vector<double> ans(N_total, answer);
return ans;
}
// Prepare the answer vector
std::vector<double> ans (N_total, 0.0);
// if N > 4, then throw error
if (_N > 5) {
throw Error("EnergyCorrelatorGeneralized is only hard coded for N = 0,1,2,3,4,5");
}
// Now deal with N = 3,4,5. Different options if storage array is used or not.
if (_strategy == EnergyCorrelator::storage_array) {
// For N > 2, fill static storage array to save computation time.
// Make energy storage
std::vector<double> energyStore;
energyStore.resize(particles.size());
// Make angular storage
std::vector < std::vector<double> > angleStore;
angleStore.resize(particles.size());
for (unsigned int i = 0; i < angleStore.size(); i++) {
angleStore[i].resize(i);
}
// Fill storage with energy/angle information
for (unsigned int i = 0; i < particles.size(); i++) {
energyStore[i] = energy(particles[i]);
for (unsigned int j = 0; j < i; j++) {
if (half_beta == 1){
angleStore[i][j] = angleSquared(particles[i], particles[j]);
} else {
angleStore[i][j] = pow(angleSquared(particles[i], particles[j]), half_beta);
}
}
}
// now do recursion
if (_N == 3) {
double angle1, angle2, angle3;
for (unsigned int i = 2; i < particles.size(); i++) {
for (unsigned int j = 1; j < i; j++) {
for (unsigned int k = 0; k < j; k++) {
angle1 = angleStore[i][j];
angle2 = angleStore[i][k];
angle3 = angleStore[j][k];
double angle_list[] = {angle1, angle2, angle3};
std::vector<double> angle_vector(angle_list, angle_list + N_total);
std::sort(angle_vector.begin(), angle_vector.begin() + N_total);
std::vector<double> final_angles (N_total, angle_vector[0]);
double z_product = energyStore[i] * energyStore[j] * energyStore[k]/norm;
ans[0] += z_product * final_angles[0];
for ( int s=1 ; s<N_total; s++){
final_angles[s] = final_angles[s-1]*angle_vector[s];
ans[s] += z_product * final_angles[s];
}
}
}
}
} else if (_N == 4) {
double angle1, angle2, angle3, angle4, angle5, angle6;
for (unsigned int i = 3; i < particles.size(); i++) {
for (unsigned int j = 2; j < i; j++) {
for (unsigned int k = 1; k < j; k++) {
for (unsigned int l = 0; l < k; l++) {
angle1 = angleStore[i][j];
angle2 = angleStore[i][k];
angle3 = angleStore[i][l];
angle4 = angleStore[j][k];
angle5 = angleStore[j][l];
angle6 = angleStore[k][l];
double angle_list[] = {angle1, angle2, angle3, angle4, angle5, angle6};
std::vector<double> angle_vector(angle_list, angle_list + N_total);
std::sort(angle_vector.begin(), angle_vector.begin() + N_total);
std::vector<double> final_angles (N_total, angle_vector[0]);
double z_product = energyStore[i] * energyStore[j] * energyStore[k] * energyStore [l]/norm;
ans[0] += z_product * final_angles[0];
for ( int s=1 ; s<N_total; s++){
final_angles[s] = final_angles[s-1]*angle_vector[s];
ans[s] += z_product * final_angles[s];
}
}
}
}
}
} else if (_N == 5) {
double angle1, angle2, angle3, angle4, angle5, angle6, angle7, angle8, angle9, angle10;
for (unsigned int i = 4; i < particles.size(); i++) {
for (unsigned int j = 3; j < i; j++) {
for (unsigned int k = 2; k < j; k++) {
for (unsigned int l = 1; l < k; l++) {
for (unsigned int m = 0; m < l; m++) {
angle1 = angleStore[i][j];
angle2 = angleStore[i][k];
angle3 = angleStore[i][l];
angle4 = angleStore[i][m];
angle5 = angleStore[j][k];
angle6 = angleStore[j][l];
angle7 = angleStore[j][m];
angle8 = angleStore[k][l];
angle9 = angleStore[k][m];
angle10 = angleStore[l][m];
double angle_list[] = {angle1, angle2, angle3, angle4, angle5, angle6,
angle7, angle8, angle9, angle10};
std::vector<double> angle_vector(angle_list, angle_list + N_total);
std::sort(angle_vector.begin(), angle_vector.begin() + N_total);
std::vector<double> final_angles (N_total, angle_vector[0]);
double z_product = energyStore[i] * energyStore[j] * energyStore[k]
* energyStore[l] * energyStore[m]/norm;
ans[0] += z_product * final_angles[0];
for ( int s=1 ; s<N_total; s++){
final_angles[s] = final_angles[s-1]*angle_vector[s];
ans[s] += z_product * final_angles[s];
}
}
}
}
}
}
} else {
assert(_N <= 5);
}
} else if (_strategy == EnergyCorrelator::slow) {
if (_N == 3) {
double angle1, angle2, angle3;
for (unsigned int i = 0; i < particles.size(); i++) {
for (unsigned int j = i + 1; j < particles.size(); j++) {
for (unsigned int k = j + 1; k < particles.size(); k++) {
angle1 = pow(angleSquared(particles[i], particles[j]), half_beta);
angle2 = pow(angleSquared(particles[i], particles[k]), half_beta);
angle3 = pow(angleSquared(particles[j], particles[k]), half_beta);
double angle_list[] = {angle1, angle2, angle3};
std::vector<double> angle_vector(angle_list, angle_list + N_total);
std::sort(angle_vector.begin(), angle_vector.begin() + N_total);
std::vector<double> final_angles (N_total, angle_vector[0]);
double z_product = energy(particles[i])
* energy(particles[j])
* energy(particles[k])/norm;
ans[0] += z_product * final_angles[0];
for ( int s=1 ; s<N_total; s++){
final_angles[s] = final_angles[s-1]*angle_vector[s];
ans[s] += z_product * final_angles[s];
}
}
}
}
} else if (_N == 4) {
double angle1, angle2, angle3, angle4, angle5, angle6;
for (unsigned int i = 0; i < particles.size(); i++) {
for (unsigned int j = i + 1; j < particles.size(); j++) {
for (unsigned int k = j + 1; k < particles.size(); k++) {
for (unsigned int l = k + 1; l < particles.size(); l++) {
angle1 = pow(angleSquared(particles[i], particles[j]), half_beta);
angle2 = pow(angleSquared(particles[i], particles[k]), half_beta);
angle3 = pow(angleSquared(particles[i], particles[l]), half_beta);
angle4 = pow(angleSquared(particles[j], particles[k]), half_beta);
angle5 = pow(angleSquared(particles[j], particles[l]), half_beta);
angle6 = pow(angleSquared(particles[k], particles[l]), half_beta);
double angle_list[] = {angle1, angle2, angle3, angle4, angle5, angle6};
std::vector<double> angle_vector(angle_list, angle_list + N_total);
std::sort(angle_vector.begin(), angle_vector.begin() + N_total);
std::vector<double> final_angles (N_total, angle_vector[0]);
double z_product = energy(particles[i])
* energy(particles[j])
* energy(particles[k])
* energy(particles[l])/norm;
ans[0] += z_product * final_angles[0];
for ( int s=1 ; s<N_total; s++){
final_angles[s] = final_angles[s-1]*angle_vector[s];
ans[s] += z_product * final_angles[s];
}
}
}
}
}
} else if (_N == 5) {
double angle1, angle2, angle3, angle4, angle5, angle6, angle7, angle8, angle9, angle10;
for (unsigned int i = 0; i < particles.size(); i++) {
for (unsigned int j = i + 1; j < particles.size(); j++) {
for (unsigned int k = j + 1; k < particles.size(); k++) {
for (unsigned int l = k + 1; l < particles.size(); l++) {
for (unsigned int m = l + 1; m < particles.size(); m++) {
angle1 = pow(angleSquared(particles[i], particles[j]), half_beta);
angle2 = pow(angleSquared(particles[i], particles[k]), half_beta);
angle3 = pow(angleSquared(particles[i], particles[l]), half_beta);
angle4 = pow(angleSquared(particles[j], particles[k]), half_beta);
angle5 = pow(angleSquared(particles[j], particles[l]), half_beta);
angle6 = pow(angleSquared(particles[k], particles[l]), half_beta);
angle7 = pow(angleSquared(particles[m], particles[i]), half_beta);
angle8 = pow(angleSquared(particles[m], particles[j]), half_beta);
angle9 = pow(angleSquared(particles[m], particles[k]), half_beta);
angle10 = pow(angleSquared(particles[m], particles[l]), half_beta);
double angle_list[] = {angle1, angle2, angle3, angle4, angle5, angle6,
angle7, angle8, angle9, angle10};
std::vector<double> angle_vector(angle_list, angle_list + N_total);
std::sort(angle_vector.begin(), angle_vector.begin() + N_total);
std::vector<double> final_angles (N_total, angle_vector[0]);
double z_product = energy(particles[i])
* energy(particles[j])
* energy(particles[k])
* energy(particles[l])
* energy(particles[m])/norm;
ans[0] += z_product * final_angles[0];
for ( int s=1 ; s<N_total; s++){
final_angles[s] = final_angles[s-1]*angle_vector[s];
ans[s] += z_product * final_angles[s];
}
}
}
}
}
}
} else {
assert(_N <= 5);
}
} else {
assert(_strategy == EnergyCorrelator::slow || _strategy == EnergyCorrelator::storage_array);
}
return ans;
}
// call _helper_correlator to get energy information
double EnergyCorrelatorGeneralized::energy(const PseudoJet& jet) const {
return _helper_correlator.energy(jet);
}
// call _helper_correlator to get angle information
double EnergyCorrelatorGeneralized::angleSquared(const PseudoJet& jet1, const PseudoJet& jet2) const {
return _helper_correlator.angleSquared(jet1, jet2);
}
string EnergyCorrelator::description_parameters() const {
ostringstream oss;
oss << "N=" << _N << ", beta=" << _beta;
if (_measure == pt_R) oss << ", pt_R measure";
else if (_measure == E_theta) oss << ", E_theta measure";
else if (_measure == E_inv) oss << ", E_inv measure";
else throw Error("unrecognized measure");
if (_strategy == slow) oss << " and 'slow' strategy";
else if (_strategy == storage_array) oss << " and 'storage_array' strategy";
else throw Error("unrecognized strategy");
return oss.str();
}
string EnergyCorrelator::description_no_N() const {
ostringstream oss;
oss << "beta=" << _beta;
if (_measure == pt_R) oss << ", pt_R measure";
else if (_measure == E_theta) oss << ", E_theta measure";
else if (_measure == E_inv) oss << ", E_inv measure";
else throw Error("unrecognized measure");
if (_strategy == slow) oss << " and 'slow' strategy";
else if (_strategy == storage_array) oss << " and 'storage_array' strategy";
else throw Error("unrecognized strategy");
return oss.str();
}
string EnergyCorrelator::description() const {
ostringstream oss;
oss << "Energy Correlator ECF(N,beta) for ";
oss << description_parameters();
return oss.str();
}
string EnergyCorrelatorRatio::description() const {
ostringstream oss;
oss << "Energy Correlator ratio ECF(N+1,beta)/ECF(N,beta) for ";
oss << EnergyCorrelator(_N,_beta,_measure,_strategy).description_parameters();
return oss.str();
}
string EnergyCorrelatorDoubleRatio::description() const {
ostringstream oss;
oss << "Energy Correlator double ratio ECF(N-1,beta)ECF(N+1,beta)/ECF(N,beta)^2 for ";
oss << EnergyCorrelator(_N,_beta,_measure,_strategy).description_parameters();
return oss.str();
}
string EnergyCorrelatorC1::description() const {
ostringstream oss;
oss << "Energy Correlator observable C1 ECF(2,beta)/ECF(1,beta)^2 for ";
oss << EnergyCorrelator(2,_beta,_measure,_strategy).description_no_N();
return oss.str();
}
string EnergyCorrelatorC2::description() const {
ostringstream oss;
oss << "Energy Correlator observable C2 ECF(3,beta)*ECF(1,beta)/ECF(2,beta)^2 for ";
oss << EnergyCorrelator(3,_beta,_measure,_strategy).description_no_N();
return oss.str();
}
string EnergyCorrelatorD2::description() const {
ostringstream oss;
oss << "Energy Correlator observable D2 ECF(3,beta)*ECF(1,beta)^3/ECF(2,beta)^3 for ";
oss << EnergyCorrelator(3,_beta,_measure,_strategy).description_no_N();
return oss.str();
}
string EnergyCorrelatorGeneralizedD2::description() const {
ostringstream oss;
oss << "Energy Correlator observable D2 ECFN(3,alpha)/ECFN(2,beta)^(3 alpha/beta) for ";
oss << EnergyCorrelator(3,_beta,_measure,_strategy).description_no_N();
return oss.str();
}
string EnergyCorrelatorNseries::description() const {
ostringstream oss;
oss << "Energy Correlator observable N_n ECFG(2,n+1,beta)/ECFG(1,n,beta)^2 for ";
oss << EnergyCorrelator(3,_beta,_measure,_strategy).description_no_N();
return oss.str();
}
string EnergyCorrelatorMseries::description() const {
ostringstream oss;
oss << "Energy Correlator observable M_n ECFG(1,n+1,beta)/ECFG(1,n,beta) for ";
oss << EnergyCorrelator(3,_beta,_measure,_strategy).description_no_N();
return oss.str();
}
string EnergyCorrelatorN2::description() const {
ostringstream oss;
oss << "Energy Correlator observable N2 ECFG(2,3,beta)/ECFG(1,2,beta)^2 for ";
oss << EnergyCorrelator(3,_beta,_measure,_strategy).description_no_N();
return oss.str();
}
string EnergyCorrelatorN3::description() const {
ostringstream oss;
oss << "Energy Correlator observable N3 ECFG(2,4,beta)/ECFG(1,3,beta)^2 for ";
oss << EnergyCorrelator(3,_beta,_measure,_strategy).description_no_N();
return oss.str();
}
string EnergyCorrelatorM2::description() const {
ostringstream oss;
oss << "Energy Correlator observable M2 ECFG(1,3,beta)/ECFG(1,2,beta) for ";
oss << EnergyCorrelator(3,_beta,_measure,_strategy).description_no_N();
return oss.str();
}
string EnergyCorrelatorCseries::description() const {
ostringstream oss;
oss << "Energy Correlator double ratio ECFN(N-1,beta)ECFN(N+1,beta)/ECFN(N,beta)^2 for ";
oss << EnergyCorrelator(_N,_beta,_measure,_strategy).description_parameters();
return oss.str();
}
string EnergyCorrelatorUseries::description() const {
ostringstream oss;
oss << "Energy Correlator observable U_n ECFG(1,n+1,beta) for ";
oss << EnergyCorrelator(3,_beta,_measure,_strategy).description_no_N();
return oss.str();
}
string EnergyCorrelatorU1::description() const {
ostringstream oss;
oss << "Energy Correlator observable U_1 ECFG(1,2,beta) for ";
oss << EnergyCorrelator(3,_beta,_measure,_strategy).description_no_N();
return oss.str();
}
string EnergyCorrelatorU2::description() const {
ostringstream oss;
oss << "Energy Correlator observable U_2 ECFG(1,3,beta) for ";
oss << EnergyCorrelator(3,_beta,_measure,_strategy).description_no_N();
return oss.str();
}
string EnergyCorrelatorU3::description() const {
ostringstream oss;
oss << "Energy Correlator observable U_3 ECFG(1,4,beta) for ";
oss << EnergyCorrelator(3,_beta,_measure,_strategy).description_no_N();
return oss.str();
}
} // namespace contrib
FASTJET_END_NAMESPACE
Index: contrib/contribs/EnergyCorrelator/trunk/example.cc
===================================================================
--- contrib/contribs/EnergyCorrelator/trunk/example.cc (revision 976)
+++ contrib/contribs/EnergyCorrelator/trunk/example.cc (revision 977)
@@ -1,595 +1,655 @@
// Example showing usage of energy correlator classes.
//
// Compile it with "make example" and run it with
//
// ./example < ../data/single-event.dat
//
// Copyright (c) 2013-2016
// Andrew Larkoski, Lina Necib, Gavin Salam, and Jesse Thaler
//
// $Id$
//----------------------------------------------------------------------
// This file is part of FastJet contrib.
//
// It is free software; you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2 of the License, or (at
// your option) any later version.
//
// It is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
// or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
// License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this code. If not, see <http://www.gnu.org/licenses/>.
//----------------------------------------------------------------------
#include <iomanip>
#include <stdlib.h>
#include <stdio.h>
#include <ctime>
#include <iostream>
#include <istream>
#include <fstream>
#include <sstream>
#include <string>
#include "fastjet/PseudoJet.hh"
#include "fastjet/ClusterSequence.hh"
#include "fastjet/JetDefinition.hh"
#include <sstream>
#include "EnergyCorrelator.hh" // In external code, this should be fastjet/contrib/EnergyCorrelator.hh
using namespace std;
using namespace fastjet;
using namespace fastjet::contrib;
// forward declaration to make things clearer
void read_event(vector<PseudoJet> &event);
void analyze(const vector<PseudoJet> & input_particles);
//----------------------------------------------------------------------
int main(){
//----------------------------------------------------------
// read in input particles
vector<PseudoJet> event;
read_event(event);
cout << "# read an event with " << event.size() << " particles" << endl;
//----------------------------------------------------------
// illustrate how this EnergyCorrelator contrib works
analyze(event);
return 0;
}
// read in input particles
void read_event(vector<PseudoJet> &event){
string line;
while (getline(cin, line)) {
istringstream linestream(line);
// take substrings to avoid problems when there are extra "pollution"
// characters (e.g. line-feed).
if (line.substr(0,4) == "#END") {return;}
if (line.substr(0,1) == "#") {continue;}
double px,py,pz,E;
linestream >> px >> py >> pz >> E;
PseudoJet particle(px,py,pz,E);
// push event onto back of full_event vector
event.push_back(particle);
}
}
////////
//
// Main Routine for Analysis
//
///////
void analyze(const vector<PseudoJet> & input_particles) {
/////// EnergyCorrelator /////////////////////////////
// Initial clustering with anti-kt algorithm
JetAlgorithm algorithm = antikt_algorithm;
double jet_rad = 1.00; // jet radius for anti-kt algorithm
JetDefinition jetDef = JetDefinition(algorithm,jet_rad,E_scheme,Best);
ClusterSequence clust_seq(input_particles,jetDef);
vector<PseudoJet> antikt_jets = sorted_by_pt(clust_seq.inclusive_jets());
for (int j = 0; j < 2; j++) { // Two hardest jets per event
if (antikt_jets[j].perp() > 200) {
PseudoJet myJet = antikt_jets[j];
// various values of beta
vector<double> betalist;
betalist.push_back(0.1);
betalist.push_back(0.2);
betalist.push_back(0.5);
betalist.push_back(1.0);
betalist.push_back(1.5);
betalist.push_back(2.0);
// various values of alpha
vector<double> alphalist;
alphalist.push_back(0.1);
alphalist.push_back(0.2);
alphalist.push_back(0.5);
alphalist.push_back(1.0);
// checking the two energy/angle modes
vector<EnergyCorrelator::Measure> measurelist;
measurelist.push_back(EnergyCorrelator::pt_R);
measurelist.push_back(EnergyCorrelator::E_theta);
//measurelist.push_back(EnergyCorrelator::E_inv);
vector<string> modename;
modename.push_back("pt_R");
modename.push_back("E_theta");
//modename.push_back("E_inv");
for (unsigned int M = 0; M < measurelist.size(); M++) {
cout << "-------------------------------------------------------------------------------------" << endl;
cout << "EnergyCorrelator: ECF(N,beta) with " << modename[M] << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
printf("%7s %14s %14s %14s %14s %15s\n","beta", "N=1 (GeV)", "N=2 (GeV^2)", "N=3 (GeV^3)", "N=4 (GeV^4)", "N=5 (GeV^5)");
for (unsigned int B = 0; B < betalist.size(); B++) {
double beta = betalist[B];
EnergyCorrelator ECF0(0,beta,measurelist[M]);
EnergyCorrelator ECF1(1,beta,measurelist[M]);
EnergyCorrelator ECF2(2,beta,measurelist[M]);
EnergyCorrelator ECF3(3,beta,measurelist[M]);
EnergyCorrelator ECF4(4,beta,measurelist[M]);
EnergyCorrelator ECF5(5,beta,measurelist[M]);
printf("%7.3f %14.2f %14.2f %14.2f %14.2f %15.2f \n",beta,ECF1(myJet),ECF2(myJet),ECF3(myJet),ECF4(myJet),ECF5(myJet));
}
cout << "-------------------------------------------------------------------------------------" << endl << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
cout << "EnergyCorrelatorRatio: r_N^(beta) = ECF(N+1,beta)/ECF(N,beta) with " << modename[M] << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
printf("%7s %14s %14s %14s %14s %15s \n","beta", "N=0 (GeV)", "N=1 (GeV)", "N=2 (GeV)", "N=3 (GeV)","N=4 (GeV)");
for (unsigned int B = 0; B < betalist.size(); B++) {
double beta = betalist[B];
EnergyCorrelatorRatio r0(0,beta,measurelist[M]);
EnergyCorrelatorRatio r1(1,beta,measurelist[M]);
EnergyCorrelatorRatio r2(2,beta,measurelist[M]);
EnergyCorrelatorRatio r3(3,beta,measurelist[M]);
EnergyCorrelatorRatio r4(4,beta,measurelist[M]);
printf("%7.3f %14.4f %14.4f %14.4f %14.4f %15.4f \n",beta,r0(myJet),r1(myJet),r2(myJet),r3(myJet),r4(myJet));
}
cout << "-------------------------------------------------------------------------------------" << endl << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
cout << "EnergyCorrelatorDoubleRatio: C_N^(beta) = r_N^(beta)/r_{N-1}^(beta) with " << modename[M] << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
printf("%7s %14s %14s %14s %14s \n","beta", "N=1", "N=2", "N=3", "N=4");
for (unsigned int B = 0; B < betalist.size(); B++) {
double beta = betalist[B];
EnergyCorrelatorDoubleRatio C1(1,beta,measurelist[M]);
EnergyCorrelatorDoubleRatio C2(2,beta,measurelist[M]);
EnergyCorrelatorDoubleRatio C3(3,beta,measurelist[M]);
EnergyCorrelatorDoubleRatio C4(4,beta,measurelist[M]);
printf("%7.3f %14.6f %14.6f %14.6f %14.6f \n",beta,C1(myJet),C2(myJet),C3(myJet),C4(myJet));
}
cout << "-------------------------------------------------------------------------------------" << endl << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
cout << "EnergyCorrelatorC1: C_1^(beta) = ECF(2,beta)/ECF(1,beta)^2 with " << modename[M] << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
printf("%7s %14s \n","beta","C1 obs");
for (unsigned int B = 0; B < betalist.size(); B++) {
double beta = betalist[B];
EnergyCorrelatorC1 c1(beta,measurelist[M]);
printf("%7.3f %14.6f \n",beta,c1(myJet));
}
cout << "-------------------------------------------------------------------------------------" << endl << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
cout << "EnergyCorrelatorC2: C_2^(beta) = ECF(3,beta)*ECF(1,beta)/ECF(2,beta)^2 with " << modename[M] << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
printf("%7s %14s \n","beta","C2 obs");
for (unsigned int B = 0; B < betalist.size(); B++) {
double beta = betalist[B];
EnergyCorrelatorC2 c2(beta,measurelist[M]);
printf("%7.3f %14.6f \n",beta,c2(myJet));
}
cout << "-------------------------------------------------------------------------------------" << endl << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
cout << "EnergyCorrelatorD2: D_2^(beta) = ECF(3,beta)*ECF(1,beta)^3/ECF(2,beta)^3 with " << modename[M] << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
printf("%7s %14s \n","beta","D2 obs");
for (unsigned int B = 0; B < betalist.size(); B++) {
double beta = betalist[B];
EnergyCorrelatorD2 d2(beta,measurelist[M]);
printf("%7.3f %14.6f \n",beta,d2(myJet));
}
cout << "-------------------------------------------------------------------------------------" << endl << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
cout << "EnergyCorrelatorGeneralizedD2: D_2^(alpha, beta) = ECFN(3,alpha)/ECFN(2,beta)^(3*alpha/beta) with " << modename[M] << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
printf("%7s %18s %18s %18s %18s\n","beta","alpha = 0.100","alpha = 0.200","alpha = 0.500","alpha = 1.000");
for (unsigned int B = 1; B < betalist.size(); B++) {
double beta = betalist[B];
printf("%7.3f ", beta);
for (unsigned int A = 0; A < alphalist.size(); A++) {
double alpha = alphalist[A];
EnergyCorrelatorGeneralizedD2 d2(alpha, beta, measurelist[M]);
printf("%18.4f ", d2(myJet));
}
printf("\n");
}
cout << "-------------------------------------------------------------------------------------" << endl << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
cout << "EnergyCorrelatorGeneralized (angles = N Choose 2): ECFN(N, beta) with " << modename[M] << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
printf("%7s %7s %14s %14s %14s\n","beta", "N=1", "N=2", "N=3", "N=4");
for (unsigned int B = 0; B < betalist.size(); B++) {
double beta = betalist[B];
EnergyCorrelatorGeneralized ECF1(-1,1, beta, measurelist[M]);
EnergyCorrelatorGeneralized ECF2(-1,2, beta, measurelist[M]);
EnergyCorrelatorGeneralized ECF3(-1,3, beta, measurelist[M]);
EnergyCorrelatorGeneralized ECF4(-1,4, beta, measurelist[M]);
//EnergyCorrelatorGeneralized ECF5(-1, 5, beta, measurelist[M]);
printf("%7.3f %7.2f %14.10f %14.10f %14.10f \n", beta, ECF1(myJet), ECF2(myJet), ECF3(myJet),
ECF4(myJet));
}
cout << "-------------------------------------------------------------------------------------" <<
endl << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
cout << "EnergyCorrelatorGeneralized: ECFG(angles, N, beta=1) with " << modename[M] << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
printf("%7s %7s %14s %14s %14s\n","angles", "N=1", "N=2", "N=3", "N=4");
double beta = 1.0;
for (unsigned int A = 1; A < 2; A++) {
double angle = A;
EnergyCorrelatorGeneralized ECF1(angle, 1, beta, measurelist[M]);
EnergyCorrelatorGeneralized ECF2(angle, 2, beta, measurelist[M]);
EnergyCorrelatorGeneralized ECF3(angle, 3, beta, measurelist[M]);
EnergyCorrelatorGeneralized ECF4(angle, 4, beta, measurelist[M], EnergyCorrelator::slow);
printf("%7.0f %7.2f %14.10f %14.10f %14.10f \n", angle, ECF1(myJet), ECF2(myJet), ECF3(myJet),
ECF4(myJet));
}
for (unsigned int A = 2; A < 4; A++) {
double angle = A;
EnergyCorrelatorGeneralized ECF3(angle, 3, beta, measurelist[M]);
EnergyCorrelatorGeneralized ECF4(angle, 4, beta, measurelist[M]);
printf("%7.0f %7s %14s %14.10f %14.10f \n", angle, " " , " " ,ECF3(myJet), ECF4(myJet));
}
for (unsigned int A = 4; A < 7; A++) {
double angle = A;
EnergyCorrelatorGeneralized ECF4(angle, 4, beta, measurelist[M]);
printf("%7.0f %7s %14s %14s %14.10f \n", angle, " ", " ", " ", ECF4(myJet) );
}
cout << "-------------------------------------------------------------------------------------" <<
endl << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
cout << "EnergyCorrelatorNseries: N_i(beta) = ECFG(i+1, 2, beta)/ECFG(i, 1, beta)^2 with " << modename[M] << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
printf("%7s %14s %14s %14s \n","beta", "N=1", "N=2", "N=3");
for (unsigned int B = 0; B < betalist.size(); B++) {
double beta = betalist[B];
EnergyCorrelatorNseries N1(1,beta,measurelist[M]);
EnergyCorrelatorNseries N2(2,beta,measurelist[M]);
EnergyCorrelatorNseries N3(3,beta,measurelist[M]);
printf("%7.3f %14.6f %14.6f %14.6f \n",beta,N1(myJet),N2(myJet),N3(myJet));
}
cout << "-------------------------------------------------------------------------------------" << endl << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
cout << "EnergyCorrelatorN2: N2(beta) = ECFG(3, 2, beta)/ECFG(2, 1, beta)^2 with " << modename[M] << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
printf("%7s %14s \n","beta", "N2 obs");
for (unsigned int B = 0; B < betalist.size(); B++) {
double beta = betalist[B];
EnergyCorrelatorN2 N2(beta,measurelist[M]);
printf("%7.3f %14.6f \n",beta,N2(myJet));
}
cout << "-------------------------------------------------------------------------------------" << endl << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
cout << "EnergyCorrelatorN3: N3(beta) = ECFG(4, 2, beta)/ECFG(3, 1, beta)^2 with " << modename[M] << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
printf("%7s %14s \n","beta", "N3 obs");
for (unsigned int B = 0; B < betalist.size(); B++) {
double beta = betalist[B];
EnergyCorrelatorN3 N3(beta,measurelist[M]);
printf("%7.3f %14.6f \n",beta,N3(myJet));
}
cout << "-------------------------------------------------------------------------------------" << endl << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
cout << "EnergyCorrelatorMseries: M_i(beta) = ECFG(i+1, 1, beta)/ECFN(i, 1, beta) with " << modename[M] << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
printf("%7s %14s %14s %14s \n","beta", "N=1", "N=2", "N=3");
for (unsigned int B = 0; B < betalist.size(); B++) {
double beta = betalist[B];
EnergyCorrelatorMseries M1(1,beta,measurelist[M]);
EnergyCorrelatorMseries M2(2,beta,measurelist[M]);
EnergyCorrelatorMseries M3(3,beta,measurelist[M]);
printf("%7.3f %14.6f %14.6f %14.6f \n",beta,M1(myJet),M2(myJet),M3(myJet));
}
cout << "-------------------------------------------------------------------------------------" << endl << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
cout << "EnergyCorrelatorM2: M2(beta) = ECFG(3, 1, beta)/ECFG(3, 1, beta) with " << modename[M] << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
printf("%7s %14s \n","beta", "M2 obs");
for (unsigned int B = 0; B < betalist.size(); B++) {
double beta = betalist[B];
EnergyCorrelatorM2 M2(beta,measurelist[M]);
printf("%7.3f %14.6f \n",beta,M2(myJet));
}
cout << "-------------------------------------------------------------------------------------" << endl << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
cout << "EnergyCorrelatorCseries: C_i(beta) = ECFN(i-1, beta)*ECFN(i+1, beta)/ECFN(i, beta)^2 with " << modename[M] << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
printf("%7s %20s %20s %20s \n","beta", "N=1", "N=2", "N=3");
for (unsigned int B = 0; B < betalist.size(); B++) {
double beta = betalist[B];
EnergyCorrelatorCseries C1(1,beta,measurelist[M]);
EnergyCorrelatorCseries C2(2,beta,measurelist[M]);
EnergyCorrelatorCseries C3(3,beta,measurelist[M]);
printf("%7.3f %20.10f %20.10f %20.10f \n",beta,C1(myJet),C2(myJet),C3(myJet));
}
cout << "-------------------------------------------------------------------------------------" << endl << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
cout << "EnergyCorrelatorUseries: U_i(beta) = ECFG(i+1, 1, beta) with " << modename[M] << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
printf("%7s %20s %20s %20s \n","beta", "N=1", "N=2", "N=3");
for (unsigned int B = 0; B < betalist.size(); B++) {
double beta = betalist[B];
EnergyCorrelatorUseries U1(1,beta,measurelist[M]);
EnergyCorrelatorUseries U2(2,beta,measurelist[M]);
EnergyCorrelatorUseries U3(3,beta,measurelist[M]);
printf("%7.3f %20.10f %20.10f %20.10f \n",beta,U1(myJet),U2(myJet),U3(myJet));
}
cout << "-------------------------------------------------------------------------------------" << endl << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
cout << "EnergyCorrelatorU1: U1(beta) = ECFG(2, 1, beta) with " << modename[M] << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
printf("%7s %14s \n","beta", "U1 obs");
for (unsigned int B = 0; B < betalist.size(); B++) {
double beta = betalist[B];
EnergyCorrelatorU1 U1(beta,measurelist[M]);
printf("%7.3f %14.10f \n",beta,U1(myJet));
}
cout << "-------------------------------------------------------------------------------------" << endl << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
cout << "EnergyCorrelatorU2: U2(beta) = ECFG(3, 1, beta) with " << modename[M] << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
printf("%7s %14s \n","beta", "U2 obs");
for (unsigned int B = 0; B < betalist.size(); B++) {
double beta = betalist[B];
EnergyCorrelatorU2 U2(beta,measurelist[M]);
printf("%7.3f %14.10f \n",beta,U2(myJet));
}
cout << "-------------------------------------------------------------------------------------" << endl << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
- cout << "EnergyCorrelatorU3: U3(beta) = ECFN(4, 1, beta) with " << modename[M] << endl;
+ cout << "EnergyCorrelatorU3: U3(beta) = ECFG(4, 1, beta) with " << modename[M] << endl;
cout << "-------------------------------------------------------------------------------------" << endl;
printf("%7s %14s \n","beta", "U3 obs");
for (unsigned int B = 0; B < betalist.size(); B++) {
double beta = betalist[B];
EnergyCorrelatorU3 U3(beta,measurelist[M]);
printf("%7.3f %14.10f \n",beta,U3(myJet));
}
cout << "-------------------------------------------------------------------------------------" << endl << endl;
// timing tests for the developers
double do_timing_test = false;
if (do_timing_test) {
cout << "jet with pt = " << myJet.pt() << " and " << myJet.constituents().size() << " constituents" << endl;
clock_t clock_begin, clock_end;
double num_iter;
double beta = 0.5;
cout << setprecision(6);
// test C1
num_iter = 20000;
clock_begin = clock();
EnergyCorrelatorDoubleRatio C1s(1,beta,measurelist[M],EnergyCorrelator::slow);
EnergyCorrelatorDoubleRatio C1f(1,beta,measurelist[M],EnergyCorrelator::storage_array);
cout << "timing " << C1s.description() << endl;
cout << "timing " << C1f.description() << endl;
for (int t = 0; t < num_iter; t++) {
C1s(myJet);
}
clock_end = clock();
cout << "Slow method: " << (clock_end-clock_begin)/double(CLOCKS_PER_SEC*num_iter)*1000 << " ms per C1"<< endl;
num_iter = 20000;
clock_begin = clock();
for (int t = 0; t < num_iter; t++) {
C1f(myJet);
}
clock_end = clock();
cout << "Storage array method: " << (clock_end-clock_begin)/double(CLOCKS_PER_SEC*num_iter)*1000 << " ms per C1"<< endl;
// test C2
num_iter = 1000;
clock_begin = clock();
for (int t = 0; t < num_iter; t++) {
EnergyCorrelatorDoubleRatio C2(2,beta,measurelist[M],EnergyCorrelator::slow);
C2(myJet);
}
clock_end = clock();
cout << "Slow method: " << (clock_end-clock_begin)/double(CLOCKS_PER_SEC*num_iter)*1000 << " ms per C2"<< endl;
num_iter = 10000;
clock_begin = clock();
for (int t = 0; t < num_iter; t++) {
EnergyCorrelatorDoubleRatio C2(2,beta,measurelist[M],EnergyCorrelator::storage_array);
C2(myJet);
}
clock_end = clock();
cout << "Storage array method: " << (clock_end-clock_begin)/double(CLOCKS_PER_SEC*num_iter)*1000 << " ms per C2"<< endl;
// test C3
num_iter = 100;
clock_begin = clock();
for (int t = 0; t < num_iter; t++) {
EnergyCorrelatorDoubleRatio C3(3,beta,measurelist[M],EnergyCorrelator::slow);
C3(myJet);
}
clock_end = clock();
cout << "Slow method: " << (clock_end-clock_begin)/double(CLOCKS_PER_SEC*num_iter)*1000 << " ms per C3"<< endl;
num_iter = 3000;
clock_begin = clock();
for (int t = 0; t < num_iter; t++) {
EnergyCorrelatorDoubleRatio C3(3,beta,measurelist[M],EnergyCorrelator::storage_array);
C3(myJet);
}
clock_end = clock();
cout << "Storage array method: " << (clock_end-clock_begin)/double(CLOCKS_PER_SEC*num_iter)*1000 << " ms per C3"<< endl;
// test C4
num_iter = 10;
clock_begin = clock();
for (int t = 0; t < num_iter; t++) {
EnergyCorrelatorDoubleRatio C4(4,beta,measurelist[M],EnergyCorrelator::slow);
C4(myJet);
}
clock_end = clock();
cout << "Slow method: " << (clock_end-clock_begin)/double(CLOCKS_PER_SEC*num_iter)*1000 << " ms per C4"<< endl;
num_iter = 300;
clock_begin = clock();
for (int t = 0; t < num_iter; t++) {
EnergyCorrelatorDoubleRatio C4(4,beta,measurelist[M],EnergyCorrelator::storage_array);
C4(myJet);
}
clock_end = clock();
cout << "Storage array method: " << (clock_end-clock_begin)/double(CLOCKS_PER_SEC*num_iter)*1000 << " ms per C4"<< endl;
+ // test N2
+ num_iter = 10;
+ clock_begin = clock();
+
+ for (int t = 0; t < num_iter; t++) {
+ EnergyCorrelatorN2 N2(beta,measurelist[M],EnergyCorrelator::slow);
+ N2(myJet);
+ }
+ clock_end = clock();
+ cout << "Slow method: " << (clock_end-clock_begin)/double(CLOCKS_PER_SEC*num_iter)*1000 << " ms per N2"<< endl;
+
+ num_iter = 300;
+ clock_begin = clock();
+ for (int t = 0; t < num_iter; t++) {
+ EnergyCorrelatorN2 N2(beta,measurelist[M],EnergyCorrelator::storage_array);
+ N2(myJet);
+ }
+ clock_end = clock();
+ cout << "Storage array method: " << (clock_end-clock_begin)/double(CLOCKS_PER_SEC*num_iter)*1000 << " ms per N2"<< endl;
+
// test N3
num_iter = 10;
clock_begin = clock();
for (int t = 0; t < num_iter; t++) {
EnergyCorrelatorN3 N3(beta,measurelist[M],EnergyCorrelator::slow);
N3(myJet);
}
clock_end = clock();
cout << "Slow method: " << (clock_end-clock_begin)/double(CLOCKS_PER_SEC*num_iter)*1000 << " ms per N3"<< endl;
num_iter = 300;
clock_begin = clock();
for (int t = 0; t < num_iter; t++) {
EnergyCorrelatorN3 N3(beta,measurelist[M],EnergyCorrelator::storage_array);
N3(myJet);
}
clock_end = clock();
cout << "Storage array method: " << (clock_end-clock_begin)/double(CLOCKS_PER_SEC*num_iter)*1000 << " ms per N3"<< endl;
+ // test M2
+ num_iter = 10;
+ clock_begin = clock();
+
+ for (int t = 0; t < num_iter; t++) {
+ EnergyCorrelatorM2 M2(beta,measurelist[M],EnergyCorrelator::slow);
+ M2(myJet);
+ }
+ clock_end = clock();
+ cout << "Slow method: " << (clock_end-clock_begin)/double(CLOCKS_PER_SEC*num_iter)*1000 << " ms per M2"<< endl;
+
+ num_iter = 300;
+ clock_begin = clock();
+ for (int t = 0; t < num_iter; t++) {
+ EnergyCorrelatorM2 M2(beta,measurelist[M],EnergyCorrelator::storage_array);
+ M2(myJet);
+ }
+ clock_end = clock();
+ cout << "Storage array method: " << (clock_end-clock_begin)/double(CLOCKS_PER_SEC*num_iter)*1000 << " ms per M2"<< endl;
+
+ // test M3
+ num_iter = 10;
+ clock_begin = clock();
+
+ for (int t = 0; t < num_iter; t++) {
+ EnergyCorrelatorMseries M3(3,beta,measurelist[M],EnergyCorrelator::slow);
+ M3(myJet);
+ }
+ clock_end = clock();
+ cout << "Slow method: " << (clock_end-clock_begin)/double(CLOCKS_PER_SEC*num_iter)*1000 << " ms per M3"<< endl;
+
+ num_iter = 300;
+ clock_begin = clock();
+ for (int t = 0; t < num_iter; t++) {
+ EnergyCorrelatorMseries M3(3,beta,measurelist[M],EnergyCorrelator::storage_array);
+ M3(myJet);
+ }
+ clock_end = clock();
+ cout << "Storage array method: " << (clock_end-clock_begin)/double(CLOCKS_PER_SEC*num_iter)*1000 << " ms per M3"<< endl;
+
}
}
}
}
}
Index: contrib/contribs/EnergyCorrelator/trunk/example.ref
===================================================================
--- contrib/contribs/EnergyCorrelator/trunk/example.ref (revision 976)
+++ contrib/contribs/EnergyCorrelator/trunk/example.ref (revision 977)
@@ -1,922 +1,922 @@
# read an event with 354 particles
#--------------------------------------------------------------------------
# FastJet release 3.2.0
# M. Cacciari, G.P. Salam and G. Soyez
# A software package for jet finding and analysis at colliders
# http://fastjet.fr
#
# Please cite EPJC72(2012)1896 [arXiv:1111.6097] if you use this package
# for scientific work and optionally PLB641(2006)57 [hep-ph/0512210].
#
# FastJet is provided without warranty under the terms of the GNU GPLv2.
# It uses T. Chan's closest pair algorithm, S. Fortune's Voronoi code
# and 3rd party plugin jet algorithms. See COPYING file for details.
#--------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelator: ECF(N,beta) with pt_R
-------------------------------------------------------------------------------------
beta N=1 (GeV) N=2 (GeV^2) N=3 (GeV^3) N=4 (GeV^4) N=5 (GeV^5)
0.100 983.64 265690.56 27540663.76 1287213926.38 30113720909.66
0.200 983.64 172787.11 8222752.45 134175168.40 888560847.26
0.500 983.64 52039.98 364021.49 608244.06 356259.05
1.000 983.64 10006.49 9934.06 2670.10 271.98
1.500 983.64 3001.20 1066.15 118.17 4.24
2.000 983.64 1272.64 260.18 14.88 0.22
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorRatio: r_N^(beta) = ECF(N+1,beta)/ECF(N,beta) with pt_R
-------------------------------------------------------------------------------------
beta N=0 (GeV) N=1 (GeV) N=2 (GeV) N=3 (GeV) N=4 (GeV)
0.100 983.6369 270.1104 103.6569 46.7387 23.3945
0.200 983.6369 175.6615 47.5889 16.3175 6.6224
0.500 983.6369 52.9057 6.9950 1.6709 0.5857
1.000 983.6369 10.1730 0.9928 0.2688 0.1019
1.500 983.6369 3.0511 0.3552 0.1108 0.0359
2.000 983.6369 1.2938 0.2044 0.0572 0.0151
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorDoubleRatio: C_N^(beta) = r_N^(beta)/r_{N-1}^(beta) with pt_R
-------------------------------------------------------------------------------------
beta N=1 N=2 N=3 N=4
0.100 0.274604 0.383758 0.450898 0.500538
0.200 0.178584 0.270913 0.342885 0.405845
0.500 0.053786 0.132217 0.238870 0.350540
1.000 0.010342 0.097588 0.270742 0.378972
1.500 0.003102 0.116430 0.312016 0.323906
2.000 0.001315 0.158011 0.279675 0.263310
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorC1: C_1^(beta) = ECF(2,beta)/ECF(1,beta)^2 with pt_R
-------------------------------------------------------------------------------------
beta C1 obs
0.100 0.274604
0.200 0.178584
0.500 0.053786
1.000 0.010342
1.500 0.003102
2.000 0.001315
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorC2: C_2^(beta) = ECF(3,beta)*ECF(1,beta)/ECF(2,beta)^2 with pt_R
-------------------------------------------------------------------------------------
beta C2 obs
0.100 0.383758
0.200 0.270913
0.500 0.132217
1.000 0.097588
1.500 0.116430
2.000 0.158011
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorD2: D_2^(beta) = ECF(3,beta)*ECF(1,beta)^3/ECF(2,beta)^3 with pt_R
-------------------------------------------------------------------------------------
beta D2 obs
0.100 1.397496
0.200 1.517007
0.500 2.458216
1.000 9.435950
1.500 37.535182
2.000 120.129760
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorGeneralizedD2: D_2^(alpha, beta) = ECFN(3,alpha)/ECFN(2,beta)^(3*alpha/beta) with pt_R
-------------------------------------------------------------------------------------
beta alpha = 0.100 alpha = 0.200 alpha = 0.500 alpha = 1.000
0.200 0.3834 1.5170 156.2463 1741793.7615
0.500 0.1671 0.2882 2.4582 431.1389
1.000 0.1140 0.1342 0.3637 9.4359
1.500 0.0919 0.0871 0.1233 1.0849
2.000 0.0783 0.0632 0.0554 0.2188
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorGeneralized (angles = N Choose 2): ECFN(N, beta) with pt_R
-------------------------------------------------------------------------------------
beta N=1 N=2 N=3 N=4
0.100 1.00 0.2746037664 0.0289380967 0.0013750278
0.200 1.00 0.1785836568 0.0086399808 0.0001433286
0.500 1.00 0.0537857869 0.0003824922 0.0000006497
1.000 1.00 0.0103421840 0.0000104381 0.0000000029
1.500 1.00 0.0031018827 0.0000011202 0.0000000001
2.000 1.00 0.0013153375 0.0000002734 0.0000000000
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorGeneralized: ECFG(angles, N, beta=1) with pt_R
-------------------------------------------------------------------------------------
angles N=1 N=2 N=3 N=4
1 1.00 0.0103421840 0.0007353402 0.0000733472
2 0.0000460939 0.0000010704
3 0.0000104381 0.0000000552
4 0.0000000114
5 0.0000000045
6 0.0000000029
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorNseries: N_i(beta) = ECFG(i+1, 2, beta)/ECFG(i, 1, beta)^2 with pt_R
-------------------------------------------------------------------------------------
beta N=1 N=2 N=3
0.100 0.178584 0.551898 1.506618
0.200 0.078954 0.534774 1.521976
0.500 0.010342 0.487547 1.601014
1.000 0.001315 0.430942 1.979487
1.500 0.000437 0.391935 3.250084
2.000 0.000220 0.365859 6.700247
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorN2: N2(beta) = ECFG(3, 2, beta)/ECFG(2, 1, beta)^2 with pt_R
-------------------------------------------------------------------------------------
beta N2 obs
0.100 0.551898
0.200 0.534774
0.500 0.487547
1.000 0.430942
1.500 0.391935
2.000 0.365859
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorN3: N3(beta) = ECFG(4, 2, beta)/ECFG(3, 1, beta)^2 with pt_R
-------------------------------------------------------------------------------------
beta N3 obs
0.100 1.506618
0.200 1.521976
0.500 1.601014
1.000 1.979487
1.500 3.250084
2.000 6.700247
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorMseries: M_i(beta) = ECFG(i+1, 1, beta)/ECFN(i, 1, beta) with pt_R
-------------------------------------------------------------------------------------
beta N=1 N=2 N=3
0.100 0.274604 0.225158 0.151396
0.200 0.178584 0.206357 0.146715
0.500 0.053786 0.149827 0.130985
1.000 0.010342 0.071101 0.099746
1.500 0.003102 0.027603 0.065806
2.000 0.001315 0.010448 0.036511
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorM2: M2(beta) = ECFG(3, 1, beta)/ECFG(3, 1, beta) with pt_R
-------------------------------------------------------------------------------------
beta M2 obs
0.100 0.225158
0.200 0.206357
0.500 0.149827
1.000 0.071101
1.500 0.027603
2.000 0.010448
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorCseries: C_i(beta) = ECFN(i-1, beta)*ECFN(i+1, beta)/ECFN(i, beta)^2 with pt_R
-------------------------------------------------------------------------------------
beta N=1 N=2 N=3
0.100 0.2746037664 0.3837575950 0.4508977207
0.200 0.1785836568 0.2709126926 0.3428854490
0.500 0.0537857869 0.1322170711 0.2388696533
1.000 0.0103421840 0.0975883303 0.2707417692
1.500 0.0031018827 0.1164297328 0.3120164994
2.000 0.0013153375 0.1580111821 0.2796746959
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorUseries: U_i(beta) = ECFG(i+1, 1, beta) with pt_R
-------------------------------------------------------------------------------------
beta N=1 N=2 N=3
0.100 0.2746037664 0.0618292258 0.0093606928
0.200 0.1785836568 0.0368519186 0.0054067344
0.500 0.0537857869 0.0080585540 0.0010555469
1.000 0.0103421840 0.0007353402 0.0000733472
1.500 0.0031018827 0.0000856204 0.0000056343
2.000 0.0013153375 0.0000137425 0.0000005017
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorU1: U1(beta) = ECFG(2, 1, beta) with pt_R
-------------------------------------------------------------------------------------
beta U1 obs
0.100 0.2746037664
0.200 0.1785836568
0.500 0.0537857869
1.000 0.0103421840
1.500 0.0031018827
2.000 0.0013153375
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorU2: U2(beta) = ECFG(3, 1, beta) with pt_R
-------------------------------------------------------------------------------------
beta U2 obs
0.100 0.0618292258
0.200 0.0368519186
0.500 0.0080585540
1.000 0.0007353402
1.500 0.0000856204
2.000 0.0000137425
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
-EnergyCorrelatorU3: U3(beta) = ECFN(4, 1, beta) with pt_R
+EnergyCorrelatorU3: U3(beta) = ECFG(4, 1, beta) with pt_R
-------------------------------------------------------------------------------------
beta U3 obs
0.100 0.0093606928
0.200 0.0054067344
0.500 0.0010555469
1.000 0.0000733472
1.500 0.0000056343
2.000 0.0000005017
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelator: ECF(N,beta) with E_theta
-------------------------------------------------------------------------------------
beta N=1 (GeV) N=2 (GeV^2) N=3 (GeV^3) N=4 (GeV^4) N=5 (GeV^5)
0.100 1378.16 504056.94 68362746.10 4040636656.75 115642116882.67
0.200 1378.16 316828.68 18441161.70 345185274.86 2475861856.72
0.500 1378.16 86243.22 614652.00 941844.70 459093.24
1.000 1378.16 14186.79 11682.63 2060.77 92.98
1.500 1378.16 3751.90 907.11 39.34 0.27
2.000 1378.16 1439.57 152.71 1.84 0.00
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorRatio: r_N^(beta) = ECF(N+1,beta)/ECF(N,beta) with E_theta
-------------------------------------------------------------------------------------
beta N=0 (GeV) N=1 (GeV) N=2 (GeV) N=3 (GeV) N=4 (GeV)
0.100 1378.1622 365.7457 135.6250 59.1058 28.6198
0.200 1378.1622 229.8922 58.2055 18.7182 7.1726
0.500 1378.1622 62.5784 7.1270 1.5323 0.4874
1.000 1378.1622 10.2940 0.8235 0.1764 0.0451
1.500 1378.1622 2.7224 0.2418 0.0434 0.0069
2.000 1378.1622 1.0446 0.1061 0.0121 0.0013
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorDoubleRatio: C_N^(beta) = r_N^(beta)/r_{N-1}^(beta) with E_theta
-------------------------------------------------------------------------------------
beta N=1 N=2 N=3 N=4
0.100 0.265387 0.370818 0.435803 0.484212
0.200 0.166811 0.253186 0.321588 0.383186
0.500 0.045407 0.113888 0.215004 0.318106
1.000 0.007469 0.079997 0.214207 0.255786
1.500 0.001975 0.088810 0.179360 0.160180
2.000 0.000758 0.101555 0.113867 0.106401
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorC1: C_1^(beta) = ECF(2,beta)/ECF(1,beta)^2 with E_theta
-------------------------------------------------------------------------------------
beta C1 obs
0.100 0.265387
0.200 0.166811
0.500 0.045407
1.000 0.007469
1.500 0.001975
2.000 0.000758
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorC2: C_2^(beta) = ECF(3,beta)*ECF(1,beta)/ECF(2,beta)^2 with E_theta
-------------------------------------------------------------------------------------
beta C2 obs
0.100 0.370818
0.200 0.253186
0.500 0.113888
1.000 0.079997
1.500 0.088810
2.000 0.101555
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorD2: D_2^(beta) = ECF(3,beta)*ECF(1,beta)^3/ECF(2,beta)^3 with E_theta
-------------------------------------------------------------------------------------
beta D2 obs
0.100 1.397274
0.200 1.517804
0.500 2.508161
1.000 10.709981
1.500 44.958245
2.000 133.988418
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorGeneralizedD2: D_2^(alpha, beta) = ECFN(3,alpha)/ECFN(2,beta)^(3*alpha/beta) with E_theta
-------------------------------------------------------------------------------------
beta alpha = 0.100 alpha = 0.200 alpha = 0.500 alpha = 1.000
0.200 0.3833 1.5178 159.9740 2071485.6064
0.500 0.1670 0.2880 2.5082 509.2064
1.000 0.1135 0.1330 0.3637 10.7100
1.500 0.0907 0.0850 0.1189 1.1438
2.000 0.0767 0.0608 0.0514 0.2139
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorGeneralized (angles = N Choose 2): ECFN(N, beta) with E_theta
-------------------------------------------------------------------------------------
beta N=1 N=2 N=3 N=4
0.100 1.00 0.2653865755 0.0261167137 0.0011200786
0.200 1.00 0.1668106769 0.0070451023 0.0000956866
0.500 1.00 0.0454071552 0.0002348163 0.0000002611
1.000 1.00 0.0074693640 0.0000044631 0.0000000006
1.500 1.00 0.0019753776 0.0000003465 0.0000000000
2.000 1.00 0.0007579352 0.0000000583 0.0000000000
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorGeneralized: ECFG(angles, N, beta=1) with E_theta
-------------------------------------------------------------------------------------
angles N=1 N=2 N=3 N=4
1 1.00 0.0074693640 0.0005219446 0.0000521319
2 0.0000242551 0.0000005388
3 0.0000044631 0.0000000205
4 0.0000000035
5 0.0000000011
6 0.0000000006
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorNseries: N_i(beta) = ECFG(i+1, 2, beta)/ECFG(i, 1, beta)^2 with E_theta
-------------------------------------------------------------------------------------
beta N=1 N=2 N=3
0.100 0.166811 0.551800 1.506192
0.200 0.068920 0.534652 1.521253
0.500 0.007469 0.487710 1.598907
1.000 0.000758 0.434746 1.977674
1.500 0.000207 0.401351 3.333270
2.000 0.000082 0.372570 7.518334
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorN2: N2(beta) = ECFG(3, 2, beta)/ECFG(2, 1, beta)^2 with E_theta
-------------------------------------------------------------------------------------
beta N2 obs
0.100 0.551800
0.200 0.534652
0.500 0.487710
1.000 0.434746
1.500 0.401351
2.000 0.372570
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorN3: N3(beta) = ECFG(4, 2, beta)/ECFG(3, 1, beta)^2 with E_theta
-------------------------------------------------------------------------------------
beta N3 obs
0.100 1.506192
0.200 1.521253
0.500 1.598907
1.000 1.977674
1.500 3.333270
2.000 7.518334
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorMseries: M_i(beta) = ECFG(i+1, 1, beta)/ECFN(i, 1, beta) with E_theta
-------------------------------------------------------------------------------------
beta N=1 N=2 N=3
0.100 0.265387 0.225134 0.151350
0.200 0.166811 0.206335 0.146685
0.500 0.045407 0.149607 0.131015
1.000 0.007469 0.069878 0.099880
1.500 0.001975 0.025930 0.065823
2.000 0.000758 0.009248 0.036027
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorM2: M2(beta) = ECFG(3, 1, beta)/ECFG(3, 1, beta) with E_theta
-------------------------------------------------------------------------------------
beta M2 obs
0.100 0.225134
0.200 0.206335
0.500 0.149607
1.000 0.069878
1.500 0.025930
2.000 0.009248
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorCseries: C_i(beta) = ECFN(i-1, beta)*ECFN(i+1, beta)/ECFN(i, beta)^2 with E_theta
-------------------------------------------------------------------------------------
beta N=1 N=2 N=3
0.100 0.2653865755 0.3708178471 0.4358031826
0.200 0.1668106769 0.2531859580 0.3215882713
0.500 0.0454071552 0.1138884647 0.2150035566
1.000 0.0074693640 0.0799967491 0.2142068062
1.500 0.0019753776 0.0888095113 0.1793603915
2.000 0.0007579352 0.1015545382 0.1138668084
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorUseries: U_i(beta) = ECFG(i+1, 1, beta) with E_theta
-------------------------------------------------------------------------------------
beta N=1 N=2 N=3
0.100 0.2653865755 0.0597476192 0.0090428096
0.200 0.1668106769 0.0344188111 0.0050487063
0.500 0.0454071552 0.0067932369 0.0008900155
1.000 0.0074693640 0.0005219446 0.0000521319
1.500 0.0019753776 0.0000512213 0.0000033715
2.000 0.0007579352 0.0000070092 0.0000002525
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorU1: U1(beta) = ECFG(2, 1, beta) with E_theta
-------------------------------------------------------------------------------------
beta U1 obs
0.100 0.2653865755
0.200 0.1668106769
0.500 0.0454071552
1.000 0.0074693640
1.500 0.0019753776
2.000 0.0007579352
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorU2: U2(beta) = ECFG(3, 1, beta) with E_theta
-------------------------------------------------------------------------------------
beta U2 obs
0.100 0.0597476192
0.200 0.0344188111
0.500 0.0067932369
1.000 0.0005219446
1.500 0.0000512213
2.000 0.0000070092
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
-EnergyCorrelatorU3: U3(beta) = ECFN(4, 1, beta) with E_theta
+EnergyCorrelatorU3: U3(beta) = ECFG(4, 1, beta) with E_theta
-------------------------------------------------------------------------------------
beta U3 obs
0.100 0.0090428096
0.200 0.0050487063
0.500 0.0008900155
1.000 0.0000521319
1.500 0.0000033715
2.000 0.0000002525
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelator: ECF(N,beta) with pt_R
-------------------------------------------------------------------------------------
beta N=1 (GeV) N=2 (GeV^2) N=3 (GeV^3) N=4 (GeV^4) N=5 (GeV^5)
0.100 910.03 163661.63 10858223.95 340994615.02 5907941830.38
0.200 910.03 111307.49 3950123.18 59638399.31 478368362.42
0.500 910.03 40470.38 446453.20 2147680.90 5564873.72
1.000 910.03 13863.90 65435.19 142222.94 166409.02
1.500 910.03 8417.59 26548.97 39560.12 31484.21
2.000 910.03 6328.24 16871.11 21081.97 13743.58
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorRatio: r_N^(beta) = ECF(N+1,beta)/ECF(N,beta) with pt_R
-------------------------------------------------------------------------------------
beta N=0 (GeV) N=1 (GeV) N=2 (GeV) N=3 (GeV) N=4 (GeV)
0.100 910.0320 179.8416 66.3456 31.4043 17.3256
0.200 910.0320 122.3116 35.4884 15.0979 8.0211
0.500 910.0320 44.4714 11.0316 4.8105 2.5911
1.000 910.0320 15.2345 4.7198 2.1735 1.1701
1.500 910.0320 9.2498 3.1540 1.4901 0.7959
2.000 910.0320 6.9539 2.6660 1.2496 0.6519
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorDoubleRatio: C_N^(beta) = r_N^(beta)/r_{N-1}^(beta) with pt_R
-------------------------------------------------------------------------------------
beta N=1 N=2 N=3 N=4
0.100 0.197621 0.368911 0.473344 0.551696
0.200 0.134404 0.290147 0.425431 0.531277
0.500 0.048868 0.248061 0.436069 0.538632
1.000 0.016741 0.309811 0.460503 0.538330
1.500 0.010164 0.340980 0.472444 0.534103
2.000 0.007641 0.383385 0.468712 0.521701
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorC1: C_1^(beta) = ECF(2,beta)/ECF(1,beta)^2 with pt_R
-------------------------------------------------------------------------------------
beta C1 obs
0.100 0.197621
0.200 0.134404
0.500 0.048868
1.000 0.016741
1.500 0.010164
2.000 0.007641
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorC2: C_2^(beta) = ECF(3,beta)*ECF(1,beta)/ECF(2,beta)^2 with pt_R
-------------------------------------------------------------------------------------
beta C2 obs
0.100 0.368911
0.200 0.290147
0.500 0.248061
1.000 0.309811
1.500 0.340980
2.000 0.383385
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorD2: D_2^(beta) = ECF(3,beta)*ECF(1,beta)^3/ECF(2,beta)^3 with pt_R
-------------------------------------------------------------------------------------
beta D2 obs
0.100 1.866758
0.200 2.158775
0.500 5.076145
1.000 18.506536
1.500 33.547049
2.000 50.172493
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorGeneralizedD2: D_2^(alpha, beta) = ECFN(3,alpha)/ECFN(2,beta)^(3*alpha/beta) with pt_R
-------------------------------------------------------------------------------------
beta alpha = 0.100 alpha = 0.200 alpha = 0.500 alpha = 1.000
0.200 0.2924 2.1588 2039.4962 1029141861.7962
0.500 0.0881 0.1962 5.0761 6375.2544
1.000 0.0491 0.0610 0.2735 18.5065
1.500 0.0361 0.0329 0.0583 0.8404
2.000 0.0299 0.0226 0.0229 0.1300
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorGeneralized (angles = N Choose 2): ECFN(N, beta) with pt_R
-------------------------------------------------------------------------------------
beta N=1 N=2 N=3 N=4
0.100 1.00 0.1976212201 0.0144075072 0.0004971883
0.200 1.00 0.1344036550 0.0052413202 0.0000869560
0.500 1.00 0.0488679347 0.0005923876 0.0000031314
1.000 1.00 0.0167406417 0.0000868243 0.0000002074
1.500 1.00 0.0101642297 0.0000352272 0.0000000577
2.000 1.00 0.0076413374 0.0000223859 0.0000000307
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorGeneralized: ECFG(angles, N, beta=1) with pt_R
-------------------------------------------------------------------------------------
angles N=1 N=2 N=3 N=4
1 1.00 0.0167406417 0.0005149099 0.0000275956
2 0.0001201519 0.0000010521
3 0.0000868243 0.0000003239
4 0.0000002207
5 0.0000001864
6 0.0000002074
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorNseries: N_i(beta) = ECFG(i+1, 2, beta)/ECFG(i, 1, beta)^2 with pt_R
-------------------------------------------------------------------------------------
beta N=1 N=2 N=3
0.100 0.134404 0.501515 2.093230
0.200 0.066590 0.490962 2.107355
0.500 0.016741 0.472128 2.270271
1.000 0.007641 0.428733 3.968204
1.500 0.005197 0.367850 11.456776
2.000 0.003938 0.329248 20.513687
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorN2: N2(beta) = ECFG(3, 2, beta)/ECFG(2, 1, beta)^2 with pt_R
-------------------------------------------------------------------------------------
beta N2 obs
0.100 0.501515
0.200 0.490962
0.500 0.472128
1.000 0.428733
1.500 0.367850
2.000 0.329248
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorN3: N3(beta) = ECFG(4, 2, beta)/ECFG(3, 1, beta)^2 with pt_R
-------------------------------------------------------------------------------------
beta N3 obs
0.100 2.093230
0.200 2.107355
0.500 2.270271
1.000 3.968204
1.500 11.456776
2.000 20.513687
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorMseries: M_i(beta) = ECFG(i+1, 1, beta)/ECFN(i, 1, beta) with pt_R
-------------------------------------------------------------------------------------
beta N=1 N=2 N=3
0.100 0.197621 0.140440 0.090587
0.200 0.134404 0.127907 0.086996
0.500 0.048868 0.087042 0.076041
1.000 0.016741 0.030758 0.053593
1.500 0.010164 0.010637 0.025871
2.000 0.007641 0.005839 0.009492
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorM2: M2(beta) = ECFG(3, 1, beta)/ECFG(3, 1, beta) with pt_R
-------------------------------------------------------------------------------------
beta M2 obs
0.100 0.140440
0.200 0.127907
0.500 0.087042
1.000 0.030758
1.500 0.010637
2.000 0.005839
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorCseries: C_i(beta) = ECFN(i-1, beta)*ECFN(i+1, beta)/ECFN(i, beta)^2 with pt_R
-------------------------------------------------------------------------------------
beta N=1 N=2 N=3
0.100 0.1976212201 0.3689110739 0.4733439247
0.200 0.1344036550 0.2901472976 0.4254309496
0.500 0.0488679347 0.2480607340 0.4360689366
1.000 0.0167406417 0.3098112813 0.4605028221
1.500 0.0101642297 0.3409799143 0.4724436009
2.000 0.0076413374 0.3833849510 0.4687122507
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorUseries: U_i(beta) = ECFG(i+1, 1, beta) with pt_R
-------------------------------------------------------------------------------------
beta N=1 N=2 N=3
0.100 0.1976212201 0.0277540195 0.0025141656
0.200 0.1344036550 0.0171911179 0.0014955586
0.500 0.0488679347 0.0042535497 0.0003234433
1.000 0.0167406417 0.0005149099 0.0000275956
1.500 0.0101642297 0.0001081211 0.0000027972
2.000 0.0076413374 0.0000446167 0.0000004235
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorU1: U1(beta) = ECFG(2, 1, beta) with pt_R
-------------------------------------------------------------------------------------
beta U1 obs
0.100 0.1976212201
0.200 0.1344036550
0.500 0.0488679347
1.000 0.0167406417
1.500 0.0101642297
2.000 0.0076413374
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorU2: U2(beta) = ECFG(3, 1, beta) with pt_R
-------------------------------------------------------------------------------------
beta U2 obs
0.100 0.0277540195
0.200 0.0171911179
0.500 0.0042535497
1.000 0.0005149099
1.500 0.0001081211
2.000 0.0000446167
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
-EnergyCorrelatorU3: U3(beta) = ECFN(4, 1, beta) with pt_R
+EnergyCorrelatorU3: U3(beta) = ECFG(4, 1, beta) with pt_R
-------------------------------------------------------------------------------------
beta U3 obs
0.100 0.0025141656
0.200 0.0014955586
0.500 0.0003234433
1.000 0.0000275956
1.500 0.0000027972
2.000 0.0000004235
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelator: ECF(N,beta) with E_theta
-------------------------------------------------------------------------------------
beta N=1 (GeV) N=2 (GeV^2) N=3 (GeV^3) N=4 (GeV^4) N=5 (GeV^5)
0.100 934.39 173035.93 11869881.64 387687952.45 7030672399.84
0.200 934.39 117791.85 4351824.23 69148951.24 587495287.84
0.500 934.39 43220.34 507378.92 2589996.65 7002091.93
1.000 934.39 15182.02 75656.66 165115.95 178354.07
1.500 934.39 9296.03 30143.02 40417.01 24563.71
2.000 934.39 6943.30 18259.83 17679.34 7116.38
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorRatio: r_N^(beta) = ECF(N+1,beta)/ECF(N,beta) with E_theta
-------------------------------------------------------------------------------------
beta N=0 (GeV) N=1 (GeV) N=2 (GeV) N=3 (GeV) N=4 (GeV)
0.100 934.3868 185.1866 68.5978 32.6615 18.1349
0.200 934.3868 126.0633 36.9450 15.8896 8.4961
0.500 934.3868 46.2553 11.7394 5.1047 2.7035
1.000 934.3868 16.2481 4.9833 2.1824 1.0802
1.500 934.3868 9.9488 3.2426 1.3408 0.6078
2.000 934.3868 7.4309 2.6299 0.9682 0.4025
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorDoubleRatio: C_N^(beta) = r_N^(beta)/r_{N-1}^(beta) with E_theta
-------------------------------------------------------------------------------------
beta N=1 N=2 N=3 N=4
0.100 0.198191 0.370425 0.476130 0.555237
0.200 0.134916 0.293067 0.430089 0.534693
0.500 0.049503 0.253795 0.434833 0.529617
1.000 0.017389 0.306701 0.437950 0.494940
1.500 0.010647 0.325926 0.413512 0.453265
2.000 0.007953 0.353909 0.368161 0.415742
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorC1: C_1^(beta) = ECF(2,beta)/ECF(1,beta)^2 with E_theta
-------------------------------------------------------------------------------------
beta C1 obs
0.100 0.198191
0.200 0.134916
0.500 0.049503
1.000 0.017389
1.500 0.010647
2.000 0.007953
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorC2: C_2^(beta) = ECF(3,beta)*ECF(1,beta)/ECF(2,beta)^2 with E_theta
-------------------------------------------------------------------------------------
beta C2 obs
0.100 0.370425
0.200 0.293067
0.500 0.253795
1.000 0.306701
1.500 0.325926
2.000 0.353909
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorD2: D_2^(beta) = ECF(3,beta)*ECF(1,beta)^3/ECF(2,beta)^3 with E_theta
-------------------------------------------------------------------------------------
beta D2 obs
0.100 1.869035
0.200 2.172229
0.500 5.126818
1.000 17.637552
1.500 30.610782
2.000 44.502015
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorGeneralizedD2: D_2^(alpha, beta) = ECFN(3,alpha)/ECFN(2,beta)^(3*alpha/beta) with E_theta
-------------------------------------------------------------------------------------
beta alpha = 0.100 alpha = 0.200 alpha = 0.500 alpha = 1.000
0.200 0.2936 2.1722 2081.0777 1038338617.9694
0.500 0.0883 0.1966 5.1268 6301.7080
1.000 0.0491 0.0607 0.2712 17.6376
1.500 0.0361 0.0328 0.0584 0.8180
2.000 0.0300 0.0227 0.0234 0.1308
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorGeneralized (angles = N Choose 2): ECFN(N, beta) with E_theta
-------------------------------------------------------------------------------------
beta N=1 N=2 N=3 N=4
0.100 1.00 0.1981905437 0.0145501117 0.0005085991
0.200 1.00 0.1349155085 0.0053344701 0.0000907149
0.500 1.00 0.0495033749 0.0006219455 0.0000033978
1.000 1.00 0.0173890665 0.0000927400 0.0000002166
1.500 1.00 0.0106474132 0.0000369493 0.0000000530
2.000 1.00 0.0079526591 0.0000223829 0.0000000232
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorGeneralized: ECFG(angles, N, beta=1) with E_theta
-------------------------------------------------------------------------------------
angles N=1 N=2 N=3 N=4
1 1.00 0.0173890665 0.0005243822 0.0000276026
2 0.0001290539 0.0000011436
3 0.0000927400 0.0000003720
4 0.0000002479
5 0.0000002021
6 0.0000002166
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorNseries: N_i(beta) = ECFG(i+1, 2, beta)/ECFG(i, 1, beta)^2 with E_theta
-------------------------------------------------------------------------------------
beta N=1 N=2 N=3
0.100 0.134916 0.502292 2.091587
0.200 0.067180 0.491827 2.107891
0.500 0.017389 0.472830 2.289141
1.000 0.007953 0.426794 4.159019
1.500 0.005251 0.366194 11.630367
2.000 0.003828 0.328039 19.240170
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorN2: N2(beta) = ECFG(3, 2, beta)/ECFG(2, 1, beta)^2 with E_theta
-------------------------------------------------------------------------------------
beta N2 obs
0.100 0.502292
0.200 0.491827
0.500 0.472830
1.000 0.426794
1.500 0.366194
2.000 0.328039
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorN3: N3(beta) = ECFG(4, 2, beta)/ECFG(3, 1, beta)^2 with E_theta
-------------------------------------------------------------------------------------
beta N3 obs
0.100 2.091587
0.200 2.107891
0.500 2.289141
1.000 4.159019
1.500 11.630367
2.000 19.240170
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorMseries: M_i(beta) = ECFG(i+1, 1, beta)/ECFN(i, 1, beta) with E_theta
-------------------------------------------------------------------------------------
beta N=1 N=2 N=3
0.100 0.198191 0.140807 0.091081
0.200 0.134916 0.127947 0.087436
0.500 0.049503 0.086121 0.076197
1.000 0.017389 0.030156 0.052638
1.500 0.010647 0.010921 0.024416
2.000 0.007953 0.006325 0.009110
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorM2: M2(beta) = ECFG(3, 1, beta)/ECFG(3, 1, beta) with E_theta
-------------------------------------------------------------------------------------
beta M2 obs
0.100 0.140807
0.200 0.127947
0.500 0.086121
1.000 0.030156
1.500 0.010921
2.000 0.006325
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorCseries: C_i(beta) = ECFN(i-1, beta)*ECFN(i+1, beta)/ECFN(i, beta)^2 with E_theta
-------------------------------------------------------------------------------------
beta N=1 N=2 N=3
0.100 0.1981905437 0.3704251544 0.4761303115
0.200 0.1349155085 0.2930674174 0.4300888197
0.500 0.0495033749 0.2537948134 0.4348330516
1.000 0.0173890665 0.3067005727 0.4379497669
1.500 0.0106474132 0.3259256469 0.4135119649
2.000 0.0079526591 0.3539093501 0.3681613681
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorUseries: U_i(beta) = ECFG(i+1, 1, beta) with E_theta
-------------------------------------------------------------------------------------
beta N=1 N=2 N=3
0.100 0.1981905437 0.0279066279 0.0025417550
0.200 0.1349155085 0.0172619856 0.0015093221
0.500 0.0495033749 0.0042632685 0.0003248489
1.000 0.0173890665 0.0005243822 0.0000276026
1.500 0.0106474132 0.0001162849 0.0000028392
2.000 0.0079526591 0.0000503042 0.0000004582
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorU1: U1(beta) = ECFG(2, 1, beta) with E_theta
-------------------------------------------------------------------------------------
beta U1 obs
0.100 0.1981905437
0.200 0.1349155085
0.500 0.0495033749
1.000 0.0173890665
1.500 0.0106474132
2.000 0.0079526591
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
EnergyCorrelatorU2: U2(beta) = ECFG(3, 1, beta) with E_theta
-------------------------------------------------------------------------------------
beta U2 obs
0.100 0.0279066279
0.200 0.0172619856
0.500 0.0042632685
1.000 0.0005243822
1.500 0.0001162849
2.000 0.0000503042
-------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------
-EnergyCorrelatorU3: U3(beta) = ECFN(4, 1, beta) with E_theta
+EnergyCorrelatorU3: U3(beta) = ECFG(4, 1, beta) with E_theta
-------------------------------------------------------------------------------------
beta U3 obs
0.100 0.0025417550
0.200 0.0015093221
0.500 0.0003248489
1.000 0.0000276026
1.500 0.0000028392
2.000 0.0000004582
-------------------------------------------------------------------------------------

File Metadata

Mime Type
text/x-diff
Expires
Wed, May 14, 11:09 AM (17 h, 53 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
5111357
Default Alt Text
(142 KB)

Event Timeline