Loading...
Searching...
No Matches
ClusterSequenceActiveArea.hh
//FJSTARTHEADER
// $Id$
//
// Copyright (c) 2005-2021, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
//
//----------------------------------------------------------------------
// 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. They are described in the original FastJet paper,
// hep-ph/0512210 and in the manual, arXiv:1111.6097. If you use
// FastJet as part of work towards a scientific publication, please
// quote the version you use and include a citation to the manual and
// optionally also to hep-ph/0512210.
//
// 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, see <http://www.gnu.org/licenses/>.
//----------------------------------------------------------------------
//FJENDHEADER
#ifndef __FASTJET_CLUSTERSEQUENCEACTIVEAREA_HH__
#define __FASTJET_CLUSTERSEQUENCEACTIVEAREA_HH__
#include "fastjet/PseudoJet.hh"
#include "fastjet/ClusterSequenceAreaBase.hh"
#include "fastjet/ClusterSequenceActiveAreaExplicitGhosts.hh"
#include<iostream>
#include<vector>
//------------ backwards compatibility with version 2.1 -------------
// for backwards compatibility make ActiveAreaSpec name available
//#include "fastjet/ActiveAreaSpec.hh"
//#include "fastjet/ClusterSequenceWithArea.hh"
//--------------------------------------------------------------------
FASTJET_BEGIN_NAMESPACE // defined in fastjet/internal/base.hh
//using namespace std;
/// @ingroup sec_area_classes
/// \class ClusterSequenceActiveArea
/// Like ClusterSequence with computation of the active jet area
///
/// Class that behaves essentially like ClusterSequence except
/// that it also provides access to the area of a jet (which
/// will be a random quantity... Figure out what to do about seeds
/// later...)
///
/// This class should not be used directly. Rather use
/// ClusterSequenceArea with the appropriate AreaDefinition
class ClusterSequenceActiveArea : public ClusterSequenceAreaBase {
public:
/// default constructor
ClusterSequenceActiveArea() {}
/// constructor based on JetDefinition and GhostedAreaSpec
template<class L> ClusterSequenceActiveArea
(const std::vector<L> & pseudojets,
const JetDefinition & jet_def_in,
const GhostedAreaSpec & ghost_spec,
const bool & writeout_combinations = false) ;
virtual double area (const PseudoJet & jet) const FASTJET_OVERRIDE{
return _average_area[jet.cluster_hist_index()];};
virtual double area_error (const PseudoJet & jet) const FASTJET_OVERRIDE {
return _average_area2[jet.cluster_hist_index()];};
virtual PseudoJet area_4vector (const PseudoJet & jet) const FASTJET_OVERRIDE{
return _average_area_4vector[jet.cluster_hist_index()];};
/// enum providing a variety of tentative strategies for estimating
/// the background (e.g. non-jet) activity in a highly populated event; the
/// one that has been most extensively tested is median.
///
/// These strategies are OBSOLETE and deprecated (see comment
/// for pt_per_unit_area).
enum mean_pt_strategies{median=0, non_ghost_median, pttot_over_areatot,
pttot_over_areatot_cut, mean_ratio_cut, play,
median_4vector};
/// return the transverse momentum per unit area according to one
/// of the above strategies; for some strategies (those with "cut"
/// in their name) the parameter "range" allows one to exclude a
/// subset of the jets for the background estimation, those that
/// have pt/area > median(pt/area)*range.
///
/// NB: This call is OBSOLETE and deprecated; use a
/// JetMedianBackgroundEstimator or GridMedianBackgroundEstimator
/// instead.
double pt_per_unit_area(mean_pt_strategies strat=median,
double range=2.0 ) const;
/// rewrite the empty area from the parent class, so as to use
/// all info at our disposal
/// return the total area, corresponding to a given Selector, that
/// consists of ghost jets or unclustered ghosts
///
/// The selector passed as an argument needs to apply jet by jet.
virtual double empty_area(const Selector & selector) const FASTJET_OVERRIDE;
/// return the true number of empty jets (replaces
/// ClusterSequenceAreaBase::n_empty_jets(...))
virtual double n_empty_jets(const Selector & selector) const FASTJET_OVERRIDE;
protected:
void _resize_and_zero_AA ();
void _initialise_AA(const JetDefinition & jet_def,
const GhostedAreaSpec & ghost_spec,
const bool & writeout_combinations,
bool & continue_running);
void _run_AA(const GhostedAreaSpec & ghost_spec);
void _postprocess_AA(const GhostedAreaSpec & ghost_spec);
/// does the initialisation and running specific to the active
/// areas class
void _initialise_and_run_AA (const JetDefinition & jet_def,
const GhostedAreaSpec & ghost_spec,
const bool & writeout_combinations = false);
/// transfer the history (and jet-momenta) from clust_seq to our
/// own internal structure while removing ghosts
void _transfer_ghost_free_history(
const ClusterSequenceActiveAreaExplicitGhosts & clust_seq);
/// transfer areas from the ClusterSequenceActiveAreaExplicitGhosts
/// object into our internal area bookkeeping...
void _transfer_areas(const std::vector<int> & unique_hist_order,
const ClusterSequenceActiveAreaExplicitGhosts & );
/// child classes benefit from having these at their disposal
std::valarray<double> _average_area, _average_area2;
std::valarray<PseudoJet> _average_area_4vector;
/// returns true if there are any particles whose transverse momentum
/// if so low that there's a risk of the ghosts having modified the
/// clustering sequence
bool has_dangerous_particles() const {return _has_dangerous_particles;}
private:
double _non_jet_area, _non_jet_area2, _non_jet_number;
double _maxrap_for_area; // max rap where we put ghosts
double _safe_rap_for_area; // max rap where we trust jet areas
bool _has_dangerous_particles;
/// routine for extracting the tree in an order that will be independent
/// of any degeneracies in the recombination sequence that don't
/// affect the composition of the final jets
void _extract_tree(std::vector<int> &) const;
/// do the part of the extraction associated with pos, working
/// through its children and their parents
void _extract_tree_children(int pos, std::valarray<bool> &, const std::valarray<int> &, std::vector<int> &) const;
/// do the part of the extraction associated with the parents of pos.
void _extract_tree_parents (int pos, std::valarray<bool> &, const std::valarray<int> &, std::vector<int> &) const;
/// check if two jets have the same momentum to within the
/// tolerance (and if pt's are not the same we're forgiving and
/// look to see if the energy is the same)
void _throw_unless_jets_have_same_perp_or_E(const PseudoJet & jet,
const PseudoJet & refjet,
double tolerance,
const ClusterSequenceActiveAreaExplicitGhosts & jets_ghosted_seq
) const;
/// since we are playing nasty games with seeds, we should warn
/// the user a few times
//static int _n_seed_warnings;
//const static int _max_seed_warnings = 10;
// record the number of repeats
int _ghost_spec_repeat;
/// a class for our internal storage of ghost jets
class GhostJet : public PseudoJet {
public:
GhostJet(const PseudoJet & j, double a) : PseudoJet(j), area(a){}
double area;
};
std::vector<GhostJet> _ghost_jets;
std::vector<GhostJet> _unclustered_ghosts;
};
template<class L> ClusterSequenceActiveArea::ClusterSequenceActiveArea
(const std::vector<L> & pseudojets,
const JetDefinition & jet_def_in,
const GhostedAreaSpec & ghost_spec,
const bool & writeout_combinations) {
// transfer the initial jets (type L) into our own array
_transfer_input_jets(pseudojets);
// run the clustering for active areas
_initialise_and_run_AA(jet_def_in, ghost_spec, writeout_combinations);
}
FASTJET_END_NAMESPACE
#endif // __FASTJET_CLUSTERSEQUENCEACTIVEAREA_HH__
fastjet::ClusterSequenceActiveAreaExplicitGhosts
Like ClusterSequence with computation of the active jet area with the addition of explicit ghosts.
Definition ClusterSequenceActiveAreaExplicitGhosts.hh:58
fastjet::ClusterSequenceActiveArea
Like ClusterSequence with computation of the active jet area.
Definition ClusterSequenceActiveArea.hh:63
fastjet::ClusterSequenceActiveArea::ClusterSequenceActiveArea
ClusterSequenceActiveArea()
default constructor
Definition ClusterSequenceActiveArea.hh:67
fastjet::ClusterSequenceActiveArea::area_4vector
virtual PseudoJet area_4vector(const PseudoJet &jet) const override
return a PseudoJet whose 4-vector is defined by the following integral
Definition ClusterSequenceActiveArea.hh:81
fastjet::ClusterSequenceActiveArea::area_error
virtual double area_error(const PseudoJet &jet) const override
return the error (uncertainty) associated with the determination of the area of this jet; this base c...
Definition ClusterSequenceActiveArea.hh:78
fastjet::ClusterSequenceActiveArea::mean_pt_strategies
mean_pt_strategies
enum providing a variety of tentative strategies for estimating the background (e....
Definition ClusterSequenceActiveArea.hh:90
fastjet::ClusterSequenceActiveArea::area
virtual double area(const PseudoJet &jet) const override
return the area associated with the given jet; this base class returns 0.
Definition ClusterSequenceActiveArea.hh:76
fastjet::ClusterSequenceActiveArea::_average_area
std::valarray< double > _average_area
child classes benefit from having these at their disposal
Definition ClusterSequenceActiveArea.hh:147
fastjet::ClusterSequenceActiveArea::_initialise_and_run_AA
void _initialise_and_run_AA(const JetDefinition &jet_def, const GhostedAreaSpec &ghost_spec, const bool &writeout_combinations=false)
does the initialisation and running specific to the active areas class
Definition ClusterSequenceActiveArea.cc:53
fastjet::ClusterSequenceActiveArea::has_dangerous_particles
bool has_dangerous_particles() const
returns true if there are any particles whose transverse momentum if so low that there's a risk of th...
Definition ClusterSequenceActiveArea.hh:153
fastjet::ClusterSequenceAreaBase::ClusterSequenceAreaBase
ClusterSequenceAreaBase(const std::vector< L > &pseudojets, const JetDefinition &jet_def_in, const bool &writeout_combinations=false)
a constructor which just carries out the construction of the parent class
Definition ClusterSequenceAreaBase.hh:54
fastjet::ClusterSequence::_transfer_input_jets
void _transfer_input_jets(const std::vector< L > &pseudojets)
transfer the vector<L> of input jets into our own vector<PseudoJet> _jets (with some reserved space f...
Definition ClusterSequence.hh:948
fastjet::GhostedAreaSpec
Parameters to configure the computation of jet areas using ghosts.
Definition GhostedAreaSpec.hh:103
fastjet::JetDefinition
class that is intended to hold a full definition of the jet clusterer
Definition JetDefinition.hh:250
fastjet::PseudoJet
Class to contain pseudojets, including minimal information of use to jet-clustering routines.
Definition PseudoJet.hh:68
fastjet::Selector
Class that encodes information about cuts and other selection criteria that can be applied to PseudoJ...
Definition Selector.hh:149