ClusterAnalysisHighPt.h

#ifndef FastJetStability_ClusterAnalysisHighPt_h
#define FastJetStability_ClusterAnalysisHighPt_h

#include "JetStabilityDefs.h"
#include "ClusteringComparisonIndexCP.h"
#include "AbsFuzzinessCalculator.h"
#include "ClusterAnalysis.h"

#include "fastjet/ClusterSequence.hh"

namespace stab {

class ClusterAnalysisHighPt {

public:
  inline ClusterAnalysisHighPt (const double dCut, const bool useJunkJet = true)
    :m_dCut(dCut)
    ,m_nEvent(0U),m_nEventSize(100U),m_event(m_nEventSize)
    ,m_nJetSize(50U),m_jets(m_nJetSize)
    ,m_nJetsInCycle(0U),m_nJets(0U)
    ,m_jetCycleMap(m_nJetSize),m_partMap(m_nEventSize,0U)
    ,m_nCycle(0U),m_useJunkJet(useJunkJet)
    { }

  inline ClusterAnalysisHighPt ()
    :m_dCut(-1.)
    ,m_nEvent(0U),m_nEventSize(100U),m_event(m_nEventSize)
    ,m_nJetSize(50U),m_jets(m_nJetSize)
    ,m_nJetsInCycle(0U),m_nJets(0U)
    ,m_jetCycleMap(m_nJetSize),m_partMap(m_nEventSize,0U)
    ,m_nCycle(0U),m_useJunkJet(true)
    { }

  inline virtual ~ClusterAnalysisHighPt () { }

  void initialize(const fastjet::ClusterSequence &);

  void clear();

  void fill(const fastjet::ClusterSequence &);

  double doStability(const ClusteringComparisonIndexCP &,const StabilityCalcMethod method=PAIRWISE);

  double doFuzziness(const AbsFuzzinessCalculator &);

  inline double dCut() const { return m_dCut; }

  inline const std::vector<double> & cpStab() const { return m_cpStab; }

private:
  //---------------------------- private methods -------------------
  double pairwiseStability(const ClusteringComparisonIndexCP &);
  double exhaustiveStability(const ClusteringComparisonIndexCP &);
  double unsmearedStability(const ClusteringComparisonIndexCP &);
  double resampledStability(const ClusteringComparisonIndexCP &);
  

  //---------------------------- private data ----------------------
  // distance cut-off for this analysis
  double m_dCut;

  unsigned m_nEvent;  // number of particles in the event   
  unsigned m_nEventSize; // size of m_event vector
  // the initial event
  Event m_event;

  // list of clustered jets to keep track of each event
  // This grows as it encounters more jets
  // should perform one-to-one match with each fill
  unsigned m_nJetSize; // size of capacity of m_jets
  Event m_jets;

  unsigned m_nJetsInCycle;
  unsigned m_nJets;
  
  // this vector points for each element in the cycle's jets to
  // an index in m_jets
  std::vector<unsigned> m_jetCycleMap;

  // map the initial event into the m_jets vector
  std::vector<unsigned> m_partMap;
  // a collection of m_partMap for each cycle of smearing
  std::vector<std::vector<unsigned> > m_partMapVec;

  // constituent perspective clustering stability map
  std::vector<double> m_cpStab;

  // the number of cycles encountered (i.e. the number of time fill has been called)
  unsigned m_nCycle;

  // use a third jet for everything outside of the first in pt
  bool m_useJunkJet;


}; // end ClusterAnalysisHighPt declaration

} // end stab namespace

#endif