Rivet/Projections/Spherocity.hh

0001 // -*- C++ -*-
0002 #ifndef RIVET_Spherocity_HH
0003 #define RIVET_Spherocity_HH
0004
0005 #include "Rivet/Projection.hh"
0006 #include "Rivet/Projections/AxesDefinition.hh"
0007 #include "Rivet/Projections/FinalState.hh"
0008 #include "Rivet/Event.hh"
0009
0010 namespace Rivet {
0011
0012
0013   /// @brief Get the transverse spherocity scalars for hadron-colliders.
0014   ///
0015   /// @author Holger Schulz
0016   ///
0017   /// The scalar (minimum) transverse spherocity is defined as
0018   /// \f[
0019   /// S = \frac{\pi^2}{4} \mathrm{min}_{\vec{n}_\perp} \left( \frac{\sum_i \left|\vec{p}_{\perp,i} \times \vec{n}_\perp \right|}{\sum_i |\vec{p}_{\perp,i}|} \right)^2
0020   /// \f],
0021   /// with the direction of the unit vector \f$ \vec{n_\perp} \f$ which minimises \f$ T \f$
0022   /// being identified as the spherocity axis. The unit vector which maximises the spherocity
0023   /// scalar in the plane perpendicular to \f$ \vec{n} \f$ is the "spherocity major"
0024   /// direction, and the vector perpendicular to both the spherocity and spherocity major directions
0025   /// is the spherocity minor. Both the major and minor directions have associated spherocity
0026   /// scalars.
0027   ///
0028   /// Care must be taken in the case of Drell-Yan processes - there we should use the
0029   /// newly proposed observable \f$ a_T \f$.
0030   class Spherocity : public AxesDefinition {
0031   public:
0032
0033     using AxesDefinition::operator=;
0034
0035     // Default Constructor
0036     Spherocity() {}
0037
0038     /// Constructor.
0039     Spherocity(const FinalState& fsp) {
0040       setName("Spherocity");
0041       declare(fsp, "FS");
0042     }
0043
0044     /// Clone on the heap.
0045     RIVET_DEFAULT_PROJ_CLONE(Spherocity);
0046
0047     /// Import to avoid warnings about overload-hiding
0048     using Projection::operator =;
0049
0050
0051   protected:
0052
0053     /// Perform the projection on the Event
0054     void project(const Event& e) {
0055       const vector<Particle> ps = apply<FinalState>(e, "FS").particles();
0056       calc(ps);
0057     }
0058
0059
0060     /// Compare projections
0061     CmpState compare(const Projection& p) const {
0062       return mkNamedPCmp(p, "FS");
0063     }
0064
0065
0066   public:
0067
0068     /// @name Spherocity scalar accessors
0069     /// @{
0070     /// The spherocity scalar, \f$ S \f$, (minimum spherocity).
0071     double spherocity() const { return _spherocities[0]; }
0072     /// @}
0073
0074
0075     /// @name Spherocity axis accessors
0076     /// @{
0077     /// The spherocity axis.
0078     const Vector3& spherocityAxis() const { return _spherocityAxes[0]; }
0079     /// The spherocity major axis (axis of max spherocity perpendicular to spherocity axis).
0080     const Vector3& spherocityMajorAxis() const { return _spherocityAxes[1]; }
0081     /// The spherocity minor axis (axis perpendicular to spherocity and spherocity major).
0082     const Vector3& spherocityMinorAxis() const { return _spherocityAxes[2]; }
0083     /// @}
0084
0085
0086     /// @name AxesDefinition axis accessors.
0087     /// @{
0088     const Vector3& axis1() const { return spherocityAxis(); }
0089     const Vector3& axis2() const { return spherocityMajorAxis(); }
0090     const Vector3& axis3() const { return spherocityMinorAxis(); }
0091     /// @}
0092
0093
0094   public:
0095
0096     /// @name Direct methods
0097     /// Ways to do the calculation directly, without engaging the caching system
0098     /// @{
0099
0100     /// Manually calculate the spherocity, without engaging the caching system
0101     void calc(const FinalState& fs);
0102
0103     /// Manually calculate the spherocity, without engaging the caching system
0104     void calc(const vector<Particle>& fsparticles);
0105
0106     /// Manually calculate the spherocity, without engaging the caching system
0107     void calc(const vector<FourMomentum>& fsmomenta);
0108
0109     /// Manually calculate the spherocity, without engaging the caching system
0110     void calc(const vector<Vector3>& threeMomenta);
0111
0112     /// @}
0113
0114
0115   protected:
0116
0117     /// The spherocity scalars.
0118     vector<double> _spherocities;
0119
0120     /// The spherocity axes.
0121     vector<Vector3> _spherocityAxes;
0122
0123
0124   protected:
0125
0126     /// Explicitly calculate the spherocity values.
0127     void _calcSpherocity(const vector<Vector3>& fsmomenta);
0128
0129   };
0130
0131 }
0132
0133 #endif