// -*- C++ -*-
#ifndef RIVET_InvariantJetMass_HH
#define RIVET_InvariantJetMass_HH

#include "Rivet/Particle.hh"

#include "Rivet/Projection.hh"
#include "Rivet/Projections/AxesDefinition.hh"
#include "Rivet/Projections/FinalState.hh"
#include "Rivet/Event.hh"

namespace Rivet {
  
  //Projection to find the invariantjetmass for a given event.
  
  class InvariantJetMass : public AxesDefinition {
  public:
    
    /// Constructor.
    InvariantJetMass(const FinalState& fsp)
      : _calculatedInvariantJetMass(false)
    {
      setName("InvariantJetMass");
      addProjection(fsp, "FS");
    }
    
    /// Clone on the heap.
    virtual const Projection* clone() const {
      return new InvariantJetMass(*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:
    
    ///@{ InvariantJetMass scalar accessors
    /// The invariantjetmass scalar, \f$ T \f$, (invariantjetmass along taxis).
    const double invariantjetmass() const { return _invariantjetmasss[0]; }

 
    ///@{ InvariantJetMass axis accessors
    /// The thrust axis.
    const Vector3& invariantjetmassAxis() const { return _invariantjetmassAxes[0]; }

    
    ///@{ AxesDefinition axis accessors.
    const Vector3& axis1() const { return invariantjetmassAxis(); }
    const Vector3& axis2() const { return invariantjetmassAxis(); }
    const Vector3& axis3() const { return invariantjetmassAxis(); }

    
  public:
    
    /// @name Direct methods
    /// Ways to do the calculation directly, without engaging the caching system
    //@{
 
    /// Manually calculate the invariantjetmass, without engaging the caching system
    void calc(const FinalState& fs);
    
    /// Manually calculate the invariantjetmass, without engaging the caching system
    void calc(const vector<Particle>& fsparticles);
    
    /// Manually calculate the invariantjetmass, without engaging the caching system
    void calc(const vector<FourMomentum>& fsmomenta);
    
    
    //@}
    
    
  private:
    
    /// The invariantjetmass scalars.
    vector<double> _invariantjetmasss;
    
    /// The invariantjetmass axes.
    vector<Vector3> _invariantjetmassAxes;
    
    /// Caching flag to avoid costly recalculations.
    bool _calculatedInvariantJetMass;
    
  private:
    
    /// Explicitly calculate the invariantjetmass values.
    void _calcInvariantJetMass(const vector<FourMomentum>& fsmomenta);
    
  };
  
 }
 
#endif