/usr/include/Rivet/Projections/Spherocity.hh is in librivet-dev 1.8.3-2build1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 | // -*- C++ -*-
#ifndef RIVET_Spherocity_HH
#define RIVET_Spherocity_HH
#include "Rivet/Projection.hh"
#include "Rivet/Projections/AxesDefinition.hh"
#include "Rivet/Projections/FinalState.hh"
#include "Rivet/Event.hh"
namespace Rivet {
/**
@brief Get the transverse spherocity scalars for hadron-colliders.
@author Holger Schulz
The scalar (maximum) transverse spherocity is defined as
\f[
T = \mathrm{max}_{\vec{n_\perp}} \frac{\sum_i \left|\vec{p}_{\perp,i} \cdot \vec{n} \right|}{\sum_i |\vec{p}_{\perp,i}|}
\f],
with the direction of the unit vector \f$ \vec{n_\perp} \f$ which maximises \f$ T \f$
being identified as the spherocity axis. The unit vector which maximises the spherocity
scalar in the plane perpendicular to \f$ \vec{n} \f$ is the "spherocity major"
direction, and the vector perpendicular to both the spherocity and spherocity major directions
is the spherocity minor. Both the major and minor directions have associated spherocity
scalars.
Care must be taken in the case of Drell-Yan processes - there we should use the
newly proposed observable \f$ a_T \f$.
*/
class Spherocity : public AxesDefinition {
public:
// Default Constructor
Spherocity() {}
/// Constructor.
Spherocity(const FinalState& fsp)
: _calculatedSpherocity(false)
{
setName("Spherocity");
addProjection(fsp, "FS");
}
/// Clone on the heap.
virtual const Projection* clone() const {
return new Spherocity(*this);
}
protected:
/// Perform the projection on the Event
void project(const Event& e) {
const vector<Particle> ps
= applyProjection<FinalState>(e, "FS").particles();
calc(ps);
}
/// Compare projections
int compare(const Projection& p) const {
return mkNamedPCmp(p, "FS");
}
public:
///@{ Spherocity scalar accessors
/// The spherocity scalar, \f$ S \f$, (minimum spherocity).
double spherocity() const { return _spherocities[0]; }
///@}
///@{ Spherocity axis accessors
/// The spherocity axis.
const Vector3& spherocityAxis() const { return _spherocityAxes[0]; }
/// The spherocity major axis (axis of max spherocity perpendicular to spherocity axis).
const Vector3& spherocityMajorAxis() const { return _spherocityAxes[1]; }
/// The spherocity minor axis (axis perpendicular to spherocity and spherocity major).
const Vector3& spherocityMinorAxis() const { return _spherocityAxes[2]; }
///@}
///@{ AxesDefinition axis accessors.
const Vector3& axis1() const { return spherocityAxis(); }
const Vector3& axis2() const { return spherocityMajorAxis(); }
const Vector3& axis3() const { return spherocityMinorAxis(); }
///@}
public:
/// @name Direct methods
/// Ways to do the calculation directly, without engaging the caching system
//@{
/// Manually calculate the spherocity, without engaging the caching system
void calc(const FinalState& fs);
/// Manually calculate the spherocity, without engaging the caching system
void calc(const vector<Particle>& fsparticles);
/// Manually calculate the spherocity, without engaging the caching system
void calc(const vector<FourMomentum>& fsmomenta);
/// Manually calculate the spherocity, without engaging the caching system
void calc(const vector<Vector3>& threeMomenta);
//@}
private:
/// The spherocity scalars.
vector<double> _spherocities;
/// The spherocity axes.
vector<Vector3> _spherocityAxes;
/// Caching flag to avoid costly recalculations.
bool _calculatedSpherocity;
private:
/// Explicitly calculate the spherocity values.
void _calcSpherocity(const vector<Vector3>& fsmomenta);
};
}
#endif
|