ClusterSequenceAreaBase.hh

//STARTHEADER
// $Id: ClusterSequenceAreaBase.hh 1761 2010-09-16 10:43:18Z soyez $
//
// Copyright (c) 2005-2006, Matteo Cacciari and Gavin Salam
//
//----------------------------------------------------------------------
// This file is part of FastJet.
//
//  FastJet 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.
//
//  The algorithms that underlie FastJet have required considerable
//  development and are described in hep-ph/0512210. If you use
//  FastJet as part of work towards a scientific publication, please
//  include a citation to the FastJet paper.
//
//  FastJet 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 FastJet; if not, write to the Free Software
//  Foundation, Inc.:
//      59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//----------------------------------------------------------------------
//ENDHEADER

#ifndef __FASTJET_CLUSTERSEQUENCEAREABASE_HH__
#define __FASTJET_CLUSTERSEQUENCEAREABASE_HH__

#include "fastjet/ClusterSequence.hh"
#include "fastjet/internal/LimitedWarning.hh"
#include "fastjet/RangeDefinition.hh"

FASTJET_BEGIN_NAMESPACE

class ClusterSequenceAreaBase : public ClusterSequence {
public:
  
  template<class L> ClusterSequenceAreaBase
         (const std::vector<L> & pseudojets, 
          const JetDefinition & jet_def,
          const bool & writeout_combinations = false) :
           ClusterSequence(pseudojets, jet_def, writeout_combinations) {}


  ClusterSequenceAreaBase() {}


  virtual ~ClusterSequenceAreaBase() {}


  virtual double area       (const PseudoJet & ) const {return 0.0;}

  virtual double area_error (const PseudoJet & ) const {return 0.0;}

  virtual PseudoJet area_4vector(const PseudoJet & ) const {
    return PseudoJet(0.0,0.0,0.0,0.0);}

  virtual bool is_pure_ghost(const PseudoJet & ) const {
    return false;
  }

  virtual bool has_explicit_ghosts() const {
    return false;
  }

  virtual double empty_area(const RangeDefinition & range) const;

  double empty_area_from_jets(const std::vector<PseudoJet> & all_jets,
                              const RangeDefinition & range) const;

  virtual double n_empty_jets(const RangeDefinition & range) const {
    double R = jet_def().R();
    return empty_area(range)/(0.55*pi*R*R);
  }

  double median_pt_per_unit_area(const RangeDefinition & range) const;

  double median_pt_per_unit_area_4vector(const RangeDefinition & range) const;
  
  double median_pt_per_unit_something(
                    const RangeDefinition & range, bool use_area_4vector) const;

  virtual void get_median_rho_and_sigma(const RangeDefinition & range, 
                                        bool use_area_4vector,
                                        double & median, double & sigma,
                                        double & mean_area) const;

  virtual void get_median_rho_and_sigma(const std::vector<PseudoJet> & all_jets,
                                        const RangeDefinition & range, 
                                        bool use_area_4vector,
                                        double & median, double & sigma,
                                        double & mean_area,
                                        bool all_are_inclusive = false) const;

  virtual void get_median_rho_and_sigma(const RangeDefinition & range, 
                                bool use_area_4vector,
                                double & median, double & sigma) const {
    double mean_area;
    get_median_rho_and_sigma(range,  use_area_4vector,
                             median,  sigma, mean_area);
  }
  

  virtual void parabolic_pt_per_unit_area(double & a, double & b, 
                                          const RangeDefinition & range, 
                                          double exclude_above=-1.0, 
                                          bool use_area_4vector=false) const;

  std::vector<PseudoJet> subtracted_jets(const double rho,
                                         const double ptmin=0.0) const;

  std::vector<PseudoJet> subtracted_jets(const RangeDefinition & range, 
                                         const double ptmin=0.0) const;

  PseudoJet subtracted_jet(const PseudoJet & jet,
                           const double rho) const;

  PseudoJet subtracted_jet(const PseudoJet & jet,
                           const RangeDefinition & range) const;

  double subtracted_pt(const PseudoJet & jet,
                       const double rho,
                       bool use_area_4vector=false) const;

  double subtracted_pt(const PseudoJet & jet,
                       const RangeDefinition & range,
                       bool use_area_4vector=false) const;


private:
  static LimitedWarning _warnings;
  static LimitedWarning _warnings_zero_area;

  void _check_jet_alg_good_for_median() const;
  
};



FASTJET_END_NAMESPACE

#endif // __FASTJET_CLUSTERSEQUENCEAREABASE_HH__