Separate out PWGJE (user)tasks that need fastjet; do not build when fastjet is not present
if(FASTJETENV)
set ( EDEFINE -isystem${FASTJETENV}/include/fastjet )
-else()
- set ( EDEFINE -isystem${ALICE_ROOT}/JETAN/fastjet)
endif(FASTJETENV)
string ( REPLACE ".h" ".cxx" MODULE_SRCS "${CLASS_HDRS}" )
cmake_minimum_required(VERSION 2.8.4 FATAL_ERROR)
-file(GLOB PACKAGES CMake*.pkg)
+# file(GLOB PACKAGES CMake*.pkg)
+set(FASTJET_ROOT $ENV{FASTJET_ROOT})
+
+if(NOT FASTJET_ROOT)
+ set(PACKAGES CMakelibJETAN.pkg)
+ message("JETAN: Fastjet not found; skipping FASTJETAN")
+else()
+ set(PACKAGES CMakelibFASTJETAN.pkg CMakelibJETAN.pkg)
+endif(NOT FASTJET_ROOT)
+
ALICE_BuildModule()
set ( SRCS AliFastJetFinder.cxx AliFastJetHeaderV1.cxx AliFastJetInput.cxx AliFastJetBkg.cxx AliSISConeJetFinder.cxx AliSISConeJetHeader.cxx AliAnalysisTaskJetCluster.cxx AliAnalysisTaskJetBackgroundSubtract.cxx)
-set(FASTJET_ROOT $ENV{FASTJET_ROOT})
+# set(FASTJET_ROOT $ENV{FASTJET_ROOT}) # already done in CMakeLists.txt
-if(FASTJET_ROOT)
- set (FASTJET_INC ${FASTJET_ROOT}/include)
-else()
- set (FASTJET_INC ${ALICE_ROOT}/JETAN/fastjet)
-endif(FASTJET_ROOT)
+set (FASTJET_INC ${FASTJET_ROOT}/include)
string ( REPLACE ".cxx" ".h" HDRS "${SRCS}" )
set ( EDEFINE -isystem${FASTJET_INC} )
set ( EINCLUDE ${FASTJET_INC} ANALYSIS STEER/AOD STEER/STEERBase )
+
+++ /dev/null
-// for backwards compatibility fastjet/CDFJetCluPlugin.hh can also be
-// accessed through this file without specifying "fastjet/"; this is
-// however deprecated for new code, and is not guaranteed to work from
-// release 3.x onwards
-#ifndef __BACKWARD_WARNING__
-#define __BACKWARD_WARNING__
-#warning This file includes at least one deprecated FastJet header. \
-Please consider including FastJet plugins using "fastjet/...Plugin.hh" \
-For backwards compatibility fastjet/...Plugin.hh can also be accessed \
-through this file without specifying "fastjet/"; this is however \
-deprecated for new work, and is not guaranteed to work from release \
-3.x onwards.
-#endif
-
-#include "fastjet/CDFJetCluPlugin.hh"
+++ /dev/null
-// for backwards compatibility fastjet/CDFMidPointPlugin.hh can also be
-// accessed through this file without specifying "fastjet/"; this is
-// however deprecated for new code, and is not guaranteed to work from
-// release 3.x onwards
-#ifndef __BACKWARD_WARNING__
-#define __BACKWARD_WARNING__
-#warning This file includes at least one deprecated FastJet header. \
-Please consider including FastJet plugins using "fastjet/...Plugin.hh" \
-For backwards compatibility fastjet/...Plugin.hh can also be accessed \
-through this file without specifying "fastjet/"; this is however \
-deprecated for new work, and is not guaranteed to work from release \
-3.x onwards.
-#endif
-
-#include "fastjet/CDFMidPointPlugin.hh"
+++ /dev/null
-//STARTHEADER
-// $Id: FjClusterSequence.hh 945 2007-11-09 08:46:04Z salam $
-//
-// 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 __FJCLUSTERSEQUENCE_HH__
-#define __FJCLUSTERSEQUENCE_HH__
-
-
-#ifndef __BACKWARD_WARNING_V1__
-#define __BACKWARD_WARNING_V1__
-#warning This file includes at least one deprecated FastJet header from v1. \
-All fastjet components (including plugins) should now be accessed by including fastjet/...
-#endif // __BACKWARD_WARNING_V1__
-
-#include "fastjet/ClusterSequence.hh"
-
-
-/// typedef which provides backwards compatibility for
-/// user programs based on the v1 interface
-typedef fastjet::ClusterSequence FjClusterSequence;
-
-/// typedef which provides backwards compatibility for
-/// user programs based on the v1 interface
-typedef fastjet::Strategy FjStrategy;
-
-
-// below follow redefinitions of all the strategy constants
-// to allow a v1 legacy user to access the strategy names
-// as before
-
-/// experimental ...
-const FjStrategy N2MinHeapTiled = fastjet::N2MinHeapTiled;
-/// fastest from about 50..10^4
-const FjStrategy N2Tiled = fastjet::N2Tiled;
-/// legacy
-const FjStrategy N2PoorTiled = fastjet::N2PoorTiled;
-/// fastest below 50
-const FjStrategy N2Plain = fastjet::N2Plain;
-/// worse even than the usual N^3 algorithms
-const FjStrategy N3Dumb = fastjet::N3Dumb;
-/// automatic selection of the best (based on N)
-const FjStrategy Best = fastjet::Best;
-/// best of the NlnN variants -- best overall for N>10^4
-const FjStrategy NlnN = fastjet::NlnN;
-/// legacy N ln N using 3pi coverage of cylinder
-const FjStrategy NlnN3pi = fastjet::NlnN3pi;
-/// legacy N ln N using 4pi coverage of cylinder
-const FjStrategy NlnN4pi = fastjet::NlnN4pi;
-/// Chan's closest pair method (in a variant with 4pi coverage),
-/// for use exclusively with the Cambridge algorithm
-const FjStrategy NlnNCam4pi = fastjet::NlnNCam4pi;
-const FjStrategy NlnNCam2pi2R = fastjet::NlnNCam2pi2R;
-const FjStrategy NlnNCam = fastjet::NlnNCam; // 2piMultD
-
-
-#endif //__FJCLUSTERSEQUENCE_HH__
+++ /dev/null
-//STARTHEADER
-// $Id: FjPseudoJet.hh 945 2007-11-09 08:46:04Z salam $
-//
-// 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 __FJPSEUDOJET_HH__
-#define __FJPSEUDOJET_HH__
-
-#ifndef __BACKWARD_WARNING_V1__
-#define __BACKWARD_WARNING_V1__
-#warning This file includes at least one deprecated FastJet header from v1. \
-All fastjet components (including plugins) should now be accessed by including fastjet/...
-#endif // __BACKWARD_WARNING_V1__
-
-
-#include "fastjet/PseudoJet.hh"
-
-/// typedef which provides backwards compatibility for
-/// user programs based on the v1 interface
-typedef fastjet::PseudoJet FjPseudoJet;
-
-/// thought not officially "declared" in the docuementation,
-/// this was used in the v1 fastjet_timing.cc example program,
-/// so in order to ensure that it still compiles we define it...
-const double twopi = fastjet::twopi;
-
-#endif //__FJPSEUDOJET_HH__
+++ /dev/null
-//STARTHEADER
-// $Id: ActiveAreaSpec.hh 633 2007-05-10 15:59:09Z salam $
-//
-// 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_ACTIVEAREASPEC_HH__
-#define __FASTJET_ACTIVEAREASPEC_HH__
-#include "fastjet/GhostedAreaSpec.hh"
-
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-/// just provide a typedef for backwards compatibility with programs
-/// based on versions 2.0 and 2.1 of fastjet
-typedef GhostedAreaSpec ActiveAreaSpec;
-
-} // fastjet namespace
-
-#endif // __FASTJET_ACTIVEAREASPEC_HH__
+++ /dev/null
-//STARTHEADER
-// $Id: AreaDefinition.hh 635 2007-05-10 18:37:10Z salam $
-//
-// Copyright (c) 2006-2007, Matteo Cacciari, Gavin 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 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_AREADEFINITION_HH__
-#define __FASTJET_AREADEFINITION_HH__
-
-#include "fastjet/GhostedAreaSpec.hh"
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-//----------------------------------------------------------------------
-//
-/// class for holding a "Voronoi area" specification; an area will be
-/// assigned to each particle, which is the area of the intersection
-/// of the particle's Voronoi cell with a circle of radius
-/// R*effective_Rfact.
-///
-class VoronoiAreaSpec {
-public:
-
- /// default constructor (effective_Rfact = 1);
- VoronoiAreaSpec() : _effective_Rfact(1.0) {};
-
- /// constructor that allows you to set effective_Rfact.
- VoronoiAreaSpec(double effective_Rfact) :
- _effective_Rfact(effective_Rfact) {};
-
- /// return the value of effective_Rfact
- double effective_Rfact() const {return _effective_Rfact;}
-
- /// return a textual description of the area definition.
- std::string description() const;
-
-private:
- double _effective_Rfact;
-};
-
-
-/// the different types of area that are supported
-enum AreaType {invalid_area = -1,
- active_area = 0, active_area_explicit_ghosts = 1,
- one_ghost_passive_area = 10, passive_area = 11,
- voronoi_area=20};
-
-
-//----------------------------------------------------------------------
-/// class that holds a generic area definition
-///
-class AreaDefinition {
-public:
-
- /// default constructor, which provides a ghosted active area, with
- /// sensible defaults for the ghosts.
- AreaDefinition() {
- _area_type = active_area;
- _ghost_spec = GhostedAreaSpec();
- }
-
- /// constructor for an area definition based on an area type and a
- /// ghosted area specification
- AreaDefinition(AreaType type, const GhostedAreaSpec & spec) {
- _ghost_spec = spec;
- _area_type = type;
- assert(type != voronoi_area);
- }
-
- /// constructor for an area definition based on an area type and a
- /// voronoi area specification (type must be voronoi_area)
- AreaDefinition(AreaType type, const VoronoiAreaSpec & spec) {
- _voronoi_spec = spec;
- _area_type = type;
- assert(type == voronoi_area);
- }
-
- /// constructor for an area definition based on an area type and
- /// which attempts to provide sensible defaults for everything else
- AreaDefinition(AreaType type) {
- _area_type = type;
- if (type == voronoi_area) {
- _voronoi_spec = VoronoiAreaSpec();
- } else {
- _ghost_spec = GhostedAreaSpec();
- }
- }
-
- /// constructor for an area definition based on an ghosted area
- /// specification, and an option to select which ghosted area you want
- AreaDefinition(const GhostedAreaSpec & spec, AreaType type = active_area) {
- _ghost_spec = spec;
- _area_type = type;
- assert(type != voronoi_area);
- }
-
- /// constructor for an area definition based on a voronoi area
- /// specification
- AreaDefinition(const VoronoiAreaSpec & spec) {
- _voronoi_spec = spec;
- _area_type = voronoi_area;
- }
-
- /// return a description of the current area definition
- std::string description() const;
-
- /// return info about the type of area being used by this defn
- AreaType area_type() const {return _area_type;}
-
- /// return a reference to the active area spec
- const GhostedAreaSpec & ghost_spec() const {return _ghost_spec;}
- GhostedAreaSpec & ghost_spec() {return _ghost_spec;}
-
- /// return a reference to the voronoi area spec
- const VoronoiAreaSpec & voronoi_spec() const {return _voronoi_spec;}
-
-private:
-
- AreaType _area_type;
- GhostedAreaSpec _ghost_spec;
- VoronoiAreaSpec _voronoi_spec;
-};
-
-} // fastjet namespace
-
-
-#endif // __FASTJET_AREADEFINITION_HH__
+++ /dev/null
-//STARTHEADER
-// $Id: CDFJetCluPlugin.hh 1493 2009-03-11 19:15:17Z salam $
-//
-// 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 __CDFJETCLUPLUGIN_HH__
-#define __CDFJETCLUPLUGIN_HH__
-
-#include "fastjet/JetDefinition.hh"
-#include "fastjet/PseudoJet.hh"
-#include <map>
-
-// questionable whether this should be in fastjet namespace or not...
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-/// a plugin for fastjet-v2.1 that provides an interface to the CDF
-/// jetclu algorithm
-class CDFJetCluPlugin : public JetDefinition::Plugin {
-public:
- /// a compact constructor
- CDFJetCluPlugin (double cone_radius,
- double overlap_threshold,
- double seed_threshold = 1.0,
- int iratch = 1) :
- _seed_threshold ( seed_threshold ),
- _cone_radius ( cone_radius ),
- _adjacency_cut ( 2 ),
- _max_iterations ( 100 ),
- _iratch ( iratch ),
- _overlap_threshold ( overlap_threshold ) {}
-
- /// a constructor that looks like the one provided by CDF
- CDFJetCluPlugin (
- double seed_threshold ,
- double cone_radius ,
- int adjacency_cut ,
- int max_iterations ,
- int iratch ,
- double overlap_threshold) :
- _seed_threshold (seed_threshold ),
- _cone_radius (cone_radius ),
- _adjacency_cut (adjacency_cut ),
- _max_iterations (max_iterations ),
- _iratch (iratch ),
- _overlap_threshold (overlap_threshold ) {}
-
- // some functions to return info about parameters
- double seed_threshold () const {return _seed_threshold ;}
- double cone_radius () const {return _cone_radius ;}
- int adjacency_cut () const {return _adjacency_cut ;}
- int max_iterations () const {return _max_iterations ;}
- int iratch () const {return _iratch ;}
- double overlap_threshold () const {return _overlap_threshold ;}
-
-
- // the things that are required by base class
- virtual std::string description () const;
- virtual void run_clustering(ClusterSequence &) const;
- /// the plugin mechanism's standard way of accessing the jet radius
- virtual double R() const {return cone_radius();}
-
-
-private:
-
- double _seed_threshold ;
- double _cone_radius ;
- int _adjacency_cut ;
- int _max_iterations ;
- int _iratch ;
- double _overlap_threshold;
-
- /// given a jet try inserting its energy into the map -- if that
- /// energy entry already exists, modify the jet infinitesimally so
- /// as ensure that the jet energy is unique
- void _insert_unique (PseudoJet & jet, std::map<double,int> & jetmap) const;
-
-};
-
-} // fastjet namespace
-
-#endif // __CDFJETCLUPLUGIN_HH__
+++ /dev/null
-//STARTHEADER
-// $Id: CDFMidPointPlugin.hh 1186 2008-04-04 16:15:39Z salam $
-//
-// 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 __CDFMIDPOINTPLUGIN_HH__
-#define __CDFMIDPOINTPLUGIN_HH__
-
-#include "fastjet/JetDefinition.hh"
-
-// questionable whether this should be in fastjet namespace or not...
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-//----------------------------------------------------------------------
-//
-/// CDFMidPointPlugin is a plugin for fastjet (v2.1 upwards) that
-/// provides an interface to the CDF version of Run-II iterative cone
-/// algorithm with midpoint seeds (also known as the Iterative Legacy
-/// Cone Algorithm, ILCA).
-///
-/// The CDF code has been taken from Joey Huston's webpage
-/// http://www.pa.msu.edu/~huston/Les_Houches_2005/Les_Houches_SM.html
-///
-/// Note that the CDF midpoint code contains options that go beyond
-/// those described in the Tevatron run-II document (hep-ex/0005012),
-/// notably search-cones, as described in hep-ph/0111434, and
-/// midpoints bewteen multiplets of stable cones.
-///
-/// Additionally, the version of the CDF midpoint code distributed
-/// here has been modified by the FastJet authors, so as to allow one
-/// to choose the scale used in the split-merge step.
-//
-//----------------------------------------------------------------------
-class CDFMidPointPlugin : public JetDefinition::Plugin {
-public:
- /// the choice of scale to be used in the split-merge step
- // NB: just replicates what we've added to the CDF midpoint code
- enum SplitMergeScale {SM_pt, SM_Et, SM_mt, SM_pttilde};
-
- ///
- /// A CDFMidPointPlugin constructor that looks like the one provided
- /// by CDF. Its arguments should have the following meaning:
- ///
- /// - seed_threshold: minimum pt for a particle to be considered
- /// a seed of the iteration.
- ///
- /// - cone_radius: standard meaning
- ///
- /// - cone_area_fraction: stable-cones are searched for with a
- /// radius Rsearch = R * sqrt(cone_area_fraction), and then
- /// expanded to size R afterwards; note (hep-ph/0610012) that this
- /// introduces IR unsafety at NLO for X+2-jet observables (where X
- /// any hard object).
- ///
- /// - max_pair_size: "midpoints" can be added between pairs of
- /// stable cones, triplets of stable cones, etc.; max_pair_size
- /// indicates the maximum number of stable cones that are
- /// assembled when adding midpoints.
- ///
- /// - max_iterations: the maximum number of iterations to carry out
- /// when looking for a stable cone.
- ///
- /// - overlap_threshold: if
- /// (overlapping_Et)/(Et_of_softer_protojet) < overlap_threshold,
- /// overlapping jets are split, otherwise they are merged.
- ///
- /// - sm_scale: a choice for the scale to be used in the split-merge
- /// step (both for ordering the momenta and quantifying the
- /// overlap); the three options are
- ///
- /// . SM_pt: pt (default -- source of small IR safety issue in purely
- /// hadronic events)
- ///
- /// . SM_Et: Et (not boost invariant, reduces to mt at zero rapidity and
- /// to pt and infinite rapidity)
- ///
- /// . SM_mt: transverse mass = sqrt(m^2+pt^2)
- ///
- CDFMidPointPlugin (
- double seed_threshold ,
- double cone_radius ,
- double cone_area_fraction ,
- int max_pair_size ,
- int max_iterations ,
- double overlap_threshold ,
- SplitMergeScale sm_scale = SM_pt) :
- _seed_threshold (seed_threshold ),
- _cone_radius (cone_radius ),
- _cone_area_fraction (cone_area_fraction ),
- _max_pair_size (max_pair_size ),
- _max_iterations (max_iterations ),
- _overlap_threshold (overlap_threshold ),
- _sm_scale (sm_scale) {}
-
- /// a compact constructor
- ///
- /// NB: as of version 2.4, the default value for the
- /// overlap_threshold threshold has been removed, to avoid
- /// misleading people into using the value of 0.5 without thinking,
- /// which is known to have adverse effects in high-noise
- /// environments. A recommended value is 0.75.
- CDFMidPointPlugin (double cone_radius,
- double overlap_threshold,// = 0.5,
- double seed_threshold = 1.0,
- double cone_area_fraction = 1.0) :
- _seed_threshold (seed_threshold ),
- _cone_radius (cone_radius ),
- _cone_area_fraction (cone_area_fraction ),
- _max_pair_size (2 ),
- _max_iterations (100 ),
- _overlap_threshold (overlap_threshold ),
- _sm_scale (SM_pt) {}
-
-
- // some functions to return info about parameters
- double seed_threshold () const {return _seed_threshold ;}
- double cone_radius () const {return _cone_radius ;}
- double cone_area_fraction () const {return _cone_area_fraction ;}
- int max_pair_size () const {return _max_pair_size ;}
- int max_iterations () const {return _max_iterations ;}
- double overlap_threshold () const {return _overlap_threshold ;}
-
-
- // the things that are required by base class
- virtual std::string description () const;
- virtual void run_clustering(ClusterSequence &) const;
- /// the plugin mechanism's standard way of accessing the jet radius
- virtual double R() const {return cone_radius();}
-
-private:
-
- double _seed_threshold ;
- double _cone_radius ;
- double _cone_area_fraction;
- int _max_pair_size ;
- int _max_iterations ;
- double _overlap_threshold ;
- SplitMergeScale _sm_scale ;
-};
-
-} // fastjet namespace
-
-#endif // __CDFMIDPOINTPLUGIN_HH__
+++ /dev/null
-//STARTHEADER
-// $Id: CircularRange.hh 1502 2009-04-06 10:33:14Z salam $
-//
-// 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_CIRCULARRANGE_HH__
-#define __FASTJET_CIRCULARRANGE_HH__
-
-#include "fastjet/RangeDefinition.hh"
-#include "fastjet/Error.hh"
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-class CircularRange : public fastjet::RangeDefinition {
-public:
- /// constructor
- CircularRange() {_set_invalid_rapphi();}
-
- /// initialise CircularRange with a jet
- CircularRange(const fastjet::PseudoJet & jet, double distance) {
- _distance = distance;
- _rapjet = jet.rap();
- _phijet = jet.phi();
- _total_area = fastjet::pi*_distance*_distance; }
-
- /// initialise CircularRange with a (rap,phi) point
- CircularRange(double rap, double phi, double distance) {
- _distance = distance;
- _rapjet = rap;
- _phijet = phi;
- _total_area = fastjet::pi*_distance*_distance; }
-
- /// initialise CircularRange with just the radius parameter
- CircularRange(double distance) {
- _set_invalid_rapphi();
- _distance = distance;
- _total_area = fastjet::pi*_distance*_distance; }
-
- /// destructor
- virtual ~CircularRange() {}
-
- /// return description of range
- virtual inline std::string description() const {
- std::ostringstream ostr;
- ostr << "CircularRange: within distance "<< _distance << " of given jet or point." ;
- return ostr.str(); }
-
- /// returns true since this range is localizable (i.e. set_position
- /// does something meaningful)
- virtual inline bool is_localizable() const { return true; }
-
- /// return bool according to whether (rap,phi) is in range
- virtual inline bool is_in_range(double rap, double phi) const {
- if (! _rapphi_are_valid()) {
- throw Error("Circular range used without a center having being defined (use set_position())");
- }
- double deltaphi = _phijet - phi;
- if ( deltaphi > pi) { deltaphi -= twopi; }
- else if ( deltaphi < -pi) { deltaphi += twopi; }
- bool inrange = ( (rap-_rapjet)*(rap-_rapjet) +
- deltaphi*deltaphi <= _distance*_distance );
- return inrange; }
-
- /// return the minimal and maximal rapidity of this range
- virtual inline void get_rap_limits(double & rapmin, double & rapmax) const {
- rapmin = _rapjet - _distance;
- rapmax = _rapjet + _distance; }
-
-private:
- double _distance;
-
- /// value for phi that marks it as invalid
- const static double _invalid_phi = -1000.0;
- /// set internal phi so as to mark things as invalid
- void _set_invalid_rapphi() {_phijet = _invalid_phi;}
- /// true if rap,phi are valid (tests only phi)
- bool _rapphi_are_valid() const {return _phijet != _invalid_phi;}
-
-};
-
-} // fastjet namespace
-
-#endif // __FASTJET_CIRCULARRANGE_HH__
+++ /dev/null
-//STARTHEADER
-// $Id: ClusterSequence.hh 1435 2009-02-12 21:11:04Z salam $
-//
-// 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
-
-
-//----------------------------------------------------------------------
-// here's where we put the main page for fastjet (as explained in the
-// Doxygen faq)
-//......................................................................
-/*! \mainpage FastJet code documentation
- *
- * These pages provide automatically generated documentation for the
- * FastJet package.
- *
- * For further information and normal documentation, see the main <a
- * href="http://www.lpthe.jussieu.fr/~salam/fastjet">FastJet</a> page.
- */
-//----------------------------------------------------------------------
-
-#ifndef __FASTJET_CLUSTERSEQUENCE_HH__
-#define __FASTJET_CLUSTERSEQUENCE_HH__
-
-#include<vector>
-#include<map>
-#include "fastjet/internal/DynamicNearestNeighbours.hh"
-#include "fastjet/PseudoJet.hh"
-#include<memory>
-#include<cassert>
-#include<iostream>
-#include<string>
-#include<set>
-#include<cmath> // needed to get double std::abs(double)
-#include "fastjet/Error.hh"
-#include "fastjet/JetDefinition.hh"
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-
-/// deals with clustering
-class ClusterSequence {
-
-
- public:
-
- /// default constructor
- ClusterSequence () {}
-
- /// create a clustersequence starting from the supplied set
- /// of pseudojets and clustering them with the long-invariant
- /// kt algorithm (E-scheme recombination) with the supplied
- /// value for R.
- ///
- /// If strategy=DumbN3 a very stupid N^3 algorithm is used for the
- /// clustering; otherwise strategy = NlnN* uses cylinders algorithms
- /// with some number of pi coverage. If writeout_combinations=true a
- /// summary of the recombination sequence is written out
- template<class L> ClusterSequence (const std::vector<L> & pseudojets,
- const double & R = 1.0,
- const Strategy & strategy = Best,
- const bool & writeout_combinations = false);
-
-
- /// create a clustersequence starting from the supplied set
- /// of pseudojets and clustering them with jet definition specified
- /// by jet_def (which also specifies the clustering strategy)
- template<class L> ClusterSequence (
- const std::vector<L> & pseudojets,
- const JetDefinition & jet_def,
- const bool & writeout_combinations = false);
-
- // virtual ClusterSequence destructor, in case any derived class
- // thinks of needing a destructor at some point
- virtual ~ClusterSequence (); //{}
-
- // NB: in the routines that follow, for extracting lists of jets, a
- // list structure might be more efficient, if sometimes a little
- // more awkward to use (at least for old fortran hands).
-
- /// return a vector of all jets (in the sense of the inclusive
- /// algorithm) with pt >= ptmin. Time taken should be of the order
- /// of the number of jets returned.
- std::vector<PseudoJet> inclusive_jets (const double & ptmin = 0.0) const;
-
- /// return the number of jets (in the sense of the exclusive
- /// algorithm) that would be obtained when running the algorithm
- /// with the given dcut.
- int n_exclusive_jets (const double & dcut) const;
-
- /// return a vector of all jets (in the sense of the exclusive
- /// algorithm) that would be obtained when running the algorithm
- /// with the given dcut.
- std::vector<PseudoJet> exclusive_jets (const double & dcut) const;
-
- /// return a vector of all jets when the event is clustered (in the
- /// exclusive sense) to exactly njets.
- std::vector<PseudoJet> exclusive_jets (const int & njets) const;
-
- /// return the dmin corresponding to the recombination that went from
- /// n+1 to n jets (sometimes known as d_{n n+1}).
- double exclusive_dmerge (const int & njets) const;
-
- /// return the maximum of the dmin encountered during all recombinations
- /// up to the one that led to an n-jet final state; identical to
- /// exclusive_dmerge, except in cases where the dmin do not increase
- /// monotonically.
- double exclusive_dmerge_max (const int & njets) const;
-
- /// return the ymin corresponding to the recombination that went from
- /// n+1 to n jets (sometimes known as y_{n n+1}).
- double exclusive_ymerge (int njets) const {return exclusive_dmerge(njets) / Q2();}
-
- /// same as exclusive_dmerge_max, but normalised to squared total energy
- double exclusive_ymerge_max (int njets) const {return exclusive_ymerge_max(njets)/Q2();}
-
- /// the number of exclusive jets at the given ycut
- int n_exclusive_jets_ycut (double ycut) const {return n_exclusive_jets(ycut*Q2());}
-
- /// the exclusive jets obtained at the given ycut
- std::vector<PseudoJet> exclusive_jets_ycut (double ycut) const {
- int njets = n_exclusive_jets_ycut(ycut);
- return exclusive_jets(njets);
- }
-
-
- //int n_exclusive_jets (const PseudoJet & jet, const double & dcut) const;
-
- /// return a vector of all subjets of the current jet (in the sense
- /// of the exclusive algorithm) that would be obtained when running
- /// the algorithm with the given dcut.
- ///
- /// Time taken is O(m ln m), where m is the number of subjets that
- /// are found. If m gets to be of order of the total number of
- /// constituents in the jet, this could be substantially slower than
- /// just getting that list of constituents.
- std::vector<PseudoJet> exclusive_subjets (const PseudoJet & jet,
- const double & dcut) const;
-
- /// return the size of exclusive_subjets(...); still n ln n with same
- /// coefficient, but marginally more efficient than manually taking
- /// exclusive_subjets.size()
- int n_exclusive_subjets(const PseudoJet & jet,
- const double & dcut) const;
-
- /// return the list of subjets obtained by unclustering the supplied
- /// jet down to n subjets (or all constituents if there are fewer
- /// than n).
- ///
- /// requires n ln n time
- std::vector<PseudoJet> exclusive_subjets (const PseudoJet & jet,
- int nsub) const;
-
- /// return the dij that was present in the merging nsub+1 -> nsub
- /// subjets inside this jet.
- double exclusive_subdmerge(const PseudoJet & jet, int nsub) const;
-
- /// return the maximum dij that occurred in the whole event at the
- /// stage that the nsub+1 -> nsub merge of subjets occurred inside
- /// this jet.
- double exclusive_subdmerge_max(const PseudoJet & jet, int nsub) const;
-
- //std::vector<PseudoJet> exclusive_jets (const PseudoJet & jet,
- // const int & njets) const;
- //double exclusive_dmerge (const PseudoJet & jet, const int & njets) const;
-
- /// returns the sum of all energies in the event (relevant mainly for e+e-)
- double Q() const {return _Q;}
- /// return Q()^2
- double Q2() const {return _Q*_Q;}
-
- /// returns true iff the object is included in the jet.
- ///
- /// NB: this is only sensible if the object is already registered
- /// within the cluster sequence, so you cannot use it with an input
- /// particle to the CS (since the particle won't have the history
- /// index set properly).
- ///
- /// For nice clustering structures it should run in O(ln(N)) time
- /// but in worst cases (certain cone plugins) it can take O(n) time,
- /// where n is the number of particles in the jet.
- bool object_in_jet(const PseudoJet & object, const PseudoJet & jet) const;
-
- /// if the jet has parents in the clustering, it returns true
- /// and sets parent1 and parent2 equal to them.
- ///
- /// if it has no parents it returns false and sets parent1 and
- /// parent2 to zero
- bool has_parents(const PseudoJet & jet, PseudoJet & parent1,
- PseudoJet & parent2) const;
-
- /// if the jet has a child then return true and give the child jet
- /// otherwise return false and set the child to zero
- bool has_child(const PseudoJet & jet, PseudoJet & child) const;
-
- /// Version of has_child that sets a pointer to the child if the child
- /// exists;
- bool has_child(const PseudoJet & jet, const PseudoJet * & childp) const;
-
- /// if this jet has a child (and so a partner) return true
- /// and give the partner, otherwise return false and set the
- /// partner to zero
- bool has_partner(const PseudoJet & jet, PseudoJet & partner) const;
-
-
- /// return a vector of the particles that make up jet
- std::vector<PseudoJet> constituents (const PseudoJet & jet) const;
-
-
- /// output the supplied vector of jets in a format that can be read
- /// by an appropriate root script; the format is:
- /// jet-n jet-px jet-py jet-pz jet-E
- /// particle-n particle-rap particle-phi particle-pt
- /// particle-n particle-rap particle-phi particle-pt
- /// ...
- /// #END
- /// ... [i.e. above repeated]
- void print_jets_for_root(const std::vector<PseudoJet> & jets,
- std::ostream & ostr = std::cout) const;
-
- /// print jets for root to the file labelled filename, with an
- /// optional comment at the beginning
- void print_jets_for_root(const std::vector<PseudoJet> & jets,
- const std::string & filename,
- const std::string & comment = "") const;
-
-// Not yet. Perhaps in a future release.
-// /// print out all inclusive jets with pt > ptmin
-// virtual void print_jets (const double & ptmin=0.0) const;
-
- /// add on to subjet_vector the constituents of jet (for internal use mainly)
- void add_constituents (const PseudoJet & jet,
- std::vector<PseudoJet> & subjet_vector) const;
-
- /// return the enum value of the strategy used to cluster the event
- inline Strategy strategy_used () const {return _strategy;}
- std::string strategy_string () const;
-
- /// return a reference to the jet definition
- const JetDefinition & jet_def() const {return _jet_def;}
-
- /// returns the scale associated with a jet as required for this
- /// clustering algorithm (kt^2 for the kt-algorithm, 1 for the
- /// Cambridge algorithm). [May become virtual at some point]
- double jet_scale_for_algorithm(const PseudoJet & jet) const;
-
- //----- next follow functions designed specifically for plugins, which
- // may only be called when plugin_activated() returns true
-
- /// record the fact that there has been a recombination between
- /// jets()[jet_i] and jets()[jet_k], with the specified dij, and
- /// return the index (newjet_k) allocated to the new jet, whose
- /// momentum is assumed to be the 4-vector sum of that of jet_i and
- /// jet_j
- void plugin_record_ij_recombination(int jet_i, int jet_j, double dij,
- int & newjet_k) {
- assert(plugin_activated());
- _do_ij_recombination_step(jet_i, jet_j, dij, newjet_k);
- }
-
- /// as for the simpler variant of plugin_record_ij_recombination,
- /// except that the new jet is attributed the momentum and
- /// user_index of newjet
- void plugin_record_ij_recombination(int jet_i, int jet_j, double dij,
- const PseudoJet & newjet,
- int & newjet_k);
-
- /// record the fact that there has been a recombination between
- /// jets()[jet_i] and the beam, with the specified diB; when looking
- /// for inclusive jets, any iB recombination will returned to the user
- /// as a jet.
- void plugin_record_iB_recombination(int jet_i, double diB) {
- assert(plugin_activated());
- _do_iB_recombination_step(jet_i, diB);
- }
-
- /// a class intended to serve as a base in case a plugin needs to
- /// associate extra information with a ClusterSequence (see
- /// SISConePlugin.* for an example).
- class Extras {
- public:
- virtual ~Extras() {}
- virtual std::string description() const {return "This is a dummy extras class that contains no extra information! Derive from it if you want to use it to provide extra information from a plugin jet finder";}
- };
-
- /// the plugin can associated some extra information with the
- /// ClusterSequence object by calling this function
- inline void plugin_associate_extras(std::auto_ptr<Extras> extras_in) {
- _extras = extras_in;
- }
-
- /// returns true when the plugin is allowed to run the show.
- inline bool plugin_activated() const {return _plugin_activated;}
-
- /// returns a pointer to the extras object (may be null)
- const Extras * extras() const {return _extras.get();}
-
- /// allows a plugin to run a templated clustering (nearest-neighbour heuristic)
- ///
- /// This has N^2 behaviour on "good" distance, but a worst case behaviour
- /// of N^3 (and many algs trigger the worst case behaviour)
- ///
- ///
- /// For more details on how this works, see GenBriefJet below
- template<class GBJ> void plugin_simple_N2_cluster () {
- assert(plugin_activated());
- _simple_N2_cluster<GBJ>();
- }
-
- //----------------------------------------------------------------------
- /// class to help with a generic clustering sequence
- class GenBriefJet {
- public:
- /// function that initialises the GenBriefJet given a PseudoJet.
- ///
- /// In a derived class, this member has a responsability to call
- ///
- /// - set_scale_squared
- /// - set_geom_iB
- ///
- /// The clustering will be performed by finding the minimum of
- ///
- /// diB = scale_squared[i] * geom_iB * _invR2
- /// dij = min(scale_squared[i],scale_squared[j]) * geom_ij * _invR2
- ///
- virtual void init(const PseudoJet & jet) = 0;
-
- /// Returns the "geometric" part of distance between this jet
- /// and jet_j
- virtual double geom_ij(const GenBriefJet * jet_j) const = 0;
-
- void set_scale_squared(double scale_squared) {kt2 = scale_squared;}
- void set_geom_iB(double diB) {NN_dist = diB; NN = NULL;}
-
- public: // formally public: but users should think of it as private!
- double NN_dist; // dij
- double kt2; // squared scale
- GenBriefJet * NN; // pointer to nearest neighbour
- int _jets_index; // index of this jet
- };
-
-
-public:
- /// set the default (static) jet finder across all current and future
- /// ClusterSequence objects -- deprecated and obsolescent (i.e. may be
- /// suppressed in a future release).
- static void set_jet_algorithm (JetAlgorithm jet_algorithm) {_default_jet_algorithm = jet_algorithm;}
- /// same as above for backward compatibility
- static void set_jet_finder (JetAlgorithm jet_algorithm) {_default_jet_algorithm = jet_algorithm;}
-
-
- /// a single element in the clustering history (see vector _history
- /// below).
- struct history_element{
- int parent1; /// index in _history where first parent of this jet
- /// was created (InexistentParent if this jet is an
- /// original particle)
-
- int parent2; /// index in _history where second parent of this jet
- /// was created (InexistentParent if this jet is an
- /// original particle); BeamJet if this history entry
- /// just labels the fact that the jet has recombined
- /// with the beam)
-
- int child; /// index in _history where the current jet is
- /// recombined with another jet to form its child. It
- /// is Invalid if this jet does not further
- /// recombine.
-
- int jetp_index; /// index in the _jets vector where we will find the
- /// PseudoJet object corresponding to this jet
- /// (i.e. the jet created at this entry of the
- /// history). NB: if this element of the history
- /// corresponds to a beam recombination, then
- /// jetp_index=Invalid.
-
- double dij; /// the distance corresponding to the recombination
- /// at this stage of the clustering.
-
- double max_dij_so_far; /// the largest recombination distance seen
- /// so far in the clustering history.
- };
-
- enum JetType {Invalid=-3, InexistentParent = -2, BeamJet = -1};
-
- /// allow the user to access the internally stored _jets() array,
- /// which contains both the initial particles and the various
- /// intermediate and final stages of recombination.
- ///
- /// The first n_particles() entries are the original particles,
- /// in the order in which they were supplied to the ClusterSequence
- /// constructor. It can be useful to access them for example when
- /// examining whether a given input object is part of a specific
- /// jet, via the objects_in_jet(...) member function (which only takes
- /// PseudoJets that are registered in the ClusterSequence).
- ///
- /// One of the other (internal uses) is related to the fact
- /// because we don't seem to be able to access protected elements of
- /// the class for an object that is not "this" (at least in case where
- /// "this" is of a slightly different kind from the object, both
- /// derived from ClusterSequence).
- const std::vector<PseudoJet> & jets() const;
-
- /// allow the user to access the raw internal history.
- ///
- /// This is present (as for jets()) in part so that protected
- /// derived classes can access this information about other
- /// ClusterSequences.
- ///
- /// A user who wishes to follow the details of the ClusterSequence
- /// can also make use of this information (and should consult the
- /// history_element documentation for more information), but should
- /// be aware that these internal structures may evolve in future
- /// FastJet versions.
- const std::vector<history_element> & history() const;
-
- /// returns the number of particles that were provided to the
- /// clustering algorithm (helps the user find their way around the
- /// history and jets objects if they weren't paying attention
- /// beforehand).
- unsigned int n_particles() const;
-
- /// returns a vector of size n_particles() which indicates, for
- /// each of the initial particles (in the order in which they were
- /// supplied), which of the supplied jets it belongs to; if it does
- /// not belong to any of the supplied jets, the index is set to -1;
- std::vector<int> particle_jet_indices(const std::vector<PseudoJet> &) const;
-
- /// routine that returns an order in which to read the history
- /// such that clusterings that lead to identical jet compositions
- /// but different histories (because of degeneracies in the
- /// clustering order) will have matching constituents for each
- /// matching entry in the unique_history_order.
- ///
- /// The order has the property that an entry's parents will always
- /// appear prior to that entry itself.
- ///
- /// Roughly speaking the order is such that we first provide all
- /// steps that lead to the final jet containing particle 1; then we
- /// have the steps that lead to reconstruction of the jet containing
- /// the next-lowest-numbered unclustered particle, etc...
- /// [see GPS CCN28-12 for more info -- of course a full explanation
- /// here would be better...]
- std::vector<int> unique_history_order() const;
-
- /// return the set of particles that have not been clustered. For
- /// kt and cam/aachen algorithms this should always be null, but for
- /// cone type algorithms it can be non-null;
- std::vector<PseudoJet> unclustered_particles() const;
-
- /// transfer the sequence contained in other_seq into our own;
- /// any plugin "extras" contained in the from_seq will be lost
- /// from there.
- void transfer_from_sequence(ClusterSequence & from_seq);
-
-
-protected:
- static JetAlgorithm _default_jet_algorithm;
- JetDefinition _jet_def;
-
- /// returns true if the jet has a history index contained within
- /// the range of this CS
- bool _potentially_valid(const PseudoJet & jet) const {
- return jet.cluster_hist_index() >= 0
- && jet.cluster_hist_index() < int(_history.size());
- }
-
- /// transfer the vector<L> of input jets into our own vector<PseudoJet>
- /// _jets (with some reserved space for future growth).
- template<class L> void _transfer_input_jets(
- const std::vector<L> & pseudojets);
-
- /// This is the routine that will do all the initialisation and
- /// then run the clustering (may be called by various constructors).
- /// It assumes _jets contains the momenta to be clustered.
- void _initialise_and_run (const JetDefinition & jet_def,
- const bool & writeout_combinations);
-
- /// This is an alternative routine for initialising and running the
- /// clustering, provided for legacy purposes. The jet finder is that
- /// specified in the static member _default_jet_algorithm.
- void _initialise_and_run (const double & R,
- const Strategy & strategy,
- const bool & writeout_combinations);
-
- /// fills in the various member variables with "decanted" options from
- /// the jet_definition and writeout_combinations variables
- void _decant_options(const JetDefinition & jet_def,
- const bool & writeout_combinations);
-
- /// fill out the history (and jet cross refs) related to the initial
- /// set of jets (assumed already to have been "transferred"),
- /// without any clustering
- void _fill_initial_history();
-
- /// carry out the recombination between the jets numbered jet_i and
- /// jet_j, at distance scale dij; return the index newjet_k of the
- /// result of the recombination of i and j.
- void _do_ij_recombination_step(const int & jet_i, const int & jet_j,
- const double & dij, int & newjet_k);
-
- /// carry out an recombination step in which _jets[jet_i] merges with
- /// the beam,
- void _do_iB_recombination_step(const int & jet_i, const double & diB);
-
-
- /// This contains the physical PseudoJets; for each PseudoJet one
- /// can find the corresponding position in the _history by looking
- /// at _jets[i].cluster_hist_index().
- std::vector<PseudoJet> _jets;
-
-
- /// this vector will contain the branching history; for each stage,
- /// _history[i].jetp_index indicates where to look in the _jets
- /// vector to get the physical PseudoJet.
- std::vector<history_element> _history;
-
- /// set subhist to be a set pointers to history entries corresponding to the
- /// subjets of this jet; one stops going working down through the
- /// subjets either when
- /// - there is no further to go
- /// - one has found maxjet entries
- /// - max_dij_so_far <= dcut
- /// By setting maxjet=0 one can use just dcut; by setting dcut<0
- /// one can use jet maxjet
- void get_subhist_set(std::set<const history_element*> & subhist,
- const PseudoJet & jet, double dcut, int maxjet) const;
-
- bool _writeout_combinations;
- int _initial_n;
- double _Rparam, _R2, _invR2;
- double _Q;
- Strategy _strategy;
- JetAlgorithm _jet_algorithm;
-
-
- private:
-
- bool _plugin_activated;
- std::auto_ptr<Extras> _extras; // things the plugin might want to add
-
- void _really_dumb_cluster ();
- void _delaunay_cluster ();
- //void _simple_N2_cluster ();
- template<class BJ> void _simple_N2_cluster ();
- void _tiled_N2_cluster ();
- void _faster_tiled_N2_cluster ();
-
- //
- void _minheap_faster_tiled_N2_cluster();
-
- // things needed specifically for Cambridge with Chan's 2D closest
- // pairs method
- void _CP2DChan_cluster();
- void _CP2DChan_cluster_2pi2R ();
- void _CP2DChan_cluster_2piMultD ();
- void _CP2DChan_limited_cluster(double D);
- void _do_Cambridge_inclusive_jets();
-
- void _add_step_to_history(const int & step_number, const int & parent1,
- const int & parent2, const int & jetp_index,
- const double & dij);
-
- /// internal routine associated with the construction of the unique
- /// history order (following children in the tree)
- void _extract_tree_children(int pos, std::valarray<bool> &,
- const std::valarray<int> &, std::vector<int> &) const;
-
- /// internal routine associated with the construction of the unique
- /// history order (following parents in the tree)
- void _extract_tree_parents (int pos, std::valarray<bool> &,
- const std::valarray<int> &, std::vector<int> &) const;
-
-
- // these will be useful shorthands in the Voronoi-based code
- typedef std::pair<int,int> TwoVertices;
- typedef std::pair<double,TwoVertices> DijEntry;
- typedef std::multimap<double,TwoVertices> DistMap;
-
- /// currently used only in the Voronoi based code
- void _add_ktdistance_to_map(const int & ii,
- DistMap & DijMap,
- const DynamicNearestNeighbours * DNN);
-
- /// for making sure the user knows what it is they're running...
- void _print_banner();
- /// will be set by default to be true for the first run
- static bool _first_time;
-
- /// record the number of warnings provided about the exclusive
- /// algorithm -- so that we don't print it out more than a few
- /// times.
- static int _n_exclusive_warnings;
-
- //----------------------------------------------------------------------
- /// the fundamental structure which contains the minimal info about
- /// a jet, as needed for our plain N^2 algorithm -- the idea is to
- /// put all info that will be accessed N^2 times into an array of
- /// BriefJets...
- struct BriefJet {
- double eta, phi, kt2, NN_dist;
- BriefJet * NN;
- int _jets_index;
- };
-
-
- /// structure analogous to BriefJet, but with the extra information
- /// needed for dealing with tiles
- class TiledJet {
- public:
- double eta, phi, kt2, NN_dist;
- TiledJet * NN, *previous, * next;
- int _jets_index, tile_index, diJ_posn;
- // routines that are useful in the minheap version of tiled
- // clustering ("misuse" the otherwise unused diJ_posn, so as
- // to indicate whether jets need to have their minheap entries
- // updated).
- inline void label_minheap_update_needed() {diJ_posn = 1;}
- inline void label_minheap_update_done() {diJ_posn = 0;}
- inline bool minheap_update_needed() const {return diJ_posn==1;}
- };
-
- //-- some of the functions that follow are templates and will work
- //as well for briefjet and tiled jets
-
- /// set the kinematic and labelling info for jeta so that it corresponds
- /// to _jets[_jets_index]
- template <class J> void _bj_set_jetinfo( J * const jet,
- const int _jets_index) const;
-
- /// "remove" this jet, which implies updating links of neighbours and
- /// perhaps modifying the tile structure
- void _bj_remove_from_tiles( TiledJet * const jet) const;
-
- /// return the distance between two BriefJet objects
- template <class J> double _bj_dist(const J * const jeta,
- const J * const jetb) const;
-
- // return the diJ (multiplied by _R2) for this jet assuming its NN
- // info is correct
- template <class J> double _bj_diJ(const J * const jeta) const;
-
- /// for testing purposes only: if in the range head--tail-1 there is a
- /// a jet which corresponds to hist_index in the history, then
- /// return a pointer to that jet; otherwise return tail.
- template <class J> inline J * _bj_of_hindex(
- const int hist_index,
- J * const head, J * const tail)
- const {
- J * res;
- for(res = head; res<tail; res++) {
- if (_jets[res->_jets_index].cluster_hist_index() == hist_index) {break;}
- }
- return res;
- }
-
-
- //-- remaining functions are different in various cases, so we
- // will use templates but are not sure if they're useful...
-
- /// updates (only towards smaller distances) the NN for jeta without checking
- /// whether in the process jeta itself might be a new NN of one of
- /// the jets being scanned -- span the range head to tail-1 with
- /// assumption that jeta is not contained in that range
- template <class J> void _bj_set_NN_nocross(J * const jeta,
- J * const head, const J * const tail) const;
-
- /// reset the NN for jeta and DO check whether in the process jeta
- /// itself might be a new NN of one of the jets being scanned --
- /// span the range head to tail-1 with assumption that jeta is not
- /// contained in that range
- template <class J> void _bj_set_NN_crosscheck(J * const jeta,
- J * const head, const J * const tail) const;
-
-
-
- /// number of neighbours that a tile will have (rectangular geometry
- /// gives 9 neighbours).
- static const int n_tile_neighbours = 9;
- //----------------------------------------------------------------------
- /// The fundamental structures to be used for the tiled N^2 algorithm
- /// (see CCN27-44 for some discussion of pattern of tiling)
- struct Tile {
- /// pointers to neighbouring tiles, including self
- Tile * begin_tiles[n_tile_neighbours];
- /// neighbouring tiles, excluding self
- Tile ** surrounding_tiles;
- /// half of neighbouring tiles, no self
- Tile ** RH_tiles;
- /// just beyond end of tiles
- Tile ** end_tiles;
- /// start of list of BriefJets contained in this tile
- TiledJet * head;
- /// sometimes useful to be able to tag a tile
- bool tagged;
- };
- std::vector<Tile> _tiles;
- double _tiles_eta_min, _tiles_eta_max;
- double _tile_size_eta, _tile_size_phi;
- int _n_tiles_phi,_tiles_ieta_min,_tiles_ieta_max;
-
- // reasonably robust return of tile index given ieta and iphi, in particular
- // it works even if iphi is negative
- inline int _tile_index (int ieta, int iphi) const {
- // note that (-1)%n = -1 so that we have to add _n_tiles_phi
- // before performing modulo operation
- return (ieta-_tiles_ieta_min)*_n_tiles_phi
- + (iphi+_n_tiles_phi) % _n_tiles_phi;
- }
-
- // routines for tiled case, including some overloads of the plain
- // BriefJet cases
- int _tile_index(const double & eta, const double & phi) const;
- void _tj_set_jetinfo ( TiledJet * const jet, const int _jets_index);
- void _bj_remove_from_tiles(TiledJet * const jet);
- void _initialise_tiles();
- void _print_tiles(TiledJet * briefjets ) const;
- void _add_neighbours_to_tile_union(const int tile_index,
- std::vector<int> & tile_union, int & n_near_tiles) const;
- void _add_untagged_neighbours_to_tile_union(const int tile_index,
- std::vector<int> & tile_union, int & n_near_tiles);
-
-
- //----------------------------------------------------------------------
- /// fundamental structure for e+e- clustering
- struct EEBriefJet {
- double NN_dist; // obligatorily present
- double kt2; // obligatorily present == E^2 in general
- EEBriefJet * NN; // must be present too
- int _jets_index; // must also be present!
- //...........................................................
- double nx, ny, nz; // our internal storage for fast distance calcs
- };
-
- /// to help instantiation
- void _dummy_N2_cluster_instantiation();
-
-};
-
-
-//**********************************************************************
-//************** START OF INLINE MATERIAL ******************
-//**********************************************************************
-
-
-//----------------------------------------------------------------------
-// Transfer the initial jets into our internal structure
-template<class L> void ClusterSequence::_transfer_input_jets(
- const std::vector<L> & pseudojets) {
-
- // this will ensure that we can point to jets without difficulties
- // arising.
- _jets.reserve(pseudojets.size()*2);
-
- // insert initial jets this way so that any type L that can be
- // converted to a pseudojet will work fine (basically PseudoJet
- // and any type that has [] subscript access to the momentum
- // components, such as CLHEP HepLorentzVector).
- for (unsigned int i = 0; i < pseudojets.size(); i++) {
- _jets.push_back(pseudojets[i]);}
-
-}
-
-//----------------------------------------------------------------------
-// initialise from some generic type... Has to be made available
-// here in order for it the template aspect of it to work...
-template<class L> ClusterSequence::ClusterSequence (
- const std::vector<L> & pseudojets,
- const double & R,
- const Strategy & strategy,
- const bool & writeout_combinations) {
-
- // transfer the initial jets (type L) into our own array
- _transfer_input_jets(pseudojets);
-
- // run the clustering
- _initialise_and_run(R,strategy,writeout_combinations);
-}
-
-
-//----------------------------------------------------------------------
-/// constructor of a jet-clustering sequence from a vector of
-/// four-momenta, with the jet definition specified by jet_def
-template<class L> ClusterSequence::ClusterSequence (
- const std::vector<L> & pseudojets,
- const JetDefinition & jet_def,
- const bool & writeout_combinations) {
-
- // transfer the initial jets (type L) into our own array
- _transfer_input_jets(pseudojets);
-
- // run the clustering
- _initialise_and_run(jet_def,writeout_combinations);
-}
-
-
-inline const std::vector<PseudoJet> & ClusterSequence::jets () const {
- return _jets;
-}
-
-inline const std::vector<ClusterSequence::history_element> & ClusterSequence::history () const {
- return _history;
-}
-
-inline unsigned int ClusterSequence::n_particles() const {return _initial_n;}
-
-
-
-//----------------------------------------------------------------------
-template <class J> inline void ClusterSequence::_bj_set_jetinfo(
- J * const jetA, const int _jets_index) const {
- jetA->eta = _jets[_jets_index].rap();
- jetA->phi = _jets[_jets_index].phi_02pi();
- jetA->kt2 = jet_scale_for_algorithm(_jets[_jets_index]);
- jetA->_jets_index = _jets_index;
- // initialise NN info as well
- jetA->NN_dist = _R2;
- jetA->NN = NULL;
-}
-
-
-
-
-//----------------------------------------------------------------------
-template <class J> inline double ClusterSequence::_bj_dist(
- const J * const jetA, const J * const jetB) const {
- double dphi = std::abs(jetA->phi - jetB->phi);
- double deta = (jetA->eta - jetB->eta);
- if (dphi > pi) {dphi = twopi - dphi;}
- return dphi*dphi + deta*deta;
-}
-
-//----------------------------------------------------------------------
-template <class J> inline double ClusterSequence::_bj_diJ(const J * const jet) const {
- double kt2 = jet->kt2;
- if (jet->NN != NULL) {if (jet->NN->kt2 < kt2) {kt2 = jet->NN->kt2;}}
- return jet->NN_dist * kt2;
-}
-
-
-//----------------------------------------------------------------------
-// set the NN for jet without checking whether in the process you might
-// have discovered a new nearest neighbour for another jet
-template <class J> inline void ClusterSequence::_bj_set_NN_nocross(
- J * const jet, J * const head, const J * const tail) const {
- double NN_dist = _R2;
- J * NN = NULL;
- if (head < jet) {
- for (J * jetB = head; jetB != jet; jetB++) {
- double dist = _bj_dist(jet,jetB);
- if (dist < NN_dist) {
- NN_dist = dist;
- NN = jetB;
- }
- }
- }
- if (tail > jet) {
- for (J * jetB = jet+1; jetB != tail; jetB++) {
- double dist = _bj_dist(jet,jetB);
- if (dist < NN_dist) {
- NN_dist = dist;
- NN = jetB;
- }
- }
- }
- jet->NN = NN;
- jet->NN_dist = NN_dist;
-}
-
-
-//----------------------------------------------------------------------
-template <class J> inline void ClusterSequence::_bj_set_NN_crosscheck(J * const jet,
- J * const head, const J * const tail) const {
- double NN_dist = _R2;
- J * NN = NULL;
- for (J * jetB = head; jetB != tail; jetB++) {
- double dist = _bj_dist(jet,jetB);
- if (dist < NN_dist) {
- NN_dist = dist;
- NN = jetB;
- }
- if (dist < jetB->NN_dist) {
- jetB->NN_dist = dist;
- jetB->NN = jet;
- }
- }
- jet->NN = NN;
- jet->NN_dist = NN_dist;
-}
-
-
-
-} // fastjet namespace
-
-#endif // __FASTJET_CLUSTERSEQUENCE_HH__
+++ /dev/null
-//STARTHEADER
-// $Id: ClusterSequence1GhostPassiveArea.hh 1134 2008-03-15 17:05:16Z salam $
-//
-// Copyright (c) 2005-2007, Matteo Cacciari, Gavin 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 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_CLUSTERSEQUENCE1GHOSTPASSIVEAREA_HH__
-#define __FASTJET_CLUSTERSEQUENCE1GHOSTPASSIVEAREA_HH__
-
-
-#include "fastjet/PseudoJet.hh"
-#include "fastjet/ClusterSequenceAreaBase.hh"
-#include "fastjet/ClusterSequenceActiveArea.hh"
-#include<iostream>
-#include<vector>
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-//using namespace std;
-
-/// 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...)
-class ClusterSequence1GhostPassiveArea : public ClusterSequenceActiveArea {
-public:
-
- ClusterSequence1GhostPassiveArea() {}
-
- /// constructor based on JetDefinition and 1GhostPassiveAreaSpec
- template<class L> ClusterSequence1GhostPassiveArea
- (const std::vector<L> & pseudojets,
- const JetDefinition & jet_def,
- const GhostedAreaSpec & area_spec,
- const bool & writeout_combinations = false) ;
-
- /// return an estimate for the number of empty jets -- one uses the
- /// AreaBase one rather than the ActiveArea one (which for which we
- /// do not have the information).
- virtual double n_empty_jets(const RangeDefinition & range) const {
- return ClusterSequenceAreaBase::n_empty_jets(range);
- }
-
-protected:
- /// does the initialisation and running specific to the passive
- /// areas class
- void _initialise_and_run_1GPA (const JetDefinition & jet_def,
- const GhostedAreaSpec & area_spec,
- const bool & writeout_combinations = false);
-
-private:
-
- void _run_1GPA(const GhostedAreaSpec & area_spec);
-};
-
-
-
-
-template<class L> ClusterSequence1GhostPassiveArea::ClusterSequence1GhostPassiveArea
-(const std::vector<L> & pseudojets,
- const JetDefinition & jet_def,
- const GhostedAreaSpec & area_spec,
- const bool & writeout_combinations) {
-
- // transfer the initial jets (type L) into our own array
- _transfer_input_jets(pseudojets);
-
- // run the clustering for passive areas
- _initialise_and_run_1GPA(jet_def, area_spec, writeout_combinations);
-
-}
-
-
-
-} // fastjet namespace
-
-#endif // __FASTJET_CLUSTERSEQUENCE1GHOSTPASSIVEAREA_HH__
+++ /dev/null
-//STARTHEADER
-// $Id: ClusterSequenceActiveArea.hh 1134 2008-03-15 17:05:16Z salam $
-//
-// 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_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"
-//--------------------------------------------------------------------
-
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-//using namespace std;
-
-/// 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...)
-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,
- const GhostedAreaSpec & area_spec,
- const bool & writeout_combinations = false) ;
-
- virtual double area (const PseudoJet & jet) const {
- return _average_area[jet.cluster_hist_index()];};
- virtual double area_error (const PseudoJet & jet) const {
- return _average_area2[jet.cluster_hist_index()];};
-
- virtual PseudoJet area_4vector (const PseudoJet & jet) const {
- 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.
- 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; use media_pt_per_unit_area from the
- // ClusterSequenceAreaBase class instead
- double pt_per_unit_area(mean_pt_strategies strat=median,
- double range=2.0 ) const;
-
- // following code removed -- now dealt with by AreaBase class (and
- // this definition here conflicts with it).
-// /// fits a form pt_per_unit_area(y) = a + b*y^2 in the range
-// /// abs(y)<raprange (for negative raprange, it defaults to
-// /// _safe_rap_for_area).
-// void parabolic_pt_per_unit_area(double & a,double & b, double raprange=-1.0,
-// double exclude_above=-1.0,
-// bool use_area_4vector=false ) const;
-//
- /// rewrite the empty area from the parent class, so as to use
- /// all info at our disposal
- /// return the total area, in the given y-phi range, that consists of ghost
- /// jets or unclustered ghosts
- virtual double empty_area(const RangeDefinition & range) const;
-
- /// return the true number of empty jets (replaces
- /// ClusterSequenceAreaBase::n_empty_jets(...))
- virtual double n_empty_jets(const RangeDefinition & range) const;
-
-protected:
- void _resize_and_zero_AA ();
- void _initialise_AA(const JetDefinition & jet_def,
- const GhostedAreaSpec & area_spec,
- const bool & writeout_combinations,
- bool & continue_running);
-
- void _run_AA(const GhostedAreaSpec & area_spec);
-
- void _postprocess_AA(const GhostedAreaSpec & area_spec);
-
- /// does the initialisation and running specific to the active
- /// areas class
- void _initialise_and_run_AA (const JetDefinition & jet_def,
- const GhostedAreaSpec & area_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 _area_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,
- const GhostedAreaSpec & area_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, area_spec, writeout_combinations);
-
-}
-
-
-
-} // fastjet namespace
-
-#endif // __FASTJET_CLUSTERSEQUENCEACTIVEAREA_HH__
+++ /dev/null
-//STARTHEADER
-// $Id: ClusterSequenceActiveAreaExplicitGhosts.hh 1303 2008-10-29 16:42:09Z salam $
-//
-// 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_CLUSTERSEQUENCEACTIVEAREAEXPLICITGHOSTS_HH_
-#define __FASTJET_CLUSTERSEQUENCEACTIVEAREAEXPLICITGHOSTS_HH_
-
-#include "fastjet/PseudoJet.hh"
-#include "fastjet/ClusterSequenceAreaBase.hh"
-#include "fastjet/GhostedAreaSpec.hh"
-#include "fastjet/internal/LimitedWarning.hh"
-#include<iostream>
-#include<vector>
-#include <stdio.h>
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-//======================================================================
-/// 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...)
-class ClusterSequenceActiveAreaExplicitGhosts :
- public ClusterSequenceAreaBase {
-public:
- /// constructor using a GhostedAreaSpec to specify how the area is
- /// to be measured
- template<class L> ClusterSequenceActiveAreaExplicitGhosts
- (const std::vector<L> & pseudojets,
- const JetDefinition & jet_def,
- const GhostedAreaSpec & area_spec,
- const bool & writeout_combinations = false)
- : ClusterSequenceAreaBase() {
- std::vector<L> * ghosts = NULL;
- _initialise(pseudojets,jet_def,&area_spec,ghosts,0.0,
- writeout_combinations); }
-
- template<class L> ClusterSequenceActiveAreaExplicitGhosts
- (const std::vector<L> & pseudojets,
- const JetDefinition & jet_def,
- const std::vector<L> & ghosts,
- double ghost_area,
- const bool & writeout_combinations = false)
- : ClusterSequenceAreaBase() {
- const GhostedAreaSpec * area_spec = NULL;
- _initialise(pseudojets,jet_def,area_spec,&ghosts,ghost_area,
- writeout_combinations); }
-
-
- /// does the actual work of initialisation
- template<class L> void _initialise
- (const std::vector<L> & pseudojets,
- const JetDefinition & jet_def,
- const GhostedAreaSpec * area_spec,
- const std::vector<L> * ghosts,
- double ghost_area,
- const bool & writeout_combinations);
-
- //vector<PseudoJet> constituents (const PseudoJet & jet) const;
-
- /// returns the number of hard particles (i.e. those supplied by the user).
- unsigned int n_hard_particles() const;
-
- /// returns the area of a jet
- virtual double area (const PseudoJet & jet) const;
-
- /// returns a four vector corresponding to the sum (E-scheme) of the
- /// ghost four-vectors composing the jet area, normalised such that
- /// for a small contiguous area the p_t of the extended_area jet is
- /// equal to area of the jet.
- virtual PseudoJet area_4vector (const PseudoJet & jet) const;
-
- /// true if a jet is made exclusively of ghosts
- virtual bool is_pure_ghost(const PseudoJet & jet) const;
-
- /// true if the entry in the history index corresponds to a
- /// ghost; if hist_ix does not correspond to an actual particle
- /// (i.e. hist_ix < 0), then the result is false.
- bool is_pure_ghost(int history_index) const;
-
- /// this class does have explicit ghosts
- virtual bool has_explicit_ghosts() const {return true;}
-
- /// return the total area, up to |y|<maxrap, that consists of
- /// unclustered ghosts
- virtual double empty_area(const RangeDefinition & range) const;
-
- /// returns the total area under study
- double total_area () const;
-
- /// returns the largest squared transverse momentum among
- /// all ghosts
- double max_ghost_perp2() const {return _max_ghost_perp2;}
-
- /// 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:
-
- int _n_ghosts;
- double _ghost_area;
- std::vector<bool> _is_pure_ghost;
- std::vector<double> _areas;
- std::vector<PseudoJet> _area_4vectors;
-
- // things related to checks for dangerous particles
- double _max_ghost_perp2;
- bool _has_dangerous_particles;
- static LimitedWarning _warnings;
-
- //static int _n_warn_dangerous_particles;
- //static const int _max_warn_dangerous_particles = 5;
-
-
- unsigned int _initial_hard_n;
-
- /// adds the "ghost" momenta, which will be used to estimate
- /// the jet area
- void _add_ghosts(const GhostedAreaSpec & area_spec);
-
- /// another way of adding ghosts
- template<class L> void _add_ghosts (
- const std::vector<L> & ghosts,
- double ghost_area);
-
- /// routine to be called after the processing is done so as to
- /// establish summary information on all the jets (areas, whether
- /// pure ghost, etc.)
- void _post_process();
-
-};
-
-
-//----------------------------------------------------------------------
-// initialise from some generic type... Has to be made available
-// here in order for the template aspect of it to work...
-template<class L> void ClusterSequenceActiveAreaExplicitGhosts::_initialise
- (const std::vector<L> & pseudojets,
- const JetDefinition & jet_def,
- const GhostedAreaSpec * area_spec,
- const std::vector<L> * ghosts,
- double ghost_area,
- const bool & writeout_combinations) {
- // don't reserve space yet -- will be done below
-
- // insert initial jets this way so that any type L that can be
- // converted to a pseudojet will work fine (basically PseudoJet
- // and any type that has [] subscript access to the momentum
- // components, such as CLHEP HepLorentzVector).
- for (unsigned int i = 0; i < pseudojets.size(); i++) {
- PseudoJet mom(pseudojets[i]);
- //mom.set_user_index(0); // for user's particles (user index now lost...)
- _jets.push_back(mom);
- _is_pure_ghost.push_back(false);
- }
-
- _initial_hard_n = _jets.size();
-
- if (area_spec != NULL) {
- _add_ghosts(*area_spec);
- } else {
- _add_ghosts(*ghosts, ghost_area);
- }
-
- if (writeout_combinations) {
- std::cout << "# Printing particles including ghosts\n";
- for (unsigned j = 0; j < _jets.size(); j++) {
- printf("%5u %20.13f %20.13f %20.13e\n",
- j,_jets[j].rap(),_jets[j].phi_02pi(),_jets[j].kt2());
- }
- std::cout << "# Finished printing particles including ghosts\n";
- }
-
- // this will ensure that we can still point to jets without
- // difficulties arising!
- _jets.reserve(_jets.size()*2);
-
- // run the clustering
- _initialise_and_run(jet_def,writeout_combinations);
-
- // set up all other information
- _post_process();
-}
-
-
-inline unsigned int ClusterSequenceActiveAreaExplicitGhosts::n_hard_particles() const {return _initial_hard_n;}
-
-
-//----------------------------------------------------------------------
-/// add an explicitly specified bunch of ghosts
-template<class L> void ClusterSequenceActiveAreaExplicitGhosts::_add_ghosts (
- const std::vector<L> & ghosts,
- double ghost_area) {
-
-
- for (unsigned i = 0; i < ghosts.size(); i++) {
- _is_pure_ghost.push_back(true);
- _jets.push_back(ghosts[i]);
- }
- // and record some info about ghosts
- _ghost_area = ghost_area;
- _n_ghosts = ghosts.size();
-}
-
-
-} // fastjet namespace
-
-#endif // __FASTJET_CLUSTERSEQUENCEACTIVEAREAEXPLICITGHOSTS_HH_
+++ /dev/null
-//STARTHEADER
-// $Id: ClusterSequenceArea.hh 1303 2008-10-29 16:42:09Z salam $
-//
-// Copyright (c) 2006-2007, Matteo Cacciari, Gavin 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 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_CLUSTERSEQUENCEAREA_HH__
-#define __FASTJET_CLUSTERSEQUENCEAREA_HH__
-
-#include "fastjet/ClusterSequenceAreaBase.hh"
-#include "fastjet/ClusterSequenceActiveArea.hh"
-#include "fastjet/ClusterSequenceActiveAreaExplicitGhosts.hh"
-#include "fastjet/ClusterSequencePassiveArea.hh"
-#include "fastjet/ClusterSequenceVoronoiArea.hh"
-#include "fastjet/AreaDefinition.hh"
-
-namespace fastjet {
-
-/// General class for user to obtain ClusterSequence with additional
-/// area information.
-///
-/// Based on the area_def, it automatically dispatches the work to the
-/// appropriate actual ClusterSequenceAreaBase-derived-class to do the
-/// real work.
-class ClusterSequenceArea : public ClusterSequenceAreaBase {
-public:
- /// main constructor
- template<class L> ClusterSequenceArea
- (const std::vector<L> & pseudojets,
- const JetDefinition & jet_def,
- const AreaDefinition & area_def_in) : _area_def(area_def_in) {
- initialize_and_run_cswa(pseudojets, jet_def);
- }
-
- /// constructor with a GhostedAreaSpec
- template<class L> ClusterSequenceArea
- (const std::vector<L> & pseudojets,
- const JetDefinition & jet_def,
- const GhostedAreaSpec & area_spec) : _area_def(area_spec){
- initialize_and_run_cswa(pseudojets, jet_def);
- }
-
- /// constructor with a VoronoiAreaSpec
- template<class L> ClusterSequenceArea
- (const std::vector<L> & pseudojets,
- const JetDefinition & jet_def,
- const VoronoiAreaSpec & area_spec) : _area_def(area_spec){
- initialize_and_run_cswa(pseudojets, jet_def);
- }
-
- /// return a reference to the area definition
- const AreaDefinition & area_def() const {return _area_def;}
-
-
- /// return the area associated with the given jet
- virtual double area (const PseudoJet & jet) const {
- return _area_base->area(jet);}
-
- /// return the error (uncertainty) associated with the determination
- /// of the area of this jet
- virtual double area_error (const PseudoJet & jet) const {
- return _area_base->area_error(jet);}
-
- /// return the 4-vector area
- virtual PseudoJet area_4vector(const PseudoJet & jet) const {
- return _area_base->area_4vector(jet);}
-
- // /// return the total area, up to |y|<maxrap, that is free of jets
- // virtual double empty_area(double maxrap) const {
- // return _area_base->empty_area(maxrap);}
- //
- // /// return something similar to the number of pure ghost jets
- // /// in the given rapidity range in an active area case.
- // /// For the local implementation we return empty_area/(0.55 pi R^2),
- // /// based on measured properties of ghost jets with kt and cam. Note
- // /// that the number returned is a double.
- // virtual double n_empty_jets(double maxrap) const {
- // return _area_base->n_empty_jets(maxrap);
-
- /// return the total area, in the given rap-phi range, that is free of jets
- virtual double empty_area(const RangeDefinition & range) const {
- return _area_base->empty_area(range);}
-
- /// return something similar to the number of pure ghost jets
- /// in the given rap-phi range in an active area case.
- /// For the local implementation we return empty_area/(0.55 pi R^2),
- /// based on measured properties of ghost jets with kt and cam. Note
- /// that the number returned is a double.
- virtual double n_empty_jets(const RangeDefinition & range) const {
- return _area_base->n_empty_jets(range);
- }
-
- /// true if a jet is made exclusively of ghosts
- virtual bool is_pure_ghost(const PseudoJet & jet) const {
- return _area_base->is_pure_ghost(jet);
- }
-
- /// true if this ClusterSequence has explicit ghosts
- virtual bool has_explicit_ghosts() const {
- return _area_base->has_explicit_ghosts();
- }
-
-
- /// overload version of what's in the ClusterSequenceAreaBase class, which
- /// additionally checks compatibility between "range" and region in which
- /// ghosts are thrown.
- 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_incl = false) const {
- _warn_if_range_unsuitable(range);
- ClusterSequenceAreaBase::get_median_rho_and_sigma(
- all_jets, range, use_area_4vector,
- median, sigma, mean_area, all_are_incl);
- }
-
- /// overload version of what's in the ClusterSequenceAreaBase class,
- /// which actually just does the same thing as the base version (but
- /// since we've overridden the 5-argument version above, we have to
- /// override the 4-argument version too.
- virtual void get_median_rho_and_sigma(const RangeDefinition & range,
- bool use_area_4vector,
- double & median, double & sigma) const {
- ClusterSequenceAreaBase::get_median_rho_and_sigma(range,use_area_4vector,
- median,sigma);
- }
-
- /// overload version of what's in the ClusterSequenceAreaBase class,
- /// which actually just does the same thing as the base version (but
- /// since we've overridden the multi-argument version above, we have to
- /// override the 5-argument version too.
- virtual void get_median_rho_and_sigma(const RangeDefinition & range,
- bool use_area_4vector,
- double & median, double & sigma,
- double & mean_area) const {
- ClusterSequenceAreaBase::get_median_rho_and_sigma(range,use_area_4vector,
- median,sigma, mean_area);
- }
-
-
- /// overload version of what's in the ClusterSequenceAreaBase class, which
- /// additionally checks compatibility between "range" and region in which
- /// ghosts are thrown.
- 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 {
- _warn_if_range_unsuitable(range);
- ClusterSequenceAreaBase::parabolic_pt_per_unit_area(
- a,b,range, exclude_above, use_area_4vector);
- }
-
-
-private:
-
- /// print a warning if the range is unsuitable for the current
- /// calculation of the area (e.g. because ghosts do not extend
- /// far enough).
- void _warn_if_range_unsuitable(const RangeDefinition & range) const;
-
- template<class L> void initialize_and_run_cswa (
- const std::vector<L> & pseudojets,
- const JetDefinition & jet_def);
-
- std::auto_ptr<ClusterSequenceAreaBase> _area_base;
- AreaDefinition _area_def;
- static LimitedWarning _range_warnings;
-
-};
-
-//----------------------------------------------------------------------
-template<class L> void ClusterSequenceArea::initialize_and_run_cswa(
- const std::vector<L> & pseudojets,
- const JetDefinition & jet_def)
- {
-
- ClusterSequenceAreaBase * _area_base_ptr;
- switch(_area_def.area_type()) {
- case active_area:
- _area_base_ptr = new ClusterSequenceActiveArea(pseudojets,
- jet_def,
- _area_def.ghost_spec());
- break;
- case active_area_explicit_ghosts:
- _area_base_ptr = new ClusterSequenceActiveAreaExplicitGhosts(pseudojets,
- jet_def,
- _area_def.ghost_spec());
- break;
- case voronoi_area:
- _area_base_ptr = new ClusterSequenceVoronoiArea(pseudojets,
- jet_def,
- _area_def.voronoi_spec());
- break;
- case one_ghost_passive_area:
- _area_base_ptr = new ClusterSequence1GhostPassiveArea(pseudojets,
- jet_def,
- _area_def.ghost_spec());
- break;
- case passive_area:
- _area_base_ptr = new ClusterSequencePassiveArea(pseudojets,
- jet_def,
- _area_def.ghost_spec());
- break;
- default:
- std::cerr << "Error: unrecognized area_type in ClusterSequenceArea:"
- << _area_def.area_type() << std::endl;
- exit(-1);
- }
- // now copy across the information from the area base class
- _area_base = std::auto_ptr<ClusterSequenceAreaBase>(_area_base_ptr);
- transfer_from_sequence(*_area_base);
-}
-
-} // fastjet namespace
-
-#endif // __FASTJET_CLUSTERSEQUENCEAREA_HH__
-
-
+++ /dev/null
-//STARTHEADER
-// $Id: ClusterSequenceAreaBase.hh 1503 2009-04-06 11:32:52Z salam $
-//
-// 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"
-
-namespace fastjet {
-
-/// base class that sets interface for extensions of ClusterSequence
-/// that provide information about the area of each jet;
-///
-/// the virtual functions here all return 0, since no area determination
-/// is implemented.
-class ClusterSequenceAreaBase : public ClusterSequence {
-public:
-
- /// a constructor which just carries out the construction of the
- /// parent class
- template<class L> ClusterSequenceAreaBase
- (const std::vector<L> & pseudojets,
- const JetDefinition & jet_def,
- const bool & writeout_combinations = false) :
- ClusterSequence(pseudojets, jet_def, writeout_combinations) {}
-
-
- /// default constructor
- ClusterSequenceAreaBase() {}
-
-
- /// destructor
- virtual ~ClusterSequenceAreaBase() {}
-
-
- /// return the area associated with the given jet; this base class
- /// returns 0.
- virtual double area (const PseudoJet & jet) const {return 0.0;}
-
- /// return the error (uncertainty) associated with the determination
- /// of the area of this jet; this base class returns 0.
- virtual double area_error (const PseudoJet & jet) const {return 0.0;}
-
- /// return a PseudoJet whose 4-vector is defined by the following integral
- ///
- /// \int drap d\phi PseudoJet("rap,phi,pt=one") *
- /// * Theta("rap,phi inside jet boundary")
- ///
- /// where PseudoJet("rap,phi,pt=one") is a 4-vector with the given
- /// rapidity (rap), azimuth (phi) and pt=1, while Theta("rap,phi
- /// inside jet boundary") is a function that is 1 when rap,phi
- /// define a direction inside the jet boundary and 0 otherwise.
- ///
- /// This base class returns a null 4-vector.
- virtual PseudoJet area_4vector(const PseudoJet & jet) const {
- return PseudoJet(0.0,0.0,0.0,0.0);}
-
- /// true if a jet is made exclusively of ghosts
- ///
- /// NB: most area classes do not give any explicit ghost jets, but
- /// some do, and they should replace this function with their own
- /// version.
- virtual bool is_pure_ghost(const PseudoJet & jet) const {
- return false;
- }
-
- /// returns true if ghosts are explicitly included within
- /// jets for this ClusterSequence;
- ///
- /// Derived classes that do include explicit ghosts should provide
- /// an alternative version of this routine and set it properly.
- virtual bool has_explicit_ghosts() const {
- return false;
- }
-
- /// return the total area, within range, that is free of jets, in
- /// general based on the inclusive jets
- virtual double empty_area(const RangeDefinition & range) const;
-
- /// return the total area, within range, that is free of jets, based
- /// on the supplied all_jets
- double empty_area_from_jets(const std::vector<PseudoJet> & all_jets,
- const RangeDefinition & range) const;
-
- /// return something similar to the number of pure ghost jets
- /// in the given range in an active area case.
- /// For the local implementation we return empty_area/(0.55 pi R^2),
- /// based on measured properties of ghost jets with kt and cam. Note
- /// that the number returned is a double.
- virtual double n_empty_jets(const RangeDefinition & range) const {
- double R = jet_def().R();
- return empty_area(range)/(0.55*pi*R*R);
- }
-
- /// the median of (pt/area) for jets contained within range,
- /// making use also of the info on n_empty_jets
- double median_pt_per_unit_area(const RangeDefinition & range) const;
-
- /// the median of (pt/area_4vector) for jets contained within
- /// making use also of the info on n_empty_jets
- double median_pt_per_unit_area_4vector(const RangeDefinition & range) const;
-
- /// the function that does the work for median_pt_per_unit_area and
- /// median_pt_per_unit_area_4vector:
- /// - something_is_area_4vect = false -> use plain area
- /// - something_is_area_4vect = true -> use 4-vector area
- double median_pt_per_unit_something(
- const RangeDefinition & range, bool use_area_4vector) const;
-
- /// using jets withing range (and with 4-vector areas if
- /// use_area_4vector), calculate the median pt/area, as well as an
- /// "error" (uncertainty), which is defined as the 1-sigma
- /// half-width of the distribution of pt/A, obtained by looking for
- /// the point below which we have (1-0.6827)/2 of the jets
- /// (including empty jets).
- ///
- /// The subtraction for a jet with uncorrected pt pt^U and area A is
- ///
- /// pt^S = pt^U - median*A +- sigma*sqrt(A)
- ///
- /// where the error is only that associated with the fluctuations
- /// in the noise and not that associated with the noise having
- /// caused changes in the hard-particle content of the jet.
- ///
- /// NB: subtraction may also be done with 4-vector area of course,
- /// and this is recommended for jets with larger values of R, as
- /// long as rho has also been determined with a 4-vector area;
- /// using a scalar area causes one to neglect terms of relative
- /// order $R^2/8$ in the jet $p_t$.
- virtual void get_median_rho_and_sigma(const RangeDefinition & range,
- bool use_area_4vector,
- double & median, double & sigma,
- double & mean_area) const;
-
- /// a more advanced version of get_median_rho_and_sigma, which allows
- /// one to use any "view" of the event containing all jets (so that,
- /// e.g. one might use Cam on a different resolution scale without
- /// have to rerun the algorithm).
- ///
- /// By default it will assume that "all" are not inclusive jets,
- /// so that in dealing with empty area it has to calculate
- /// the number of empty jets based on the empty area and the
- /// the observed <area> of jets rather than a surmised area
- ///
- /// Note that for small effective radii, this can cause problems
- /// because the harder jets get an area >> <ghost-jet-area>
- /// and so the estimate comes out all wrong. In these situations
- /// it is highly advisable to use an area with explicit ghosts, since
- /// then the "empty" jets are actually visible.
- 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;
-
- /// same as the full version of get_median_rho_and_error, but without
- /// access to the mean_area
- 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);
- }
-
-
- /// fits a form pt_per_unit_area(y) = a + b*y^2 in the range "range".
- /// exclude_above allows one to exclude large values of pt/area from fit.
- /// (if negative, the cut is discarded)
- /// use_area_4vector = true uses the 4vector areas.
- 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;
-
- /// return a vector of all subtracted jets, using area_4vector, given rho.
- /// Only inclusive_jets above ptmin are subtracted and returned.
- /// the ordering is the same as that of sorted_by_pt(cs.inclusive_jets()),
- /// i.e. not necessarily ordered in pt once subtracted
- std::vector<PseudoJet> subtracted_jets(const double rho,
- const double ptmin=0.0) const;
-
- /// return a vector of subtracted jets, using area_4vector.
- /// Only inclusive_jets above ptmin are subtracted and returned.
- /// the ordering is the same as that of sorted_by_pt(cs.inclusive_jets()),
- /// i.e. not necessarily ordered in pt once subtracted
- std::vector<PseudoJet> subtracted_jets(const RangeDefinition & range,
- const double ptmin=0.0) const;
-
- /// return a subtracted jet, using area_4vector, given rho
- PseudoJet subtracted_jet(const PseudoJet & jet,
- const double rho) const;
-
- /// return a subtracted jet, using area_4vector; note
- /// that this is potentially inefficient if repeatedly used for many
- /// different jets, because rho will be recalculated each time
- /// around.
- PseudoJet subtracted_jet(const PseudoJet & jet,
- const RangeDefinition & range) const;
-
- /// return the subtracted pt, given rho
- double subtracted_pt(const PseudoJet & jet,
- const double rho,
- bool use_area_4vector=false) const;
-
- /// return the subtracted pt; note that this is
- /// potentially inefficient if repeatedly used for many different
- /// jets, because rho will be recalculated each time around.
- double subtracted_pt(const PseudoJet & jet,
- const RangeDefinition & range,
- bool use_area_4vector=false) const;
-
-
-private:
- /// handle warning messages
- static LimitedWarning _warnings;
-
- /// check the jet algorithm is suitable (and if not issue a warning)
- void _check_jet_alg_good_for_median() const;
-
-};
-
-
-
-} // fastjet namespace
-
-#endif // __FASTJET_CLUSTERSEQUENCEAREABASE_HH__
+++ /dev/null
-//STARTHEADER
-// $Id: ClusterSequencePassiveArea.hh 1134 2008-03-15 17:05:16Z salam $
-//
-// Copyright (c) 2005-2007, Matteo Cacciari, Gavin 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 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_CLUSTERSEQUENCEPASSIVEAREA_HH__
-#define __FASTJET_CLUSTERSEQUENCEPASSIVEAREA_HH__
-
-
-#include "fastjet/PseudoJet.hh"
-#include "fastjet/ClusterSequence1GhostPassiveArea.hh"
-#include<iostream>
-#include<vector>
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-//using namespace std;
-
-/// 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...)
-class ClusterSequencePassiveArea : public ClusterSequence1GhostPassiveArea {
-public:
-
- /// constructor based on JetDefinition and PassiveAreaSpec
- template<class L> ClusterSequencePassiveArea
- (const std::vector<L> & pseudojets,
- const JetDefinition & jet_def,
- const GhostedAreaSpec & area_spec,
- const bool & writeout_combinations = false) ;
-
- /// return an empty area that's appropriate to the passive area
- /// determination carried out
- virtual double empty_area(const RangeDefinition & range) const;
-
-private:
-
- /// does the initialisation and running specific to the passive
- /// areas class
- void _initialise_and_run_PA (const JetDefinition & jet_def,
- const GhostedAreaSpec & area_spec,
- const bool & writeout_combinations = false);
-
-};
-
-
-
-
-template<class L> ClusterSequencePassiveArea::ClusterSequencePassiveArea
-(const std::vector<L> & pseudojets,
- const JetDefinition & jet_def,
- const GhostedAreaSpec & area_spec,
- const bool & writeout_combinations) {
-
- // transfer the initial jets (type L) into our own array
- _transfer_input_jets(pseudojets);
-
- // run the clustering for passive areas
- _initialise_and_run_PA(jet_def, area_spec, writeout_combinations);
-
-}
-
-
-
-} // fastjet namespace
-
-#endif // __FASTJET_CLUSTERSEQUENCEPASSIVEAREA_HH__
+++ /dev/null
-//STARTHEADER
-// $Id: ClusterSequenceVoronoiArea.hh 621 2007-05-09 10:34:30Z salam $
-//
-// Copyright (c) 2005-2007, Matteo Cacciari, Gavin 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 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_CLUSTERSEQUENCEVORONOIAREA_HH__
-#define __FASTJET_CLUSTERSEQUENCEVORONOIAREA_HH__
-
-#include "fastjet/PseudoJet.hh"
-#include "fastjet/AreaDefinition.hh"
-#include "fastjet/ClusterSequenceAreaBase.hh"
-#include <memory>
-#include <vector>
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-/**
- * \class ClusterSequenceVoronoiArea
- * Handle the computation of Voronoi jet area.
- */
-class ClusterSequenceVoronoiArea : public ClusterSequenceAreaBase {
-public:
- /// template ctor
- /// \param pseudojet list of jets (template type)
- /// \param jet_def jet definition
- /// \param effective_Rfact effective radius
- /// \param writeout_combinations ??????
- template<class L> ClusterSequenceVoronoiArea
- (const std::vector<L> & pseudojets,
- const JetDefinition & jet_def,
- const VoronoiAreaSpec & spec = VoronoiAreaSpec(),
- const bool & writeout_combinations = false);
-
- /// default dtor
- ~ClusterSequenceVoronoiArea();
-
- /// return the area associated with the given jet
- virtual inline double area(const PseudoJet & jet) const {
- return _voronoi_area[jet.cluster_hist_index()];};
-
- /// return a 4-vector area associated with the given jet -- stricly
- /// this is not the exact 4-vector area, but rather an approximation
- /// made of sums of centres of all Voronoi cells in jet, each
- /// contributing with a normalisation equal to the area of the cell
- virtual inline PseudoJet area_4vector(const PseudoJet & jet) const {
- return _voronoi_area_4vector[jet.cluster_hist_index()];};
-
- /// return the error of the area associated with the given jet
- /// (0 by definition for a voronoi area)
- virtual inline double area_error(const PseudoJet & jet) const {
- return 0.0;};
-
- /// passive area calculator -- to be defined in the .cc file (it will do
- /// the true hard work)
- class VoronoiAreaCalc;
-
-
-private:
- /// initialisation of the Voronoi Area
- void _initializeVA();
-
- std::vector<double> _voronoi_area; ///< vector containing the result
- std::vector<PseudoJet> _voronoi_area_4vector; ///< vector containing approx 4-vect areas
- VoronoiAreaCalc *_pa_calc; ///< area calculator
- double _effective_Rfact; ///< effective radius
-};
-
-
-
-
-/// template constructor need to be specified in the header!
-//----------------------------------------------------------------------
-template<class L> ClusterSequenceVoronoiArea::ClusterSequenceVoronoiArea
-(const std::vector<L> &pseudojets,
- const JetDefinition &jet_def,
- const VoronoiAreaSpec & spec,
- const bool & writeout_combinations) :
- _effective_Rfact(spec.effective_Rfact()) {
-
- // transfer the initial jets (type L) into our own array
- _transfer_input_jets(pseudojets);
-
- // run the clustering
- _initialise_and_run(jet_def,writeout_combinations);
-
- // the jet clustering's already been done, now worry about areas...
- _initializeVA();
-}
-
-} // fastjet namespace
-
-#endif // __FASTJET_CLUSTERSEQUENCEVORONOIAREA_HH__
+++ /dev/null
-//STARTHEADER
-// $Id: ClusterSequenceWithArea.hh 699 2007-06-04 20:20:42Z salam $
-//
-// Copyright (c) 2006-2007, Matteo Cacciari, Gavin 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 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_CLUSTERSEQUENCEWITHAREA_HH__
-#define __FASTJET_CLUSTERSEQUENCEWITHAREA_HH__
-
-#include "fastjet/ClusterSequenceAreaBase.hh"
-
-namespace fastjet {
-
-//----- backwards compatibility with version 2.1 ---------------
-typedef ClusterSequenceAreaBase ClusterSequenceWithArea;
-
-} // fastjet namespace
-
-#endif // __FASTJET_CLUSTERSEQUENCEWITHAREA_HH__
-
-
+++ /dev/null
-#ifndef __EECAMBRIDGEPLUGIN_HH__
-#define __EECAMBRIDGEPLUGIN_HH__
-
-//STARTHEADER
-// $Id: EECambridgePlugin.hh 1491 2009-03-11 17:04:38Z salam $
-//
-// Copyright (c) 2009, Matteo Cacciari, Gavin 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 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
-
-
-#include "fastjet/JetDefinition.hh"
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-// forward declaration to reduce includes
-class ClusterSequence;
-
-//----------------------------------------------------------------------
-//
-/// EECambridgePlugin is a plugin for fastjet (v2.4 upwards)
-///
-/// It implements the Cambridge algorithm, as defined in
-///
-/// Better jet clustering algorithms
-/// Yuri Dokshitzer, Garth Leder, Stefano Moretti, Bryan Webber
-/// JHEP 9708 (1997) 001
-/// http://www-spires.slac.stanford.edu/spires/find/hep/www?rawcmd=FIND+j+JHEPA%2C9708%2C001
-///
-/// On construction one must supply a ycut value.
-///
-/// To get the jets at the end call ClusterSequence::inclusive_jets();
-///
-class EECambridgePlugin : public JetDefinition::Plugin {
-public:
- /// Main constructor for the EECambridge Plugin class.
- /// It takes the dimensionless parameter ycut (the Q value for normalisation
- /// of the kt-distances is taken from the sum of all particle energies).
- EECambridgePlugin (double ycut) : _ycut(ycut) {}
-
- /// copy constructor
- EECambridgePlugin (const EECambridgePlugin & plugin) {
- *this = plugin;
- }
-
- // the things that are required by base class
- virtual std::string description () const;
- virtual void run_clustering(ClusterSequence &) const;
-
- double ycut() const {return _ycut;}
-
- /// the plugin mechanism's standard way of accessing the jet radius.
- /// This must be set to return something sensible, even if R
- /// does not make sense for this algorithm!
- virtual double R() const {return 1.0;}
-
-private:
- double _ycut;
-};
-
-} // fastjet namespace
-
-#endif // __EECAMBRIDGEPLUGIN_HH__
-
+++ /dev/null
-//STARTHEADER
-// $Id: Error.hh 389 2006-12-14 18:29:16Z salam $
-//
-// 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_ERROR_HH__
-#define __FASTJET_ERROR_HH__
-
-#include<iostream>
-#include<string>
-#include "fastjet/internal/base.hh"
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-/// class corresponding to errors that will be thrown by fastjet
-class Error {
-public:
- // constructors
- Error() {;};
- Error(const std::string & message) {
- _message = message;
- if (_print_errors) std::cerr << "fastjet::Error: "<<message << std::endl;
- };
-
- std::string message() const {return _message;};
-
- static void set_print_errors(bool print_errors) {
- _print_errors = print_errors;};
-
-private:
- std::string _message;
- static bool _print_errors;
-};
-
-
-} // fastjet namespace
-
-#endif // __FASTJET_ERROR_HH__
+++ /dev/null
-//STARTHEADER
-// $Id: GhostedAreaSpec.hh 1273 2008-08-11 18:22:55Z salam $
-//
-// 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_GHOSTEDAREASPEC_HH__
-#define __FASTJET_GHOSTEDAREASPEC_HH__
-
-#include<vector>
-#include<string>
-#include "fastjet/PseudoJet.hh"
-#include "fastjet/internal/BasicRandom.hh"
-
-//
-#define STATIC_GENERATOR 1
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-/// namespace to hold default parameters for the active area spec
-namespace gas {
- const double def_ghost_maxrap = 6.0;
- const int def_repeat = 1;
- const double def_ghost_area = 0.01;
- const double def_grid_scatter = 1.0;
- const double def_kt_scatter = 0.1;
- const double def_mean_ghost_kt = 1e-100;
-}
-
-//----------------------------------------------------------------------
-/// Class that defines the parameters that go into the measurement
-/// of active jet areas.
-class GhostedAreaSpec {
-public:
- /// default constructor
- GhostedAreaSpec(): _ghost_maxrap (gas::def_ghost_maxrap),
- _ghost_rap_offset(0.0),
- _repeat (gas::def_repeat),
- _ghost_area (gas::def_ghost_area),
- _grid_scatter (gas::def_grid_scatter),
- _kt_scatter (gas::def_kt_scatter),
- _mean_ghost_kt(gas::def_mean_ghost_kt),
- _actual_ghost_area(-1.0) {_initialize();};
-
- /// explicit constructor
- explicit GhostedAreaSpec(double ghost_maxrap,
- int repeat = gas::def_repeat,
- double ghost_area = gas::def_ghost_area,
- double grid_scatter = gas::def_grid_scatter,
- double kt_scatter = gas::def_kt_scatter,
- double mean_ghost_kt = gas::def_mean_ghost_kt
- ):
- _ghost_maxrap(ghost_maxrap),
- _ghost_rap_offset(0.0),
- _repeat(repeat),
- _ghost_area(ghost_area),
- _grid_scatter(grid_scatter),
- _kt_scatter(kt_scatter),
- _mean_ghost_kt(mean_ghost_kt),
- _actual_ghost_area(-1.0) {_initialize();};
-
- /// explicit constructor
- explicit GhostedAreaSpec(double ghost_minrap,
- double ghost_maxrap,
- int repeat = gas::def_repeat,
- double ghost_area = gas::def_ghost_area,
- double grid_scatter = gas::def_grid_scatter,
- double kt_scatter = gas::def_kt_scatter,
- double mean_ghost_kt = gas::def_mean_ghost_kt
- ):
- _ghost_maxrap (0.5*(ghost_maxrap - ghost_minrap)),
- _ghost_rap_offset(0.5*(ghost_maxrap + ghost_minrap)),
- _repeat(repeat),
- _ghost_area(ghost_area),
- _grid_scatter(grid_scatter),
- _kt_scatter(kt_scatter),
- _mean_ghost_kt(mean_ghost_kt),
- _actual_ghost_area(-1.0) {_initialize();};
-
-
- /// does the initialization of actual ghost parameters
- void _initialize();
-
- // for accessing values set by the user
- inline double ghost_etamax() const {return _ghost_maxrap;};
- inline double ghost_maxrap() const {return _ghost_maxrap;};
- inline double ghost_area () const {return _ghost_area ;};
- inline double grid_scatter() const {return _grid_scatter;};
- inline double kt_scatter () const {return _kt_scatter ;};
- inline double mean_ghost_kt() const {return _mean_ghost_kt ;};
- inline int repeat () const {return _repeat ;};
-
- // for accessing values
- inline double actual_ghost_area() const {return _actual_ghost_area;};
- inline int n_ghosts() const {return _n_ghosts;};
-
- // when explicitly modifying values, sometimes call the initializer
- inline void set_ghost_area (double val) {_ghost_area = val; _initialize();};
- inline void set_ghost_etamax(double val) {_ghost_maxrap = val; _initialize();};
- inline void set_ghost_maxrap(double val) {_ghost_maxrap = val; _initialize();};
- inline void set_grid_scatter(double val) {_grid_scatter = val; };
- inline void set_kt_scatter (double val) {_kt_scatter = val; };
- inline void set_mean_ghost_kt(double val){_mean_ghost_kt = val; };
- inline void set_repeat (int val) {_repeat = val; };
-
- /// return nphi (ghosts layed out (-nrap, 0..nphi-1), (-nrap+1,0..nphi-1),
- /// ... (nrap,0..nphi-1)
- inline int nphi() const {return _nphi;}
- inline int nrap() const {return _nrap;}
-
- /// get all relevant information about the status of the
- /// random number generator, so that it can be reset subsequently
- /// with set_random_status.
- inline void get_random_status(std::vector<int> & __iseed) const {
- _random_generator.get_status(__iseed);}
-
- /// set the status of the random number generator, as obtained
- /// previously with get_random_status. Note that the random
- /// generator is a static member of the class, i.e. common to all
- /// instances of the class --- so if you modify the random for this
- /// instance, you modify it for all instances.
- inline void set_random_status(const std::vector<int> & __iseed) {
- _random_generator.set_status(__iseed);}
-
- inline void checkpoint_random() {get_random_status(_random_checkpoint);}
- inline void restore_checkpoint_random() {set_random_status(_random_checkpoint);}
-
- /// for a summary
- std::string description() const;
-
- /// push the ghost 4-momenta onto the back of the vector of PseudoJets
- void add_ghosts(std::vector<PseudoJet> & ) const;
-
- /// very deprecated public access to a random number
- /// from the internal generator
- inline double random_at_own_risk() const {return _our_rand();};
- /// very deprecated public access to the generator itself
- inline BasicRandom<double> & generator_at_own_risk() const {
- return _random_generator;}
-
-private:
-
- // quantities that determine nature and distribution of ghosts
- double _ghost_maxrap;
- double _ghost_rap_offset;
- int _repeat ;
- double _ghost_area ;
- double _grid_scatter;
- double _kt_scatter ;
- double _mean_ghost_kt;
-
- // derived quantities
- double _actual_ghost_area, _dphi, _drap;
- int _n_ghosts, _nphi, _nrap;
-
-
- std::vector<int> _random_checkpoint;
- static BasicRandom<double> _random_generator;
- //mutable BasicRandom<double> _random_generator;
-
- inline double _our_rand() const {return _random_generator();};
-
-};
-
-////----------------------------------------------------------------------
-//class 1GhostPassiveAreaSpec : public GhostedAreaSpec {
-//public:
-//}
-
-} // fastjet namespace
-
-#endif // __FASTJET_GHOSTEDAREASPEC_HH__
+++ /dev/null
-#ifndef __JADEPLUGIN_HH__
-#define __JADEPLUGIN_HH__
-
-//STARTHEADER
-// $Id: JadePlugin.hh 1491 2009-03-11 17:04:38Z salam $
-//
-// Copyright (c) 2009, Matteo Cacciari, Gavin 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 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
-
-#include "fastjet/JetDefinition.hh"
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-// forward declaration to reduce includes
-class ClusterSequence;
-
-//----------------------------------------------------------------------
-//
-/// JadePlugin is a plugin for fastjet (v2.4 upwards)
-///
-/// It implements the JADE algorithm, which is an e+e- sequential
-/// recombination algorithm with interparticle distance
-///
-/// dij = 2 E_i E_j (1 - cos theta_ij)
-///
-/// or equivalently
-///
-/// yij = dij/E_{vis}^2
-///
-/// This corresponds to the distance measured used in
-///
-/// "Experimental Investigation of the Energy Dependence of the Strong Coupling Strength."
-/// JADE Collaboration (S. Bethke et al.)
-/// Phys.Lett.B213:235,1988
-///
-/// The JADE article carries out particle recombinations in the
-/// E-scheme (4-vector recombination), which is the default procedure for this
-/// plugin.
-///
-/// NOTE: other widely used schemes include E0, P, P0; however they also
-/// involve modifications to the distance measure. Be sure of
-/// what you're doing before running a JADE type algorithm.
-///
-/// To access the jets with a given ycut value (clustering stops once
-/// all yij > ycut), use
-///
-/// vector<PseudoJet> jets = cluster_sequence.exclusive_jets_ycut(ycut);
-///
-/// and related routines.
-///
-class JadePlugin : public JetDefinition::Plugin {
-public:
- /// Main constructor for the Jade Plugin class.
- JadePlugin (){}
-
- /// copy constructor
- JadePlugin (const JadePlugin & plugin) {
- *this = plugin;
- }
-
- // the things that are required by base class
- virtual std::string description () const;
- virtual void run_clustering(ClusterSequence &) const;
-
- /// the plugin mechanism's standard way of accessing the jet radius.
- /// This must be set to return something sensible, even if R
- /// does not make sense for this algorithm!
- virtual double R() const {return 1.0;}
-
-private:
-
-};
-
-} // fastjet namespace
-
-#endif // __JADEPLUGIN_HH__
-
+++ /dev/null
-//STARTHEADER
-// $Id: JetDefinition.hh 1402 2009-01-21 18:03:54Z salam $
-//
-// 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_JETDEFINITION_HH__
-#define __FASTJET_JETDEFINITION_HH__
-
-#include<cassert>
-#include "fastjet/internal/numconsts.hh"
-#include "fastjet/PseudoJet.hh"
-#include<string>
-#include<memory>
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-/// return a string containing information about the release
-// NB: (implemented in ClusterSequence.cc but defined here because
-// this is a visible location)
-std::string fastjet_version_string();
-
-//======================================================================
-/// the various options for the algorithmic strategy to adopt in
-/// clustering events with kt and cambridge style algorithms.
-enum Strategy {
- /// fastest form about 500..10^4
- N2MinHeapTiled = -4,
- /// fastest from about 50..500
- N2Tiled = -3,
- /// legacy
- N2PoorTiled = -2,
- /// fastest below 50
- N2Plain = -1,
- /// worse even than the usual N^3 algorithms
- N3Dumb = 0,
- /// automatic selection of the best (based on N)
- Best = 1,
- /// best of the NlnN variants -- best overall for N>10^4
- NlnN = 2,
- /// legacy N ln N using 3pi coverage of cylinder
- NlnN3pi = 3,
- /// legacy N ln N using 4pi coverage of cylinder
- NlnN4pi = 4,
- /// Chan's closest pair method (in a variant with 4pi coverage),
- /// for use exclusively with the Cambridge algorithm
- NlnNCam4pi = 14,
- NlnNCam2pi2R = 13,
- NlnNCam = 12, // 2piMultD
- /// the plugin has been used...
- plugin_strategy = 999
-};
-
-
-//======================================================================
-/// the various families of jet-clustering algorithm
-enum JetAlgorithm {
- /// the longitudinally invariant kt algorithm
- kt_algorithm=0,
- /// the longitudinally invariant variant of the cambridge algorithm
- /// (aka Aachen algoithm).
- cambridge_algorithm=1,
- /// like the k_t but with distance measures
- /// dij = min(1/kti^2,1/ktj^2) Delta R_{ij}^2 / R^2
- /// diB = 1/kti^2
- antikt_algorithm=2,
- /// like the k_t but with distance measures
- /// dij = min(kti^{2p},ktj^{2p}) Delta R_{ij}^2 / R^2
- /// diB = 1/kti^{2p}
- /// where p = extra_param()
- genkt_algorithm=3,
- /// a version of cambridge with a special distance measure for particles
- /// whose pt is < extra_param()
- cambridge_for_passive_algorithm=11,
- /// a version of genkt with a special distance measure for particles
- /// whose pt is < extra_param() [relevant for passive areas when p<=0]
- genkt_for_passive_algorithm=13,
- //.................................................................
- /// the e+e- kt algorithm
- ee_kt_algorithm=50,
- /// the e+e- genkt algorithm (R > 2 and p=1 gives ee_kt)
- ee_genkt_algorithm=53,
- //.................................................................
- /// any plugin algorithm supplied by the user
- plugin_algorithm = 99
-};
-
-/// make standard Les Houches nomenclature JetAlgorithm (algorithm is general
-/// recipe without the parameters) backward-compatible with old JetFinder
-typedef JetAlgorithm JetFinder;
-
-/// provide other possible names for the Cambridge/Aachen algorithm?
-const JetAlgorithm aachen_algorithm = cambridge_algorithm;
-const JetAlgorithm cambridge_aachen_algorithm = cambridge_algorithm;
-
-//======================================================================
-/// the various recombination schemes
-enum RecombinationScheme {
- /// summing the 4-momenta
- E_scheme=0,
- /// pt weighted recombination of y,phi (and summing of pt's)
- /// with preprocessing to make things massless by rescaling E=|\vec p|
- pt_scheme=1,
- /// pt^2 weighted recombination of y,phi (and summing of pt's)
- /// with preprocessing to make things massless by rescaling E=|\vec p|
- pt2_scheme=2,
- /// pt weighted recombination of y,phi (and summing of pt's)
- /// with preprocessing to make things massless by rescaling |\vec p|->=E
- Et_scheme=3,
- /// pt^2 weighted recombination of y,phi (and summing of pt's)
- /// with preprocessing to make things massless by rescaling |\vec p|->=E
- Et2_scheme=4,
- /// pt weighted recombination of y,phi (and summing of pt's), with
- /// no preprocessing
- BIpt_scheme=5,
- /// pt^2 weighted recombination of y,phi (and summing of pt's)
- /// no preprocessing
- BIpt2_scheme=6,
- /// for the user's external scheme
- external_scheme = 99
-};
-
-
-
-
-// forward declaration, needed in order to specify interface for the
-// plugin.
-class ClusterSequence;
-
-
-
-
-//======================================================================
-/// class that is intended to hold a full definition of the jet
-/// clusterer
-class JetDefinition {
-
-public:
-
- /// forward declaration of a class that allows the user to introduce
- /// their own plugin
- class Plugin;
-
- // forward declaration of a class that will provide the
- // recombination scheme facilities and/or allow a user to
- // extend these facilities
- class Recombiner;
-
-
-
- /// constructor with alternative ordering or arguments -- note that
- /// we have not provided a default jet finder, to avoid ambiguous
- /// JetDefinition() constructor.
- JetDefinition(JetAlgorithm jet_algorithm,
- double R,
- RecombinationScheme recomb_scheme = E_scheme,
- Strategy strategy = Best) {
- *this = JetDefinition(jet_algorithm, R, strategy, recomb_scheme, 1);
- }
-
- /// constructor for algorithms that have no free parameters
- /// (e.g. ee_kt_algorithm)
- JetDefinition(JetAlgorithm jet_algorithm,
- RecombinationScheme recomb_scheme = E_scheme,
- Strategy strategy = Best) {
- double dummyR = 0.0;
- *this = JetDefinition(jet_algorithm, dummyR, strategy, recomb_scheme, 0);
- }
-
- /// constructor for algorithms that require R + one extra parameter to be set
- /// (the gen-kt series for example)
- JetDefinition(JetAlgorithm jet_algorithm,
- double R,
- double xtra_param,
- RecombinationScheme recomb_scheme = E_scheme,
- Strategy strategy = Best) {
- *this = JetDefinition(jet_algorithm, R, strategy, recomb_scheme, 2);
- set_extra_param(xtra_param);
- }
-
-
- /// constructor in a form that allows the user to provide a pointer
- /// to an external recombiner class (which must remain valid for the
- /// life of the JetDefinition object).
- JetDefinition(JetAlgorithm jet_algorithm,
- double R,
- const Recombiner * recombiner,
- Strategy strategy = Best) {
- *this = JetDefinition(jet_algorithm, R, external_scheme, strategy);
- _recombiner = recombiner;
- }
-
-
- /// constructor for case with 0 parameters (ee_kt_algorithm) and
- /// and external recombiner
- JetDefinition(JetAlgorithm jet_algorithm,
- const Recombiner * recombiner,
- Strategy strategy = Best) {
- *this = JetDefinition(jet_algorithm, external_scheme, strategy);
- _recombiner = recombiner;
- }
-
- /// constructor allowing the extra parameter to be set and a pointer to
- /// a recombiner
- JetDefinition(JetAlgorithm jet_algorithm,
- double R,
- double xtra_param,
- const Recombiner * recombiner,
- Strategy strategy = Best) {
- *this = JetDefinition(jet_algorithm, R, external_scheme, strategy);
- _recombiner = recombiner;
- set_extra_param(xtra_param);
- }
-
- /// a default constructor
- JetDefinition() {
- *this = JetDefinition(kt_algorithm, 1.0);
- }
-
- /// constructor based on a pointer to a user's plugin; the object
- /// pointed to must remain valid for the whole duration of existence
- /// of the JetDefinition and any related ClusterSequences
- JetDefinition(const Plugin * plugin) {
- _plugin = plugin;
- _strategy = plugin_strategy;
- _Rparam = _plugin->R();
- _jet_algorithm = plugin_algorithm;
- set_recombination_scheme(E_scheme);
- }
-
-
- /// constructor to fully specify a jet-definition (together with
- /// information about how algorithically to run it).
- ///
- /// the ordering of arguments here is old and deprecated (except
- /// as the common constructor for internal use)
- JetDefinition(JetAlgorithm jet_algorithm,
- double R,
- Strategy strategy,
- RecombinationScheme recomb_scheme = E_scheme,
- int nparameters = 1);
-// :
-// _jet_algorithm(jet_algorithm), _Rparam(R), _strategy(strategy) {
-// // the largest sensible value for R
-// if (jet_algorithm != ee_kt_algorithm &&
-// jet_algorithm != ee_genkt_algorithm) assert(_Rparam <= 0.5*pi);
-// assert(_jet_algorithm != plugin_algorithm &&
-// _strategy != plugin_strategy);
-// _plugin = NULL;
-// set_recombination_scheme(recomb_scheme);
-// set_extra_param(0.0); // make sure it's defined
-// }
-
-
- /// set the recombination scheme to the one provided
- void set_recombination_scheme(RecombinationScheme);
-
- /// set the recombiner class to the one provided
- void set_recombiner(const Recombiner * recomb) {
- _recombiner = recomb;
- _default_recombiner = DefaultRecombiner(external_scheme);
- }
-
- /// return a pointer to the plugin
- const Plugin * plugin() const {return _plugin;};
-
- /// return information about the definition...
- JetAlgorithm jet_algorithm () const {return _jet_algorithm ;}
- /// same as above for backward compatibility
- JetAlgorithm jet_finder () const {return _jet_algorithm ;}
- double R () const {return _Rparam ;}
- // a general purpose extra parameter, whose meaning depends on
- // the algorithm, and may often be unused.
- double extra_param () const {return _extra_param ;}
- Strategy strategy () const {return _strategy ;}
- RecombinationScheme recombination_scheme() const {
- return _default_recombiner.scheme();}
-
- /// (re)set the jet finder
- void set_jet_algorithm(JetAlgorithm njf) {_jet_algorithm = njf;}
- /// same as above for backward compatibility
- void set_jet_finder(JetAlgorithm njf) {_jet_algorithm = njf;}
- /// (re)set the general purpose extra parameter
- void set_extra_param(double xtra_param) {_extra_param = xtra_param;}
-
- /// return a pointer to the currently defined recombiner (it may
- /// be the internal one)
- const Recombiner * recombiner() const {
- return _recombiner == 0 ? & _default_recombiner : _recombiner;}
-
- /// return a textual description of the current jet definition
- std::string description() const;
-
-
-public:
- //======================================================================
- /// An abstract base class that will provide the recombination scheme
- /// facilities and/or allow a user to extend these facilities
- class Recombiner {
- public:
- /// return a textual description of the recombination scheme
- /// implemented here
- virtual std::string description() const = 0;
-
- /// recombine pa and pb and put result into pab
- virtual void recombine(const PseudoJet & pa, const PseudoJet & pb,
- PseudoJet & pab) const = 0;
-
- /// routine called to preprocess each input jet (to make all input
- /// jets compatible with the scheme requirements (e.g. massless).
- virtual void preprocess(PseudoJet & p) const {};
-
- /// a destructor to be replaced if necessary in derived classes...
- virtual ~Recombiner() {};
-
- /// pa += pb in the given recombination scheme. Not virtual -- the
- /// user should have no reason to want to redefine this!
- inline void plus_equal(PseudoJet & pa, const PseudoJet & pb) const {
- // put result in a temporary location in case the recombiner
- // does something funny (ours doesn't, but who knows about the
- // user's)
- PseudoJet pres;
- recombine(pa,pb,pres);
- pa = pres;
- }
-
- };
-
-
- //======================================================================
- /// A class that will provide the recombination scheme facilities and/or
- /// allow a user to extend these facilities
- class DefaultRecombiner : public Recombiner {
- public:
- DefaultRecombiner(RecombinationScheme recomb_scheme = E_scheme) :
- _recomb_scheme(recomb_scheme) {}
-
- virtual std::string description() const;
-
- /// recombine pa and pb and put result into pab
- virtual void recombine(const PseudoJet & pa, const PseudoJet & pb,
- PseudoJet & pab) const;
-
- virtual void preprocess(PseudoJet & p) const;
-
- /// return the index of the recombination scheme
- RecombinationScheme scheme() const {return _recomb_scheme;}
-
- private:
- RecombinationScheme _recomb_scheme;
- };
-
-
- //======================================================================
- /// a class that allows a user to introduce their own "plugin" jet
- /// finder
- class Plugin{
- public:
- /// return a textual description of the jet-definition implemented
- /// in this plugin
- virtual std::string description() const = 0;
-
- /// given a ClusterSequence that has been filled up with initial
- /// particles, the following function should fill up the rest of the
- /// ClusterSequence, using the following member functions of
- /// ClusterSequence:
- /// - plugin_do_ij_recombination(...)
- /// - plugin_do_iB_recombination(...)
- virtual void run_clustering(ClusterSequence &) const = 0;
-
- virtual double R() const = 0;
-
- /// return true if there is specific support for the measurement
- /// of passive areas, in the sense that areas determined from all
- /// particles below the ghost separation scale will be a passive
- /// area. [If you don't understand this, ignore it!]
- virtual bool supports_ghosted_passive_areas() const {return false;}
-
- /// set the ghost separation scale for passive area determinations
- /// in future runs (strictly speaking that makes the routine
- /// a non const, so related internal info must be stored as a mutable)
- virtual void set_ghost_separation_scale(double scale) const;
- virtual double ghost_separation_scale() const {return 0.0;}
-
- /// a destructor to be replaced if necessary in derived classes...
- virtual ~Plugin() {};
- };
-
-private:
-
-
- JetAlgorithm _jet_algorithm;
- double _Rparam;
- double _extra_param ; ///< parameter whose meaning varies according to context
- Strategy _strategy ;
-
- const Plugin * _plugin;
-
- // when we use our own recombiner it's useful to point to it here
- // so that we don't have to worry about deleting it etc...
- DefaultRecombiner _default_recombiner;
- const Recombiner * _recombiner;
-
-};
-
-
-
-
-
-
-} // fastjet namespace
-
-#endif // __FASTJET_JETDEFINITION_HH__
+++ /dev/null
-#ifndef __NNH_HH__
-#define __NNH_HH__
-
-//STARTHEADER
-// $Id: NNH.hh 1491 2009-03-11 17:04:38Z salam $
-//
-// Copyright (c) 2009, Matteo Cacciari, Gavin 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 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
-
-#include<fastjet/ClusterSequence.hh>
-
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-/// dummy class, used as a default template argument
-class _NoInfo {};
-
-/// template that will help initialise a BJ with a PseudoJet and extra information
-template<class I> class NNHInfo {
-public:
- NNHInfo() : _info(NULL) {}
- NNHInfo(I * info) : _info(info) {}
- template<class NNBJ> void init_jet(NNBJ * briefjet, const fastjet::PseudoJet & jet, int index) { briefjet->init(jet, index, _info);}
-private:
- I * _info;
-};
-
-/// Specialisation of NNHInfo for cases where there is no extra info
-template<> class NNHInfo<_NoInfo> {
-public:
- NNHInfo() {}
- NNHInfo(_NoInfo * info) {}
- template<class NNBJ> void init_jet(NNBJ * briefjet, const fastjet::PseudoJet & jet, int index) { briefjet->init(jet, index);}
-};
-
-
-//----------------------------------------------------------------------
-/// Class to help solve closest pair problems with generic interparticle
-/// distances and a beam distance, using Anderberg's Nearest Neighbour
-/// Heuristic.
-///
-/// It is templated with a BJ (brief jet) class --- BJ should
-/// basically cache the minimal amount of information that is needed
-/// to efficient calculate interparticle distances and particle-beam
-/// distances.
-///
-/// This class can be used with or without an extra "Information" template,
-//// i.e. NNB<BJ> or NNH<BJ,I>
-///
-/// For the NNH<BJ> class to function in the case, BJ must provide three member functions
-///
-/// - void BJ::init(const PseudoJet & jet); // initialise with a PseudoJet
-/// - double BJ::distance(const BJ * other_bj_jet); // distance between this and other_bj_jet
-/// - double BJ::beam_distance() ; // distance to the beam
-///
-/// For the NNH<BJ,I> version to function, the BJ::init(...) member
-/// must accept an extra argument
-///
-/// - void BJ::init(const PseudoJet & jet, I * info); // initialise with a PseudoJet + info
-///
-/// where info might be a pointer to a class that contains, e.g., information
-/// about R, or other parameters of the jet algorithm
-///
-/// For an example of how the NNH<BJ> class is used, see the Jade (and
-/// EECambridge) plugins
-///
-/// NB: the NNH algorithm is expected N^2, but has a worst case of
-/// N^3. Many QCD problems tend to place one closer to the N^3 end of
-/// the spectrum than one would like. There is scope for further
-/// progress (cf Eppstein, Cardinal & Eppstein), nevertheless the
-/// current class is already significantly faster than standard N^3
-/// implementations.
-///
-///
-/// Implementation note: this class derives from NNHInfo, which deals
-/// with storing any information that
-
-template<class BJ, class I = _NoInfo> class NNH : public NNHInfo<I> {
-public:
-
- /// constructor with an initial set of jets (which will be assigned indices
- /// 0 ... jets.size()-1
- NNH(const std::vector<PseudoJet> & jets) {start(jets);}
- NNH(const std::vector<PseudoJet> & jets, I * info) : NNHInfo<I>(info) {start(jets);}
-
- void start(const std::vector<PseudoJet> & jets);
-
- /// return the dij_min and indices iA, iB, for the corresponding jets.
- /// If iB < 0 then iA recombines with the beam
- double dij_min(int & iA, int & iB);
-
- /// remove the jet pointed to by index iA
- void remove_jet(int iA);
-
- /// merge the jets pointed to by indices A and B and replace them with
- /// jet, assigning it an index jet_index.
- void merge_jets(int iA, int iB, const PseudoJet & jet, int jet_index);
-
- /// a destructor
- ~NNH() {
- delete[] briefjets;
- }
-
-private:
- class NNBJ; // forward declaration
-
- /// establish the nearest neighbour for jet, and cross check constistency
- /// of distances for the other jets that are encountered. Assumes
- /// jet not contained within begin...end
- void set_NN_crosscheck(NNBJ * jet, NNBJ * begin, NNBJ * end);
-
- /// establish the nearest neighbour for jet; don't cross check other jets'
- /// distances and allow jet to be contained within begin...end
- void set_NN_nocross (NNBJ * jet, NNBJ * begin, NNBJ * end);
-
- /// contains the briefjets
- NNBJ * briefjets;
-
- /// semaphores for the current extent of our structure
- NNBJ * head, * tail;
-
- /// currently active number of jets
- int n;
-
- /// where_is[i] contains a pointer to the jet with index i
- std::vector<NNBJ *> where_is;
-
- /// a class that wraps around the BJ, supplementing it with extra information
- /// such as pointers to neighbours, etc.
- class NNBJ : public BJ {
- public:
- void init(const PseudoJet & jet, int index) {
- BJ::init(jet);
- other_init(index);
- }
- void init(const PseudoJet & jet, int index, I * info) {
- BJ::init(jet, info);
- other_init(index);
- }
- void other_init(int index) {
- _index = index;
- NN_dist = BJ::beam_distance();
- NN = NULL;
- }
- int index() const {return _index;}
-
- double NN_dist;
- NNBJ * NN;
-
- private:
- int _index;
- };
-
-};
-
-
-
-//----------------------------------------------------------------------
-template<class BJ, class I> void NNH<BJ,I>::start(const std::vector<PseudoJet> & jets) {
- n = jets.size();
- briefjets = new NNBJ[n];
- where_is.resize(2*n);
-
- NNBJ * jetA = briefjets;
-
- // initialise the basic jet info
- for (int i = 0; i< n; i++) {
- //jetA->init(jets[i], i);
- init_jet(jetA, jets[i], i);
- where_is[i] = jetA;
- jetA++; // move on to next entry of briefjets
- }
- tail = jetA; // a semaphore for the end of briefjets
- head = briefjets; // a nicer way of naming start
-
- // now initialise the NN distances: jetA will run from 1..n-1; and
- // jetB from 0..jetA-1
- for (jetA = head + 1; jetA != tail; jetA++) {
- // set NN info for jetA based on jets running from head..jetA-1,
- // checking in the process whether jetA itself is an undiscovered
- // NN of one of those jets.
- set_NN_crosscheck(jetA, head, jetA);
- }
- //std::cout << "OOOO " << briefjets[1].NN_dist << " " << briefjets[1].NN - briefjets << std::endl;
-}
-
-
-//----------------------------------------------------------------------
-template<class BJ, class I> double NNH<BJ,I>::dij_min(int & iA, int & iB) {
- // find the minimum of the diJ on this round
- double diJ_min = briefjets[0].NN_dist;
- int diJ_min_jet = 0;
- for (int i = 1; i < n; i++) {
- if (briefjets[i].NN_dist < diJ_min) {
- diJ_min_jet = i;
- diJ_min = briefjets[i].NN_dist;
- }
- }
-
- // return information to user about recombination
- NNBJ * jetA = & briefjets[diJ_min_jet];
- //std::cout << jetA - briefjets << std::endl;
- iA = jetA->index();
- iB = jetA->NN ? jetA->NN->index() : -1;
- return diJ_min;
-}
-
-
-//----------------------------------------------------------------------
-// remove jetA from the list
-template<class BJ, class I> void NNH<BJ,I>::remove_jet(int iA) {
- NNBJ * jetA = where_is[iA];
- // now update our nearest neighbour info and diJ table
- // first reduce size of table
- tail--; n--;
- // Copy last jet contents and diJ info into position of jetA
- *jetA = *tail;
- // update the info on where the given index is stored
- where_is[jetA->index()] = jetA;
-
- for (NNBJ * jetI = head; jetI != tail; jetI++) {
- // see if jetI had jetA or jetB as a NN -- if so recalculate the NN
- if (jetI->NN == jetA) set_NN_nocross(jetI, head, tail);
-
- // if jetI's NN is the new tail then relabel it so that it becomes jetA
- if (jetI->NN == tail) {jetI->NN = jetA;}
- }
-}
-
-
-//----------------------------------------------------------------------
-template<class BJ, class I> void NNH<BJ,I>::merge_jets(int iA, int iB,
- const PseudoJet & jet, int index) {
-
- NNBJ * jetA = where_is[iA];
- NNBJ * jetB = where_is[iB];
-
- // If necessary relabel A & B to ensure jetB < jetA, that way if
- // the larger of them == newtail then that ends up being jetA and
- // the new jet that is added as jetB is inserted in a position that
- // has a future!
- if (jetA < jetB) swap(jetA,jetB);
-
- // initialise jetB based on the new jet
- //jetB->init(jet, index);
- init_jet(jetB, jet, index);
- // and record its position (making sure we have the space)
- if (index >= int(where_is.size())) where_is.resize(2*index);
- where_is[jetB->index()] = jetB;
-
- // now update our nearest neighbour info
- // first reduce size of table
- tail--; n--;
- // Copy last jet contents into position of jetA
- *jetA = *tail;
- // update the info on where the tail's index is stored
- where_is[jetA->index()] = jetA;
-
- for (NNBJ * jetI = head; jetI != tail; jetI++) {
- // see if jetI had jetA or jetB as a NN -- if so recalculate the NN
- if (jetI->NN == jetA || jetI->NN == jetB) {
- set_NN_nocross(jetI, head, tail);
- }
-
- // check whether new jetB is closer than jetI's current NN and
- // if need be update things
- double dist = jetI->distance(jetB);
- if (dist < jetI->NN_dist) {
- if (jetI != jetB) {
- jetI->NN_dist = dist;
- jetI->NN = jetB;
- }
- }
- if (dist < jetB->NN_dist) {
- if (jetI != jetB) {
- jetB->NN_dist = dist;
- jetB->NN = jetI;
- }
- }
-
- // if jetI's NN is the new tail then relabel it so that it becomes jetA
- if (jetI->NN == tail) {jetI->NN = jetA;}
- }
-}
-
-
-//----------------------------------------------------------------------
-// this function assumes that jet is not contained within begin...end
-template <class BJ, class I> void NNH<BJ,I>::set_NN_crosscheck(NNBJ * jet,
- NNBJ * begin, NNBJ * end) {
- double NN_dist = jet->beam_distance();
- NNBJ * NN = NULL;
- for (NNBJ * jetB = begin; jetB != end; jetB++) {
- double dist = jet->distance(jetB);
- if (dist < NN_dist) {
- NN_dist = dist;
- NN = jetB;
- }
- if (dist < jetB->NN_dist) {
- jetB->NN_dist = dist;
- jetB->NN = jet;
- }
- }
- jet->NN = NN;
- jet->NN_dist = NN_dist;
-}
-
-
-//----------------------------------------------------------------------
-// set the NN for jet without checking whether in the process you might
-// have discovered a new nearest neighbour for another jet
-template <class BJ, class I> void NNH<BJ,I>::set_NN_nocross(
- NNBJ * jet, NNBJ * begin, NNBJ * end) {
- double NN_dist = jet->beam_distance();
- NNBJ * NN = NULL;
- if (head < jet) {
- for (NNBJ * jetB = head; jetB != jet; jetB++) {
- double dist = jet->distance(jetB);
- if (dist < NN_dist) {
- NN_dist = dist;
- NN = jetB;
- }
- }
- }
- if (tail > jet) {
- for (NNBJ * jetB = jet+1; jetB != tail; jetB++) {
- double dist = jet->distance (jetB);
- if (dist < NN_dist) {
- NN_dist = dist;
- NN = jetB;
- }
- }
- }
- jet->NN = NN;
- jet->NN_dist = NN_dist;
-}
-
-
-
-
-} // fastjet namespace
-
-
-#endif // __NNH_HH__
+++ /dev/null
-//STARTHEADER
-// $Id: NestedDefsPlugin.hh 1394 2009-01-17 05:08:31Z soyez $
-//
-// Copyright (c) 2007-2008, Matteo Cacciari, Gavin 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 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 __NESTEDALGSPLUGIN_HH__
-#define __NESTEDALGSPLUGIN_HH__
-
-#include "fastjet/JetDefinition.hh"
-#include <list>
-#include <memory>
-#include <cmath>
-
-// questionable whether this should be in fastjet namespace or not...
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-// another forward declaration to reduce includes
-class PseudoJet;
-
-//----------------------------------------------------------------------
-//
-/// NestedAglsPlugin is a plugin for fastjet (v2.4 upwards) that, given
-/// a list of jet definitions, performs the clustering by feeding the
-/// particles to the first algorithm and then, successively feeding the
-/// output to the next algorithm in the list.
-//
-class NestedDefsPlugin : public JetDefinition::Plugin {
-public:
- /// Main constructor for the NestedDefs Plugin class.
- ///
- /// The argument is an initialised list of jet algorithms
- NestedDefsPlugin (std::list<JetDefinition> &defs) :
- _defs(defs){}
-
- /// copy constructor
- NestedDefsPlugin (const NestedDefsPlugin & plugin) {
- *this = plugin;
- }
-
- // the things that are required by base class
- virtual std::string description () const;
- virtual void run_clustering(ClusterSequence &) const;
- /// the plugin mechanism's standard way of accessing the jet radius
- /// here we return the R of the last alg in the list
- virtual double R() const {return _defs.rbegin()->R();}
-
-private:
- std::list<JetDefinition> _defs;
-};
-
-} // fastjet namespace
-
-#endif // __SISCONEPLUGIN_HH__
-
+++ /dev/null
-//STARTHEADER
-// $Id: PseudoJet.hh 1510 2009-04-13 08:48:41Z salam $
-//
-// 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_PSEUDOJET_HH__
-#define __FASTJET_PSEUDOJET_HH__
-
-#include<valarray>
-#include<vector>
-#include<cassert>
-#include<cmath>
-#include<iostream>
-#include "fastjet/internal/numconsts.hh"
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-//using namespace std;
-
-/// Used to protect against parton-level events where pt can be zero
-/// for some partons, giving rapidity=infinity. KtJet fails in those cases.
-const double MaxRap = 1e5;
-
-/// Class to contain pseudojets, including minimal information of use to
-/// to jet-clustering routines.
-class PseudoJet {
-
- public:
- PseudoJet() {};
- /// construct a pseudojet from explicit components
- PseudoJet(const double px, const double py, const double pz, const double E);
- /// constructor from any object that has px,py,pz,E = some_four_vector[0--3],
- template <class L> PseudoJet(const L & some_four_vector) ;
-
- // first "const double &" says that result is a reference to the
- // stored value and that we will not change that stored value.
- //
- // second "const" says that "this" will not be modified by these
- // functions.
- inline double E() const {return _E;}
- inline double e() const {return _E;} // like CLHEP
- inline double px() const {return _px;}
- inline double py() const {return _py;}
- inline double pz() const {return _pz;}
-
- /// returns phi (in the range 0..2pi)
- inline double phi() const {return phi_02pi();}
-
- /// returns phi in the range -pi..pi
- inline double phi_std() const {
- return _phi > pi ? _phi-twopi : _phi;}
-
- /// returns phi in the range 0..2pi
- inline double phi_02pi() const {return _phi;}
-
- /// returns the rapidity or some large value when the rapidity
- /// is infinite
- inline double rap() const {return _rap;}
-
- /// the same as rap()
- inline double rapidity() const {return _rap;} // like CLHEP
-
- /// returns the pseudo-rapidity or some large value when the
- /// rapidity is infinite
- double pseudorapidity() const;
- double eta() const {return pseudorapidity();}
-
- /// returns the squared transverse momentum
- inline double kt2() const {return _kt2;}
- /// returns the squared transverse momentum
- inline double perp2() const {return _kt2;} // like CLHEP
- /// returns the scalar transverse momentum
- inline double perp() const {return sqrt(_kt2);} // like CLHEP
- /// returns the squared invariant mass // like CLHEP
- inline double m2() const {return (_E+_pz)*(_E-_pz)-_kt2;}
- /// returns the squared transverse mass = kt^2+m^2
- inline double mperp2() const {return (_E+_pz)*(_E-_pz);}
- /// returns the transverse mass = sqrt(kt^2+m^2)
- inline double mperp() const {return sqrt(std::abs(mperp2()));}
- /// returns the invariant mass
- /// (If m2() is negative then -sqrt(-m2()) is returned, as in CLHEP)
- inline double m() const;
- /// return px^2+py^2+pz^2
- inline double modp2() const {return _kt2+_pz*_pz;}
- /// return the transverse energy
- inline double Et() const {return (_kt2==0) ? 0.0 : _E/sqrt(1.0+_pz*_pz/_kt2);}
- /// return the transverse energy squared
- inline double Et2() const {return (_kt2==0) ? 0.0 : _E*_E/(1.0+_pz*_pz/_kt2);}
-
- /// returns component i, where X==0, Y==1, Z==2, E==3
- double operator () (int i) const ;
- /// returns component i, where X==0, Y==1, Z==2, E==3
- inline double operator [] (int i) const { return (*this)(i); }; // this too
-
-
- // taken from CLHEP
- enum { X=0, Y=1, Z=2, T=3, NUM_COORDINATES=4, SIZE=NUM_COORDINATES };
-
-
- /// transform this jet (given in the rest frame of prest) into a jet
- /// in the lab frame [NOT FULLY TESTED]
- PseudoJet & boost(const PseudoJet & prest);
- /// transform this jet (given in lab) into a jet in the rest
- /// frame of prest [NOT FULLY TESTED]
- PseudoJet & unboost(const PseudoJet & prest);
-
- /// return the cluster_hist_index, intended to be used by clustering
- /// routines.
- inline int cluster_hist_index() const {return _cluster_hist_index;}
- /// set the cluster_hist_index, intended to be used by clustering routines.
- inline void set_cluster_hist_index(const int index) {_cluster_hist_index = index;}
-
- /// alternative name for cluster_hist_index() [perhaps more meaningful]
- inline int cluster_sequence_history_index() const {
- return cluster_hist_index();}
- /// alternative name for set_cluster_hist_index(...) [perhaps more
- /// meaningful]
- inline void set_cluster_sequence_history_index(const int index) {
- set_cluster_hist_index(index);}
-
-
- /// return the user_index, intended to allow the user to "add" information
- inline int user_index() const {return _user_index;}
- /// set the user_index, intended to allow the user to "add" information
- inline void set_user_index(const int index) {_user_index = index;}
-
- /// return a valarray containing the four-momentum (components 0-2
- /// are 3-mom, component 3 is energy).
- std::valarray<double> four_mom() const;
-
- /// returns kt distance (R=1) between this jet and another
- double kt_distance(const PseudoJet & other) const;
-
- /// returns squared cylinder (rap-phi) distance between this jet and another
- double plain_distance(const PseudoJet & other) const;
- /// returns squared cylinder (rap-phi) distance between this jet and
- /// another
- inline double squared_distance(const PseudoJet & other) const {
- return plain_distance(other);}
-
- /// returns other.phi() - this.phi(), constrained to be in
- /// range -pi .. pi
- double delta_phi_to(const PseudoJet & other) const;
-
- //// this seemed to compile except if it was used
- //friend inline double
- // kt_distance(const PseudoJet & jet1, const PseudoJet & jet2) {
- // return jet1.kt_distance(jet2);}
-
- /// returns distance between this jet and the beam
- inline double beam_distance() const {return _kt2;}
-
-
- void operator*=(double);
- void operator/=(double);
- void operator+=(const PseudoJet &);
- void operator-=(const PseudoJet &);
-
- /// reset the 4-momentum according to the supplied components and
- /// put the user and history indices back to their default values
- inline void reset(double px, double py, double pz, double E);
-
- /// reset the PseudoJet to be equal to psjet (including its
- /// indices); NB if the argument is derived from a PseudoJet then
- /// the "reset" used will be the templated version (which does not
- /// know about indices...)
- inline void reset(const PseudoJet & psjet) {
- (*this) = psjet;
- }
-
- /// reset the 4-momentum according to the supplied generic 4-vector
- /// (accessible via indexing, [0]==px,...[3]==E) and put the user
- /// and history indices back to their default values.
- template <class L> inline void reset(const L & some_four_vector) {
- reset(some_four_vector[0], some_four_vector[1],
- some_four_vector[2], some_four_vector[3]);
- }
-
- private:
- // NB: following order must be kept for things to behave sensibly...
- double _px,_py,_pz,_E;
- double _phi, _rap, _kt2;
- int _cluster_hist_index, _user_index;
- /// calculate phi, rap, kt2 based on the 4-momentum components
- void _finish_init();
- /// set the indices to default values
- void _reset_indices();
-
- //vertex_type * vertex0, vertex1;
-};
-
-
-//----------------------------------------------------------------------
-// routines for basic binary operations
-
-PseudoJet operator+(const PseudoJet &, const PseudoJet &);
-PseudoJet operator-(const PseudoJet &, const PseudoJet &);
-PseudoJet operator*(double, const PseudoJet &);
-PseudoJet operator*(const PseudoJet &, double);
-PseudoJet operator/(const PseudoJet &, double);
-
-inline double dot_product(const PseudoJet & a, const PseudoJet & b) {
- return a.E()*b.E() - a.px()*b.px() - a.py()*b.py() - a.pz()*b.pz();
-}
-
-/// returns true if the momenta of the two input jets are identical
-bool have_same_momentum(const PseudoJet &, const PseudoJet &);
-
-/// return a pseudojet with the given pt, y, phi and mass
-PseudoJet PtYPhiM(double pt, double y, double phi, double m = 0.0);
-
-//----------------------------------------------------------------------
-// Routines to do with providing sorted arrays of vectors.
-
-/// return a vector of jets sorted into decreasing transverse momentum
-std::vector<PseudoJet> sorted_by_pt(const std::vector<PseudoJet> & jets);
-
-/// return a vector of jets sorted into increasing rapidity
-std::vector<PseudoJet> sorted_by_rapidity(const std::vector<PseudoJet> & jets);
-
-/// return a vector of jets sorted into decreasing energy
-std::vector<PseudoJet> sorted_by_E(const std::vector<PseudoJet> & jets);
-
-/// return a vector of jets sorted into increasing pz
-std::vector<PseudoJet> sorted_by_pz(const std::vector<PseudoJet> & jets);
-
-//----------------------------------------------------------------------
-// some code to help sorting
-
-/// sort the indices so that values[indices[0->n-1]] is sorted
-/// into increasing order
-void sort_indices(std::vector<int> & indices,
- const std::vector<double> & values);
-
-/// given a vector of values with a one-to-one correspondence with the
-/// vector of objects, sort objects into an order such that the
-/// associated values would be in increasing order (but don't actually
-/// touch the values vector in the process).
-template<class T> std::vector<T> objects_sorted_by_values(const std::vector<T> & objects,
- const std::vector<double> & values);
-
-/// a class that helps us carry out indexed sorting.
-class IndexedSortHelper {
-public:
- inline IndexedSortHelper (const std::vector<double> * reference_values) {
- _ref_values = reference_values;
- };
- inline int operator() (const int & i1, const int & i2) const {
- return (*_ref_values)[i1] < (*_ref_values)[i2];
- };
-private:
- const std::vector<double> * _ref_values;
-};
-
-
-//----------------------------------------------------------------------
-/// constructor from any object that has px,py,pz,E = some_four_vector[0--3],
-// NB: do not know if it really needs to be inline, but when it wasn't
-// linking failed with g++ (who knows what was wrong...)
-template <class L> inline PseudoJet::PseudoJet(const L & some_four_vector) {
-
- _px = some_four_vector[0];
- _py = some_four_vector[1];
- _pz = some_four_vector[2];
- _E = some_four_vector[3];
- _finish_init();
- // some default values for these two indices
- _reset_indices();
-}
-
-
-//----------------------------------------------------------------------
-inline void PseudoJet::_reset_indices() {
- set_cluster_hist_index(-1);
- set_user_index(-1);
-}
-
-//----------------------------------------------------------------------
-/// specialization of the "reset" template for case where something
-/// is reset to a pseudojet -- it then takes the user and history
-/// indices from the psjet
-// template<> inline void PseudoJet::reset<PseudoJet>(const PseudoJet & psjet) {
-// (*this) = psjet;
-// }
-
-////// fun and games...
-////template<class L> class FJVector : public L {
-////// /** Default Constructor: create jet with no constituents */
-////// Vector<L>();
-////
-////};
-////
-
-// taken literally from CLHEP
-inline double PseudoJet::m() const {
- double mm = m2();
- return mm < 0.0 ? -std::sqrt(-mm) : std::sqrt(mm);
-}
-
-
-inline void PseudoJet::reset(double px, double py, double pz, double E) {
- _px = px;
- _py = py;
- _pz = pz;
- _E = E;
- _finish_init();
- _reset_indices();
-}
-
-
-} // fastjet namespace
-
-#endif // __FASTJET_PSEUDOJET_HH__
+++ /dev/null
-//STARTHEADER
-// $Id: RangeDefinition.hh 1404 2009-01-21 18:43:57Z salam $
-//
-// Copyright (c) 2005-2007, 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_RANGEDEFINITION_HH__
-#define __FASTJET_RANGEDEFINITION_HH__
-
-#include "fastjet/PseudoJet.hh"
-#include "fastjet/Error.hh"
-#include<sstream>
-#include<iostream>
-#include<string>
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-//----------------------------------------------------------------------
-//
-/// class for holding a range definition specification, given by limits
-/// on rapidity and azimuth.
-///
-class RangeDefinition {
-public:
- /// default constructor
- RangeDefinition() {}
-
- /// constructor for a range definition given by |y|<rapmax
- RangeDefinition(double rapmax) {
- assert ( rapmax > 0.0 );
- _rapmax = rapmax;
- _rapmin = -rapmax;
- _phimin = 0.0;
- _phimax = twopi;
- _total_area = 2.0*rapmax*twopi;
- _phispan = _phimax-_phimin; }
-
- /// destructor does nothing
- virtual ~RangeDefinition() {}
-
- /// constructor for a range definition given by
- /// rapmin <= y <= rapmax, phimin <= phi <= phimax
- RangeDefinition(double rapmin, double rapmax,
- double phimin = 0.0, double phimax = twopi) {
- assert ( rapmin < rapmax);
- assert ( phimin < phimax);
- assert ( phimin > -twopi );
- assert ( phimax < 2*twopi);
- _rapmax = rapmax;
- _rapmin = rapmin;
- _phimin = phimin;
- _phimax = phimax;
- if (_phimax-_phimin > twopi)
- _total_area = (_rapmax - _rapmin)*twopi;
- else
- _total_area = (_rapmax - _rapmin)*(_phimax - _phimin);
- _phispan = _phimax-_phimin; }
-
- /// returns true if the range is localizable (i.e. set_position is
- /// meant to do something meaningful).
- ///
- /// This version of the class is not localizable and so it returns
- /// false.
- ///
- /// For localizable classes override this function with a function
- /// that returns true
- virtual inline bool is_localizable() const { return false; }
-
-
- /// place the range on the rap-phi position
- ///
- /// THIS DOES NOT DO ANYTHING FOR THIS CLASS AND IS ONLY THERE
- /// TO FACILITATE DERIVED CLASSES
- ///
- /// DON'T NECESSARILY COUNT ON IT IN THE FUTURE EITHER???
- inline void set_position(const double & rap, const double & phi) {
- if (! is_localizable() ) {
- std::ostringstream err;
- err << description() <<
- "\nThis range is not localizable. set_position() should not be used on it.";
- throw fastjet::Error(err.str());
- } else {
- _rapjet = rap;
- _phijet = phi;
- }
- }
-
- /// place the range on the jet position
- inline void set_position(const PseudoJet & jet) {
- set_position(jet.rap(),jet.phi());
- }
-
- /// return bool according to whether the jet is within the given range
- inline bool is_in_range(const PseudoJet & jet) const {
- double rap = jet.rap();
- double phi = jet.phi();
- return is_in_range(rap,phi);
- }
-
- /// return bool according to whether a (rap,phi) point is in range
- virtual inline bool is_in_range(double rap, double phi) const {
- double dphi=phi-_phimin;
- if (dphi >= twopi) dphi -= twopi;
- if (dphi < 0) dphi += twopi;
- return ( rap >= _rapmin &&
- rap <= _rapmax &&
- dphi <= _phispan );
- }
-
- /// return the minimal and maximal rapidity of this range; remember to
- /// replace this if you write a derived class with more complex ranges;
- virtual inline void get_rap_limits(double & rapmin, double & rapmax) const {
- rapmin = _rapmin;
- rapmax = _rapmax;
- }
-
- /// area of the range region
- virtual inline double area() const { return _total_area; }
-
- /// textual description of range
- virtual inline std::string description() const {
- std::ostringstream ostr;
- ostr << "Range: " << _rapmin << " <= y <= " << _rapmax << ", "
- << _phimin << " <= phi <= " << _phimax ;
- return ostr.str();
-}
-
-protected:
- double _total_area; // total area of specified range
-
- /// calculate, and set _total_area, by calculating which of points on
- /// a grid (npoints * npoints from -rapmax..rapmax,0..2pi) are contained
- /// in the range; it takes a reasonable time with rapmax = 10,
- /// npoints = 100.
- void _numerical_total_area(double rapmax, int npoints) ;
- double _rapjet,_phijet; // jet position. only used in localizable derived classes
-
-private:
- double _rapmin,_rapmax,_phimin,_phimax,_phispan;
-
-};
-
-} // fastjet namespace
-
-#endif // __FASTJET_RANGEDEFINITION_HH__
+++ /dev/null
-#ifndef __SISCONEBASEPLUGIN_HH__
-#define __SISCONEBASEPLUGIN_HH__
-
-#include "fastjet/JetDefinition.hh"
-#include "fastjet/ClusterSequence.hh"
-#include <vector>
-#include <memory>
-#include <cmath>
-
-#include <sstream>
-
-// questionable whether this should be in fastjet namespace or not...
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-//----------------------------------------------------------------------
-//
-/// SISConeBasePlugin is a plugin for fastjet (v2.1 upwards) that
-/// provides a base interface to SISCone-type cone jet finder by
-/// Gregory Soyez and Gavin Salam.
-///
-/// This is a purely virtual class that needs to be overloaded
-/// for the specific implementations of SISCone (i.e. regular or
-/// spherical as of July 16th 2008).
-///
-/// any derived plugin MUST overload the following methods:
-/// description()
-/// run_siscone_clustering()
-/// reset_stored_plugin()
-///
-/// For further details, see the derived plugins or
-/// http://projects.hepforge.com/siscone
-//
-class SISConeBasePlugin : public JetDefinition::Plugin {
-public:
- /// default ctor
- SISConeBasePlugin (){
- _use_jet_def_recombiner = false;
- }
-
- /// copy constructor
- SISConeBasePlugin (const SISConeBasePlugin & plugin) {
- *this = plugin;
- }
-
- /// the cone radius
- double cone_radius () const {return _cone_radius ;}
-
- /// Fraction of overlap energy in a jet above which jets are merged
- /// and below which jets are split.
- double overlap_threshold () const {return _overlap_threshold ;}
-
- /// the maximum number of passes of stable-cone searching (<=0 is same
- /// as infinity).
- int n_pass_max () const {return _n_pass_max ;}
-
- /// set the "split_merge_stopping_scale": if the scale variable for
- /// all protojets is below this, then stop the split-merge procedure
- /// and keep only those jets found so far. This is useful in
- /// determination of areas of hard jets because it can be used to
- /// avoid running the split-merging on the pure ghost-part of the
- /// event.
- void set_split_merge_stopping_scale(double scale) {
- _split_merge_stopping_scale = scale;}
-
- /// return the value of the split_merge_stopping_scale (see
- /// set_split_merge_stopping_scale(...) for description)
- double split_merge_stopping_scale() {return _split_merge_stopping_scale;}
-
- /// allow the user to decide if one uses the jet_def's own recombination scheme
- void set_use_jet_def_recombiner(bool choice) {_use_jet_def_recombiner = choice;}
-
- /// indicate if the jet_def's recombination scheme is being used
- bool use_jet_def_recombiner() const {return _use_jet_def_recombiner;}
-
- /// indicates whether caching is turned on or not.
- bool caching() const {return _caching ;}
-
- /// the plugin mechanism's standard way of accessing the jet radius
- virtual double R() const {return cone_radius();}
-
- /// return true since there is specific support for the measurement
- /// of passive areas, in the sense that areas determined from all
- /// particles below the ghost separation scale will be a passive
- /// area.
- virtual bool supports_ghosted_passive_areas() const {
- return true;
- }
-
- /// set the ghost separation scale for passive area determinations
- /// _just_ in the next run (strictly speaking that makes the routine
- /// a non const, so related internal info must be stored as a mutable)
- virtual void set_ghost_separation_scale(double scale) const {
- _ghost_sep_scale = scale;
- }
-
- virtual double ghost_separation_scale() const {
- return _ghost_sep_scale;
- }
-
- // the things that one MUST overload required by base class
- //---------------------------------------------------------
-
- /// plugin description
- virtual std::string description () const =0;
-
- /// really do the clustering work
- virtual void run_clustering(ClusterSequence &) const = 0;
-
-protected:
- double _cone_radius, _overlap_threshold;
- int _n_pass_max;
- bool _caching;//, _split_merge_on_transverse_mass;
- double _split_merge_stopping_scale;
- bool _use_jet_def_recombiner;
-
- mutable double _ghost_sep_scale;
-
- // the part that HAS to be overloaded
- /// call the re-clustering itself
- virtual void reset_stored_plugin() const =0;
-
-};
-
-
-//======================================================================
-/// Class that provides extra information about a SISCone clustering
-/// the only thing that needs to be done for thee derived classes
-/// is to define '_jet_def_plugin', implement
-/// jet_def_plugin();
-/// and add the corresponding plugin class as a friend
-class SISConeBaseExtras : public ClusterSequence::Extras {
-public:
-
- /// constructor
- // it just initialises the pass information
- SISConeBaseExtras(int nparticles) : _pass(nparticles*2,-1) {}
-
- /// purely virtual destructor
- inline virtual ~SISConeBaseExtras()=0;
-
- /// returns a reference to the vector of stable cones (aka protocones)
- const std::vector<PseudoJet> & stable_cones() const {return _protocones;}
-
- /// an old name for getting the vector of stable cones (aka protocones)
- const std::vector<PseudoJet> & protocones() const {return _protocones;}
-
- /// return the # of the pass at which a given jet was found; will
- /// return -1 if the pass is invalid
- int pass(const PseudoJet & jet) const {return _pass[jet.cluster_hist_index()];}
-
- /// return a brief summary of the contents of the extras object
- /// (specifically, the number of protocones.
- std::string description() const{
- std::ostringstream ostr;
- ostr << "This SISCone clustering found " << protocones().size()
- << " stable protocones";
- return ostr.str();
- };
-
- /// return the smallest difference in squared distance encountered
- /// during splitting between a particle and two overlapping
- /// protojets.
- inline double most_ambiguous_split() const {return _most_ambiguous_split;}
-
-protected:
- std::vector<PseudoJet> _protocones;
- std::vector<int> _pass;
- double _most_ambiguous_split;
- const SISConeBasePlugin * _jet_def_plugin;
-};
-
-/// give the destructor its required implementation
-inline SISConeBaseExtras::~SISConeBaseExtras(){}
-
-
-} // fastjet namespace
-
-#endif // __SISCONEBASEPLUGIN_HH__
-
+++ /dev/null
-#ifndef __SISCONEPLUGIN_HH__
-#define __SISCONEPLUGIN_HH__
-
-#include "SISConeBasePlugin.hh"
-
-// forward declaration of the siscone classes we'll need
-namespace siscone{
- class Csiscone;
-}
-
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-//----------------------------------------------------------------------
-//
-/// SISConePlugin is a plugin for fastjet (v2.1 upwards) that provides
-/// an interface to the seedless infrared safe cone jet finder by
-/// Gregory Soyez and Gavin Salam.
-///
-/// SISCone uses geometrical techniques to exhaustively consider all
-/// possible distinct cones. It then finds out which ones are stable
-/// and sends the result to the Tevatron Run-II type split-merge
-/// procedure for overlapping cones.
-///
-/// Four parameters govern the "physics" of the algorithm:
-///
-/// - the cone_radius (this should be self-explanatory!)
-///
-/// - the overlap_threshold is the parameter which dictates how much
-/// two jets must overlap (pt_overlap/min(pt1,pt2)) if they are to be
-/// merged
-///
-/// - Not all particles are in stable cones in the first round of
-/// searching for stable cones; one can therefore optionally have the
-/// the jet finder carry out additional passes of searching for
-/// stable cones among particles that were in no stable cone in
-/// previous passes --- the maximum number of passes carried out is
-/// n_pass_max. If this is zero then additional passes are carried
-/// out until no new stable cones are found.
-///
-/// - Protojet ptmin: protojets that are below this ptmin
-/// (default = 0) are discarded before each iteration of the
-/// split-merge loop.
-///
-/// One parameter governs some internal algorithmic shortcuts:
-///
-/// - if "caching" is turned on then the last event clustered by
-/// siscone is stored -- if the current event is identical and the
-/// cone_radius and n_pass_mass are identical, then the only part of
-/// the clustering that needs to be rerun is the split-merge part,
-/// leading to significant speed gains; there is a small (O(N) storage
-/// and speed) penalty for caching, so it should be kept off
-/// (default) if only a single overlap_threshold is used.
-///
-/// The final jets can be accessed by requestion the
-/// inclusive_jets(...) from the ClusterSequence object. Note that
-/// these PseudoJets have their user_index() set to the index of the
-/// pass in which they were found (first pass = 0). NB: This does not
-/// currently work for jets that consist of a single particle.
-///
-/// For further information on the details of the algorithm see the
-/// SISCone paper, arXiv:0704.0292 [JHEP 0705:086,2007].
-///
-/// For documentation about the implementation, see the
-/// siscone/doc/html/index.html file.
-//
-class SISConePlugin : public SISConeBasePlugin{
-public:
-
- /// enum for the different split-merge scale choices;
- /// Note that order _must_ be the same as in siscone
- enum SplitMergeScale {SM_pt, ///< transverse momentum (E-scheme), IR unsafe
- SM_Et, ///< transverse energy (E-scheme), not long. boost invariant
- ///< original run-II choice [may not be implemented]
- SM_mt, ///< transverse mass (E-scheme), IR safe except
- ///< in decays of two identical narrow heavy particles
- SM_pttilde ///< pt-scheme pt = \sum_{i in jet} |p_{ti}|, should
- ///< be IR safe in all cases
- };
-
-
- /// Main constructor for the SISCone Plugin class.
- ///
- /// Note: wrt version prior to 2.4 this constructor differs in that a
- /// the default value has been removed for overlap_threshold. The
- /// former has been removed because the old default of 0.5 was found
- /// to be unsuitable in high-noise environments; so the user should
- /// now explicitly think about the value for this -- we recommend
- /// 0.75.
- ///
- SISConePlugin (double cone_radius,
- double overlap_threshold,
- int n_pass_max = 0,
- double protojet_ptmin = 0.0,
- bool caching = false,
- SplitMergeScale split_merge_scale = SM_pttilde,
- double split_merge_stopping_scale = 0.0){
- _cone_radius = cone_radius;
- _overlap_threshold = overlap_threshold;
- _n_pass_max = n_pass_max;
- _protojet_ptmin = protojet_ptmin;
- _caching = caching;
- _split_merge_scale = split_merge_scale;
- _split_merge_stopping_scale = split_merge_stopping_scale;
- _ghost_sep_scale = 0.0;
- _use_pt_weighted_splitting = false;}
-
-
- /// Backwards compatible constructor for the SISCone Plugin class
- SISConePlugin (double cone_radius,
- double overlap_threshold,
- int n_pass_max,
- double protojet_ptmin,
- bool caching ,
- bool split_merge_on_transverse_mass){
- _cone_radius = cone_radius;
- _overlap_threshold = overlap_threshold;
- _n_pass_max = n_pass_max;
- _protojet_ptmin = protojet_ptmin;
- _caching = caching;
- _split_merge_stopping_scale = 0.0;
- _split_merge_scale = split_merge_on_transverse_mass ? SM_mt : SM_pttilde;
- _ghost_sep_scale = 0.0;}
-
- /// backwards compatible constructor for the SISCone Plugin class
- /// (avoid using this in future).
- SISConePlugin (double cone_radius,
- double overlap_threshold,
- int n_pass_max,
- bool caching ) {
- _cone_radius = cone_radius;
- _overlap_threshold = overlap_threshold;
- _n_pass_max = n_pass_max;
- _protojet_ptmin = 0.0;
- _caching = caching;
- _split_merge_scale = SM_mt;
- _split_merge_stopping_scale = 0.0;
- _ghost_sep_scale = 0.0;
- _use_pt_weighted_splitting = false;}
-
- /// minimum pt for a protojet to be considered in the split-merge step
- /// of the algorithm
- double protojet_ptmin () const {return _protojet_ptmin ;}
-
- /// return the scale to be passed to SISCone as the protojet_ptmin
- /// -- if we have a ghost separation scale that is above the
- /// protojet_ptmin, then the ghost_separation_scale becomes the
- /// relevant one to use here
- double protojet_or_ghost_ptmin () const {return std::max(_protojet_ptmin,
- _ghost_sep_scale);}
-
- /// indicates scale used in split-merge
- SplitMergeScale split_merge_scale() const {return _split_merge_scale;}
- /// sets scale used in split-merge
- void set_split_merge_scale(SplitMergeScale sms) {_split_merge_scale = sms;}
-
- /// indicates whether the split-merge orders on transverse mass or not.
- /// retained for backwards compatibility with 2.1.0b3
- bool split_merge_on_transverse_mass() const {return _split_merge_scale == SM_mt ;}
- void set_split_merge_on_transverse_mass(bool val) {
- _split_merge_scale = val ? SM_mt : SM_pt;}
-
- /// indicates whether the split-merge orders on transverse mass or not.
- /// retained for backwards compatibility with 2.1.0b3
- bool split_merge_use_pt_weighted_splitting() const {return _use_pt_weighted_splitting;}
- void set_split_merge_use_pt_weighted_splitting(bool val) {
- _use_pt_weighted_splitting = val;}
-
- // the things that are required by base class
- virtual std::string description () const;
- virtual void run_clustering(ClusterSequence &) const ;
-
-protected:
- virtual void reset_stored_plugin() const;
-
-private:
- double _protojet_ptmin;
- SplitMergeScale _split_merge_scale;
-
- bool _use_pt_weighted_splitting;
-
- // part needed for the cache
- // variables for caching the results and the input
- static std::auto_ptr<SISConePlugin > stored_plugin;
- static std::auto_ptr<std::vector<PseudoJet> > stored_particles;
- static std::auto_ptr<siscone::Csiscone > stored_siscone;
-};
-
-
-//======================================================================
-/// Class that provides extra information about a SISCone clustering
-class SISConeExtras : public SISConeBaseExtras {
-public:
- /// constructor
- // it just initialises the pass information
- SISConeExtras(int nparticles)
- : SISConeBaseExtras(nparticles){}
-
- /// access to the siscone jet def plugin (more convenient than
- /// getting it from the original jet definition, because here it's
- /// directly of the right type (rather than the base type)
- const SISConePlugin* jet_def_plugin() const {
- return dynamic_cast<const SISConePlugin*>(_jet_def_plugin);
- }
-
-private:
- // let us be written to by SISConePlugin
- friend class SISConePlugin;
-};
-
-} // fastjet namespace
-
-#endif // __SISCONEPLUGIN_HH__
-
+++ /dev/null
-#ifndef __SISCONESPHERICALPLUGIN_HH__
-#define __SISCONESPHERICALPLUGIN_HH__
-
-#include "SISConeBasePlugin.hh"
-
-// forward declaration of the siscone classes we'll need
-namespace siscone_spherical{
- class CSphsiscone;
-};
-
-// questionable whether this should be in fastjet namespace or not...
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-//----------------------------------------------------------------------
-//
-/// SISConeSphericalPlugin is a plugin for fastjet (v2.1 upwards) that
-/// provides an interface to the seedless infrared safe cone jet
-/// finder by Gregory Soyez and Gavin Salam.
-///
-/// This is the version of SISCone using spherical coordinates. Compared
-/// to the original cylindrical version:
-///
-/// - Particles are within a cone if their opening angle relative to the
-/// centre of the cone is less than R
-///
-/// - The split-merge step uses the total energy in the protojet as the
-/// ordering and overlap-measure variable
-///
-/// - The IR safety of the split-merge step is _not_ guaranteed for
-/// events consisting of two back-to-back identical heavy particles
-/// that decay. This is because of potential degeneracies in the
-/// ordering for the split-merge step.
-///
-/// For moderate values of R the problem should not be too severe
-/// (or may even be absent for some values of the overlap
-/// parameter), however the user should be aware of the issue.
-///
-/// The default split-merge scale may change at a later date to
-/// resolve this issue.
-///
-///
-/// SISCone uses geometrical techniques to exhaustively consider all
-/// possible distinct cones. It then finds out which ones are stable
-/// and sends the result to the Tevatron Run-II type split-merge
-/// procedure for overlapping cones.
-///
-/// Four parameters govern the "physics" of the algorithm:
-///
-/// - the cone_radius (this should be self-explanatory!)
-///
-/// - the overlap_threshold is the parameter which dictates how much
-/// two jets must overlap (E_overlap/min(E1,E2)) if they are to be
-/// merged
-///
-/// - Not all particles are in stable cones in the first round of
-/// searching for stable cones; one can therefore optionally have the
-/// the jet finder carry out additional passes of searching for
-/// stable cones among particles that were in no stable cone in
-/// previous passes --- the maximum number of passes carried out is
-/// n_pass_max. If this is zero then additional passes are carried
-/// out until no new stable cones are found.
-///
-/// - Protojet Emin: protojets that are below this Emin
-/// (default = 0) are discarded before each iteration of the
-/// split-merge loop.
-///
-/// One parameter governs some internal algorithmic shortcuts:
-///
-/// - if "caching" is turned on then the last event clustered by
-/// siscone is stored -- if the current event is identical and the
-/// cone_radius and n_pass_max are identical, then the only part of
-/// the clustering that needs to be rerun is the split-merge part,
-/// leading to significant speed gains; there is a small (O(N) storage
-/// and speed) penalty for caching, so it should be kept off
-/// (default) if only a single overlap_threshold is used.
-///
-/// The final jets can be accessed by requestion the
-/// inclusive_jets(...) from the ClusterSequence object. Note that
-/// these PseudoJets have their user_index() set to the index of the
-/// pass in which they were found (first pass = 0). NB: This does not
-/// currently work for jets that consist of a single particle.
-///
-/// For further information on the details of the algorithm see the
-/// SISCone paper, arXiv:0704.0292 [JHEP 0705:086,2007].
-///
-/// For documentation about the implementation, see the
-/// siscone/doc/html/index.html file.
-//
-class SISConeSphericalPlugin : public SISConeBasePlugin{
-public:
-
- /// enum for the different split-merge scale choices;
- /// Note that order _must_ be the same as in siscone
- enum SplitMergeScale {SM_E, ///< Energy (IR unsafe with momentum conservation)
- SM_Etilde ///< sum_{i \in jet} E_i [1+sin^2(theta_iJ)]
- };
-
-
- /// Main constructor for the SISConeSpherical Plugin class.
- ///
- ///
- SISConeSphericalPlugin (double cone_radius,
- double overlap_threshold,
- int n_pass_max = 0,
- double protojet_Emin = 0.0,
- bool caching = false,
- SplitMergeScale split_merge_scale = SM_Etilde,
- double split_merge_stopping_scale = 0.0){
- _cone_radius =cone_radius;
- _overlap_threshold =overlap_threshold;
- _n_pass_max =n_pass_max;
- _protojet_Emin =protojet_Emin;
- _caching =caching;
- _split_merge_scale =split_merge_scale;
- _split_merge_stopping_scale = split_merge_stopping_scale;
- _ghost_sep_scale = 0.0;
- _use_E_weighted_splitting = false;
- }
-
- /// minimum energy for a protojet to be considered in the split-merge step
- /// of the algorithm
- double protojet_Emin () const {return _protojet_Emin ;}
-
- /// return the scale to be passed to SISCone as the protojet_Emin
- /// -- if we have a ghost separation scale that is above the
- /// protojet_ptmin, then the ghost_separation_scale becomes the
- /// relevant one to use here
- double protojet_or_ghost_Emin () const {return std::max(_protojet_Emin,
- _ghost_sep_scale);}
-
- /// indicates scale used in split-merge
- SplitMergeScale split_merge_scale() const {return _split_merge_scale;}
- /// sets scale used in split-merge
- void set_split_merge_scale(SplitMergeScale sms) {_split_merge_scale = sms;}
-
- /// indicate if the splittings are done using the anti-kt distance
- bool split_merge_use_E_weighted_splitting() const {return _use_E_weighted_splitting;}
- void set_split_merge_use_E_weighted_splitting(bool val) {
- _use_E_weighted_splitting = val;}
-
- /// overload the default as we don't provide support
- /// for passive areas.
- virtual bool supports_ghosted_passive_areas() const {return true;}
-
- // the things that are required by base class
- virtual std::string description () const;
- virtual void run_clustering(ClusterSequence &) const ;
-
-protected:
- virtual void reset_stored_plugin() const;
-
-private:
- double _protojet_Emin;
- SplitMergeScale _split_merge_scale;
- bool _use_E_weighted_splitting;
-
- // part needed for the cache
- // variables for caching the results and the input
- static std::auto_ptr<SISConeSphericalPlugin > stored_plugin;
- static std::auto_ptr<std::vector<PseudoJet> > stored_particles;
- static std::auto_ptr<siscone_spherical::CSphsiscone> stored_siscone;
-};
-
-//======================================================================
-/// Class that provides extra information about a SISCone clustering
-class SISConeSphericalExtras : public SISConeBaseExtras {
-public:
- /// constructor
- // it just initialises the pass information
- SISConeSphericalExtras(int nparticles)
- : SISConeBaseExtras(nparticles){}
-
- /// access to the siscone jet def plugin (more convenient than
- /// getting it from the original jet definition, because here it's
- /// directly of the right type (rather than the base type)
- const SISConeSphericalPlugin* jet_def_plugin() const {
- return dynamic_cast<const SISConeSphericalPlugin*>(_jet_def_plugin);
- }
-
-private:
- // let us be written to by SISConePlugin
- friend class SISConeSphericalPlugin;
-};
-
-} // fastjet namespace
-
-#endif // __SISCONEPLUGIN_HH__
-
+++ /dev/null
-#ifndef __FASTJET_CONFIG_H__
-#define __FASTJET_CONFIG_H__
-
-// by default, use an automatically generated config_auto.h
-// unless it's a windows machine in which case
-#ifndef WIN32
-#include "config_auto.h"
-#else
-#include "fastjet/config_win.h"
-#endif // WIN32
-
-#endif // __FASTJET_CONFIG_H__
+++ /dev/null
-/* include/fastjet/config_auto.h. Generated from config.h.in by configure. */
-/* config.h.in. Generated from configure.ac by autoheader. */
-
-/* The ATLASCone plugin is enabled */
-/* #undef ENABLE_PLUGIN_ATLASCONE */
-
-/* The CDFJetClu and CDFMidPoint plugins are enabled */
-#define ENABLE_PLUGIN_CDFCONES
-
-/* The CMSIterativeCone plugin is enabled */
-/* #undef ENABLE_PLUGIN_CMSITERATIVECONE */
-
-/* The D0RunIICone plugin is enabled */
-/* #undef ENABLE_PLUGIN_D0RUNIICONE */
-
-/* The EECambridge plugin is enabled */
-#define ENABLE_PLUGIN_EECAMBRIDGE
-
-/* The Jade plugin is enabled */
-#define ENABLE_PLUGIN_JADE
-
-/* The NestedDefs plugin is enabled */
-#define ENABLE_PLUGIN_NESTEDDEFS
-
-/* The PxCone plugin is enabled */
-/* #undef ENABLE_PLUGIN_PXCONE */
-
-/* The SISCone plugin is enabled */
-#define ENABLE_PLUGIN_SISCONE
-
-/* The TrackJet plugin is enabled */
-/* #undef ENABLE_PLUGIN_TRACKJET */
-
-/* Define to 1 if you have the <dlfcn.h> header file. */
-#define HAVE_DLFCN_H 1
-
-/* Define to 1 if you have the <inttypes.h> header file. */
-#define HAVE_INTTYPES_H 1
-
-/* Define to 1 if you have the `m' library (-lm). */
-#define HAVE_LIBM 1
-
-/* Define to 1 if you have the <memory.h> header file. */
-#define HAVE_MEMORY_H 1
-
-/* Define to 1 if you have the <stdint.h> header file. */
-#define HAVE_STDINT_H 1
-
-/* Define to 1 if you have the <stdlib.h> header file. */
-#define HAVE_STDLIB_H 1
-
-/* Define to 1 if you have the <strings.h> header file. */
-#define HAVE_STRINGS_H 1
-
-/* Define to 1 if you have the <string.h> header file. */
-#define HAVE_STRING_H 1
-
-/* Define to 1 if you have the <sys/stat.h> header file. */
-#define HAVE_SYS_STAT_H 1
-
-/* Define to 1 if you have the <sys/types.h> header file. */
-#define HAVE_SYS_TYPES_H 1
-
-/* Define to 1 if you have the <unistd.h> header file. */
-#define HAVE_UNISTD_H 1
-
-/* Name of package */
-#define PACKAGE "fastjet"
-
-/* Define to the address where bug reports for this package should be sent. */
-#define PACKAGE_BUGREPORT ""
-
-/* Define to the full name of this package. */
-#define PACKAGE_NAME "FastJet"
-
-/* Define to the full name and version of this package. */
-#define PACKAGE_STRING "FastJet 2.4.0"
-
-/* Define to the one symbol short name of this package. */
-#define PACKAGE_TARNAME "fastjet"
-
-/* Define to the version of this package. */
-#define PACKAGE_VERSION "2.4.0"
-
-/* Define to 1 if you have the ANSI C header files. */
-#define STDC_HEADERS 1
-
-/* Version number of package */
-#define VERSION "2.4.0"
+++ /dev/null
-#define PACKAGE_STRING "FastJet 2.4.0"
-#define PACKAGE_VERSION "2.4.0"
-
-/* The CDFJetClu and CDFMidPoint plugins are enabled by default*/
-#define ENABLE_PLUGIN_CDFCONES
-
-/* The PxCone plugin is disabled by default*/
-#undef ENABLE_PLUGIN_PXCONE
-
-/* The SISCone plugin is enabled by default*/
-#define ENABLE_PLUGIN_SISCONE
+++ /dev/null
-// Simple random number generator class taken from nlojet++.
-// Some doxygen-style comments added by Gavin Salam, August 2006.
-// $Id: BasicRandom.hh 621 2007-05-09 10:34:30Z salam $
-//
-// Copyright (C) 2002 Zoltan Nagy
-//
-// This program 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.
-//
-// This program 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 this program; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#ifndef __FASTJET_BASICRANDOM_HH__
-#define __FASTJET_BASICRANDOM_HH__ 1
-
-// Standard includes
-#include <iostream>
-#include <vector>
-#include <cassert>
-#include "fastjet/internal/base.hh"
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-template<typename _Tp> class BasicRandom {
-public:
- typedef _Tp value_type;
- typedef unsigned int size_type;
- typedef value_type* pointer;
-
- // give pseudo random numbers
- value_type operator() ();
- void operator() (size_type, pointer);
-
- // (re)initialize the random number generator
- void randomize(void *);
-
- // minimum and maximum values
- static value_type min();
- static value_type max();
-
- // print the informations about the generator to the stream
- void print_info(std::ostream& __os = std::cout);
-};
-
-// default random generator
-int __default_random_generator(int *__iseed);
-
-
-// specializations
-template<>
-class BasicRandom<int>
-{
-public:
- typedef int value_type;
- typedef unsigned int size_type;
- typedef value_type* pointer;
-
- // constructors
- explicit BasicRandom(int __s1 = 12345, int __s2 = 67890) {
- _M_iseed[0] = __s1;
- _M_iseed[1] = __s2;
- }
-
- // give pseudo random numbers
- value_type operator() () {
- return __default_random_generator(_M_iseed);
- }
-
- void operator() (size_type __n, pointer __res) {
- for(size_type __i = 0; __i < __n; __i++)
- __res[__i] = __default_random_generator(_M_iseed);
- }
-
- // (re)initialize the random number generator
- void randomize(void *__iseed) {
- int *__new_seed = (int*) __iseed;
- _M_iseed[0] = __new_seed[0];
- _M_iseed[1] = __new_seed[1];
- }
-
- void set_status(const std::vector<int> & __iseed) {
- assert(__iseed.size() >= 2);
- _M_iseed[0] = __iseed[0];
- _M_iseed[1] = __iseed[1];
- }
-
- void get_status(std::vector<int> & __iseed) {
- __iseed.resize(2);
- __iseed[0] = _M_iseed[0];
- __iseed[1] = _M_iseed[1];
- }
-
- // minimum and maximum values
- inline static value_type min() { return 0;}
- inline static value_type max() { return 2147483647;}
-
- // print the informations about the generator to the stream
- void print_info(std::ostream& __os = std::cout) {
- __os<<"BasicRandom<int> : "<<_M_iseed[0]<<", "<<_M_iseed[1]<<std::endl;
- }
-
-private:
- int _M_iseed[2];
-};
-
-
-/// template specialization (double) for the BasicRandom template class.
-template<> class BasicRandom<double> {
-public:
- typedef double value_type;
- typedef unsigned int size_type;
- typedef value_type* pointer;
-
- /// constructor that takes two integers to specify the seed
- explicit BasicRandom(int __s1 = 12345, int __s2 = 67890) {
- _M_iseed[0] = __s1;
- _M_iseed[1] = __s2;
- }
-
- /// return a single pseudorandom double number, in the range 0.0 to 1.0
- /// (not sure whether this range is open or closed)
- value_type operator() () {
- return 4.6566128752457969241e-10*__default_random_generator(_M_iseed);
- }
-
- /// given a pointer __res to the beginning of an array, fill that array
- /// with __n random numbers
- void operator() (size_type __n, pointer __res) {
- for(size_type __i = 0; __i < __n; __i++)
- __res[__i] = this -> operator()();
- }
-
- /// (re)initialize the random number generator from an array of seeds
- void randomize(void *__iseed) {
- int *__new_seed = (int*) __iseed;
- _M_iseed[0] = __new_seed[0];
- _M_iseed[1] = __new_seed[1];
- }
-
- void set_status(const std::vector<int> & __iseed) {
- assert(__iseed.size() >= 2);
- _M_iseed[0] = __iseed[0];
- _M_iseed[1] = __iseed[1];
- }
-
- void get_status(std::vector<int> & __iseed) {
- __iseed.resize(2);
- __iseed[0] = _M_iseed[0];
- __iseed[1] = _M_iseed[1];
- }
-
- /// minimum value returned by the generator
- inline static value_type min() { return 0.0;}
- /// maximum value returned by the generator
- inline static value_type max() { return 1.0;}
-
- /// print information about the generator to the stream
- void print_info(std::ostream& __os = std::cout) {
- __os<<"BasicRandom<double> : "<<_M_iseed[0]<<", "<<_M_iseed[1]<<std::endl;
- }
-
-private:
- int _M_iseed[2];
-};
-
-// globally defined random number generator
-extern BasicRandom<int> _G_random_int;
-extern BasicRandom<double> _G_random_double;
-
-
-} // fastjet namespace
-
-#endif // __FASTJET_BASICRANDOM_HH__
-
+++ /dev/null
-//STARTHEADER
-// $Id: ClosestPair2D.hh 293 2006-08-17 19:38:38Z salam $
-//
-// 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_CLOSESTPAIR2D__HH__
-#define __FASTJET_CLOSESTPAIR2D__HH__
-
-#include<vector>
-#include<stack>
-#include<iostream>
-#include "fastjet/internal/ClosestPair2DBase.hh"
-#include "fastjet/internal/SearchTree.hh"
-#include "fastjet/internal/MinHeap.hh"
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-//----------------------------------------------------------------------
-/// concrete implementation for finding closest pairs in 2D -- will
-/// use Chan's (hopefully efficient) shuffle based structures
-class ClosestPair2D : public ClosestPair2DBase {
-public:
- /// constructor from a vector of 2D positions -- number of objects
- /// after insertion and deletion must never exceed positions.size();
- /// objects are given IDs that correspond to their index in the vector
- /// of positions
- ClosestPair2D(const std::vector<Coord2D> & positions,
- const Coord2D & left_corner, const Coord2D & right_corner) {
- _initialize(positions, left_corner, right_corner, positions.size());
- };
-
- /// constructor which allows structure to grow beyond positions.size(), up
- /// to max_size
- ClosestPair2D(const std::vector<Coord2D> & positions,
- const Coord2D & left_corner, const Coord2D & right_corner,
- const unsigned int max_size) {
- _initialize(positions, left_corner, right_corner, max_size);
- };
-
- /// provides the IDs of the closest pair as well as the distance between
- /// them
- void closest_pair(unsigned int & ID1, unsigned int & ID2,
- double & distance2) const;
-
- /// removes the entry labelled by ID from the object;
- void remove(unsigned int ID);
-
- /// inserts the position into the closest pair structure and returns the
- /// ID that has been allocated for the object.
- unsigned int insert(const Coord2D &);
-
- /// removes ID1 and ID2 and inserts position, returning the ID
- /// corresponding to position...
- virtual unsigned int replace(unsigned int ID1, unsigned int ID2,
- const Coord2D & position);
-
- /// replaces IDs_to_remove with points at the new_positions
- /// indicating the IDs allocated to the new points in new_IDs
- virtual void replace_many(const std::vector<unsigned int> & IDs_to_remove,
- const std::vector<Coord2D> & new_positions,
- std::vector<unsigned int> & new_IDs);
-
- // mostly for checking how things are working...
- inline void print_tree_depths(std::ostream & outdev) const {
- outdev << _trees[0]->max_depth() << " "
- << _trees[1]->max_depth() << " "
- << _trees[2]->max_depth() << "\n";
- };
-
- unsigned int size();
-
-private:
-
- void _initialize(const std::vector<Coord2D> & positions,
- const Coord2D & left_corner, const Coord2D & right_corner,
- const unsigned int max_size);
-
- static const unsigned int _nshift = 3;
-
- class Point; // will be defined below
-
- /// since sets of three objects will crop up repeatedly, useful
- /// to have a triplet class?
- template<class T> class triplet {
- public:
- inline const T & operator[](unsigned int i) const {return _contents[i];};
- inline T & operator[](unsigned int i) {return _contents[i];};
- private:
- T _contents[_nshift];
- };
-
-
- /// class that will take care of ordering of shuffles for us
- class Shuffle {
- public:
- unsigned int x, y;
- Point * point;
- bool operator<(const Shuffle &) const;
- void operator+=(unsigned int shift) {x += shift; y+= shift;};
- };
-
- typedef SearchTree<Shuffle> Tree;
- typedef Tree::circulator circulator;
- typedef Tree::const_circulator const_circulator;
-
-
- triplet<std::auto_ptr<Tree> > _trees;
- std::auto_ptr<MinHeap> _heap;
- std::vector<Point> _points;
- std::stack<Point *> _available_points;
-
- /// points that are "under review" in some way
- std::vector<Point *> _points_under_review;
-
- // different statuses for review
- static const unsigned int _remove_heap_entry = 1;
- static const unsigned int _review_heap_entry = 2;
- static const unsigned int _review_neighbour = 4;
-
- /// add a label to a point as to the nature of review needed
- /// (includes adding it to list of points needing review) [doesn't
- /// affect other labels already set for the point]
- void _add_label(Point * point, unsigned int review_flag);
-
- /// sets the label for the point to be exclusively this
- /// review flag (and adds it to list of points needing review
- /// if not already there)
- void _set_label(Point * point, unsigned int review_flag);
-
- /// for all entries of the _points_under_review[] vector, carry out
- /// the actions indicated by its review flag; the points are
- /// then removed from _points_under_review[] and their flags
- /// set to zero
- void _deal_with_points_to_review();
-
- /// carry out the search-tree related operations of point removal
- void _remove_from_search_tree(Point * point_to_remove);
-
- /// carry out the search-tree related operations of point insertion
- void _insert_into_search_tree(Point * new_point);
-
- /// takes a point and creates a shuffle with the given shift
- void _point2shuffle(Point & , Shuffle & , unsigned int shift);
-
- /// pieces needed for converting coordinates to integer
- Coord2D _left_corner;
- double _range;
-
- int _ID(const Point *) const;
-
- triplet<unsigned int> _shifts; // absolute shifts
- triplet<unsigned int> _rel_shifts; // shifts relative to previous shift
-
- unsigned int _cp_search_range;
-};
-
-
-//----------------------------------------------------------------------
-/// class for representing all info needed about a point
-class ClosestPair2D::Point {
-public:
- /// the point's coordinates
- Coord2D coord;
- /// a pointer to its closest neighbour in our structure
- Point * neighbour;
- /// the corresponding squared distance
- double neighbour_dist2;
- /// circulators for each of the shifts of the shuffles
- triplet<circulator> circ;
-
- /// indicates that something special is currently happening to this point
- unsigned int review_flag;
-
- /// returns the distance between two of these objects
- double distance2(const Point & other) const {
- return coord.distance2(other.coord);
- };
-
- /// creates a shuffle for us with a given shift
- //void set_shuffle(Shuffle & shuffle);
-};
-
-
-//----------------------------------------------------------------------
-/// returns true if floor(ln_base2(x)) < floor(ln_base2(y)), using
-/// Chan's neat trick...
-inline bool floor_ln2_less(unsigned x, unsigned y) {
- if (x>y) return false;
- return (x < (x^y)); // beware of operator precedence...
-}
-
-
-//----------------------------------------------------------------------
-/// returns the ID for the specified point...
-inline int ClosestPair2D::_ID(const Point * point) const {
- return point - &(_points[0]);
-}
-
-
-//
-inline unsigned int ClosestPair2D::size() {
- return _points.size() - _available_points.size();
-}
-
-
-
-} // fastjet namespace
-
-#endif // __FASTJET_CLOSESTPAIR2D__HH__
+++ /dev/null
-//STARTHEADER
-// $Id: ClosestPair2DBase.hh 293 2006-08-17 19:38:38Z salam $
-//
-// 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_CLOSESTPAIR2DBASE__HH__
-#define __FASTJET_CLOSESTPAIR2DBASE__HH__
-
-#include<vector>
-#include "fastjet/internal/base.hh"
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-//----------------------------------------------------------------------
-/// class for representing 2d coordinates and carrying out some basic
-/// operations on them
-class Coord2D {
-public:
- double x, y;
-
- Coord2D() {};
-
- Coord2D(double a, double b): x(a), y(b) {};
-
- /// return the vector difference between two coordinates
- Coord2D operator-(const Coord2D & other) const {
- return Coord2D(x - other.x, y - other.y);};
-
- /// return the vector sum between two coordinates
- Coord2D operator+(const Coord2D & other) const {
- return Coord2D(x + other.x, y + other.y);};
-
- /// return the product of the coordinate with the factor
- Coord2D operator*(double factor) const {return Coord2D(factor*x,factor*y);};
- friend Coord2D operator*(double factor, const Coord2D & coord) {
- return Coord2D(factor*coord.x,factor*coord.y);
- }
-
- /// division of each component of coordinate
- Coord2D operator/(double divisor) const {
- return Coord2D(x / divisor, y / divisor);};
-
- /// return the squared distance between two coordinates
- friend double distance2(const Coord2D & a, const Coord2D & b) {
- double dx = a.x - b.x, dy = a.y-b.y;
- return dx*dx+dy*dy;
- };
- /// return the squared distance between two coordinates
- double distance2(const Coord2D & b) const {
- double dx = x - b.x, dy = y-b.y;
- return dx*dx+dy*dy;
- };
-};
-
-
-//----------------------------------------------------------------------
-/// abstract base class for finding closest pairs in 2D
-class ClosestPair2DBase {
-public:
- /// provides the IDs of the closest pair as well as the squared
- /// distance between them
- virtual void closest_pair(unsigned int & ID1, unsigned int & ID2,
- double & distance2) const = 0;
-
- /// removes the entry labelled by ID from the object;
- virtual void remove(unsigned int ID) = 0;
-
- /// inserts the position into the closest pair structure and returns the
- /// ID that has been allocated for the object.
- virtual unsigned int insert(const Coord2D & position) = 0;
-
- /// replaces the specified ID1 and ID2 with something at a new position
- /// assuming that ID1 and ID2 are in sequence wrt position; it returns
- /// the ID of the new object...
- virtual unsigned int replace(unsigned int ID1, unsigned int ID2,
- const Coord2D & position) {
- remove(ID1);
- remove(ID2);
- unsigned new_ID = insert(position);
- return(new_ID);
- };
-
- /// replaces IDs_to_remove with points at the new_positions
- /// indicating the IDs allocated to the new points in new_IDs
- virtual void replace_many(const std::vector<unsigned int> & IDs_to_remove,
- const std::vector<Coord2D> & new_positions,
- std::vector<unsigned int> & new_IDs) {
- for(unsigned i = 0; i < IDs_to_remove.size(); i++) {
- remove(IDs_to_remove[i]);}
- new_IDs.resize(0);
- for(unsigned i = 0; i < new_positions.size(); i++) {
- new_IDs.push_back(insert(new_positions[i]));}
- }
-
- virtual unsigned int size() = 0;
-
- virtual ~ClosestPair2DBase() {};
-
-};
-
-
-} // fastjet namespace
-
-#endif // __FASTJET_CLOSESTPAIR2DBASE__HH__
+++ /dev/null
-//STARTHEADER
-// $Id: Dnn2piCylinder.hh 431 2007-01-20 10:44:55Z salam $
-//
-// 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 DROP_CGAL // in case we do not have the code for CGAL
-#ifndef __FASTJET_DNN2PICYLINDER_HH__
-#define __FASTJET_DNN2PICYLINDER_HH__
-
-#include "fastjet/internal/DynamicNearestNeighbours.hh"
-#include "fastjet/internal/DnnPlane.hh"
-#include "fastjet/internal/numconsts.hh"
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-
-/// class derived from DynamicNearestNeighbours that provides an
-/// implementation for the surface of cylinder (using one
-/// DnnPlane object spanning 0--2pi).
-class Dnn2piCylinder : public DynamicNearestNeighbours {
- public:
- /// empty initaliser
- Dnn2piCylinder() {}
-
- /// Initialiser from a set of points on an Eta-Phi plane, where
- /// eta can have an arbitrary ranges and phi must be in range
- /// 0 <= phi < 2pi;
- ///
- /// NB: this class is more efficient than the plain Dnn4piCylinder
- /// class, but can give wrong answers when the nearest neighbour is
- /// further away than 2pi (in this case a point's nearest neighbour
- /// becomes itself, because it is considered to be a distance 2pi
- /// away). For the kt-algorithm (e.g.) this is actually not a
- /// problem (the distance need only be accurate when it is less than
- /// R), so we can tell the routine to ignore this problem --
- /// alternatively the routine will crash if it detects it occurring
- /// (only when finding the nearest neighbour index, not its
- /// distance).
- Dnn2piCylinder(const std::vector<EtaPhi> &,
- const bool & ignore_nearest_is_mirror = false,
- const bool & verbose = false );
-
- /// Returns the index of the nearest neighbour of point labelled
- /// by ii (assumes ii is valid)
- int NearestNeighbourIndex(const int & ii) const ;
-
- /// Returns the distance to the nearest neighbour of point labelled
- /// by index ii (assumes ii is valid)
- double NearestNeighbourDistance(const int & ii) const ;
-
- /// Returns true iff the given index corresponds to a point that
- /// exists in the DNN structure (meaning that it has been added, and
- /// not removed in the meantime)
- bool Valid(const int & index) const;
-
- void RemoveAndAddPoints(const std::vector<int> & indices_to_remove,
- const std::vector<EtaPhi> & points_to_add,
- std::vector<int> & indices_added,
- std::vector<int> & indices_of_updated_neighbours);
-
- ~Dnn2piCylinder();
-
- private:
-
- // our extras to help us navigate, find distance, etc.
- const static int INEXISTENT_VERTEX=-3;
-
- bool _verbose;
-
- bool _ignore_nearest_is_mirror;
-
- /// Picture of how things will work... Copy 0--pi part of the 0--2pi
- /// cylinder into a region 2pi--2pi+ a bit of a Euclidean plane. Below we
- /// show points labelled by + that have a mirror image in this
- /// manner, while points labelled by * do not have a mirror image.
- ///
- /// | . |
- /// | . |
- /// | . |
- /// | . |
- /// | 2 . |
- /// | * . |
- /// | + . + |
- /// | 0 . 1 |
- /// | . |
- /// 0 2pi 2pi + a bit
- ///
- /// Each "true" point has its true "cylinder" index (the index that
- /// is known externally to this class) as well as euclidean plane
- /// indices (main_index and mirror index in the MirrorVertexInfo
- /// structure), which are private concepts of this class.
- ///
- /// In above picture our structures would hold the following info
- /// (the picture shows the euclidean-plane numbering)
- ///
- /// _mirror_info[cylinder_index = 0] = (0, 1)
- /// _mirror_info[cylinder_index = 1] = (2, INEXISTENT_VERTEX)
- ///
- /// We also need to be able to go from the euclidean plane indices
- /// back to the "true" cylinder index, and for this purpose we use
- /// the std::vector _cylinder_index_of_plane_vertex[...], which in the above example has
- /// the following contents
- ///
- /// _cylinder_index_of_plane_vertex[0] = 0
- /// _cylinder_index_of_plane_vertex[1] = 0
- /// _cylinder_index_of_plane_vertex[2] = 1
- ///
-
- ///
- struct MirrorVertexInfo {
- /// index of the given point (appearing in the range 0--2pi) in the
- /// 0--2pi euclidean plane structure (position will coincide with
- /// that on the 0--2pi cylinder, but index labelling it will be
- /// different)
- int main_index;
- /// index of the mirror point (appearing in the range 2pi--3pi) in the
- /// 0--3pi euclidean plane structure
- int mirror_index;
- };
-
- // for each "true" vertex we have reference to indices in the euclidean
- // plane structure
- std::vector<MirrorVertexInfo> _mirror_info;
- // for each index in the euclidean 0--2pi plane structure we want to
- // be able to get back to the "true" vertex index on the overall
- // 0--2pi cylinder structure
- std::vector<int> _cylinder_index_of_plane_vertex;
-
- // NB: we define POINTERS here because the initialisation gave
- // us problems (things crashed!), perhaps because in practice
- // we were making a copy without being careful and defining
- // a proper copy constructor.
- DnnPlane * _DNN;
-
- /// given a phi value in the 0--pi range return one
- /// in the 2pi--3pi range; whereas if it is in the pi-2pi range then
- /// remap it to be inthe range (-pi)--0.
- inline EtaPhi _remap_phi(const EtaPhi & point) {
- double phi = point.second;
- if (phi < pi) { phi += twopi ;} else {phi -= twopi;}
- return EtaPhi(point.first, phi);}
-
-
- //----------------------------------------------------------------------
- /// Actions here are similar to those in the
- /// Dnn3piCylinder::_RegisterCylinderPoint case, however here we do
- /// NOT create the mirror point -- instead we initialise the structure
- /// as if there were no need for the mirror point.
- ///
- /// ADDITIONALLY push the cylinder_point onto the vector plane_points.
- void _RegisterCylinderPoint (const EtaPhi & cylinder_point,
- std::vector<EtaPhi> & plane_points);
-
- /// For each plane point specified in the vector plane_indices,
- /// establish whether there is a need to create a mirror point
- /// according to the following criteria:
- ///
- /// . phi < pi
- /// . mirror does not already exist
- /// . phi < NearestNeighbourDistance
- /// (if this is not true then there is no way that its mirror point
- /// could have a nearer neighbour).
- ///
- /// If conditions all hold, then create the mirror point, insert it
- /// into the _DNN structure, adjusting any nearest neighbours, and
- /// return the list of plane points whose nearest neighbours have
- /// changed (this will include the new neighbours that have just been
- /// added)
- void _CreateNecessaryMirrorPoints(
- const std::vector<int> & plane_indices,
- std::vector<int> & updated_plane_points);
-
-};
-
-
-// here follow some inline implementations of the simpler of the
-// functions defined above
-
-//----------------------------------------------------------------------
-/// Note: one of the difficulties of the 0--2pi mapping is that
-/// a point may have its mirror copy as its own nearest neighbour
-/// (if no other point is within a distance of 2pi). This does
-/// not matter for the kt_algorithm with
-/// reasonable values of radius, but might matter for a general use
-/// of this algorithm -- depending on whether or not the user has
-/// initialised the class with instructions to ignore this problem the
-/// program will detect and ignore it, or crash.
-inline int Dnn2piCylinder::NearestNeighbourIndex(const int & current) const {
- int main_index = _mirror_info[current].main_index;
- int mirror_index = _mirror_info[current].mirror_index;
- int plane_index;
- if (mirror_index == INEXISTENT_VERTEX ) {
- plane_index = _DNN->NearestNeighbourIndex(main_index);
- } else {
- plane_index = (
- _DNN->NearestNeighbourDistance(main_index) <
- _DNN->NearestNeighbourDistance(mirror_index)) ?
- _DNN->NearestNeighbourIndex(main_index) :
- _DNN->NearestNeighbourIndex(mirror_index) ;
- }
- int this_cylinder_index = _cylinder_index_of_plane_vertex[plane_index];
- // either the user has acknowledged the fact that they may get the
- // mirror copy as the closest point, or crash if it should occur
- // that mirror copy is the closest point.
- assert(_ignore_nearest_is_mirror || this_cylinder_index != current);
- //if (this_cylinder_index == current) {
- // cerr << "WARNING point "<<current<<
- // " has its mirror copy as its own nearest neighbour"<<endl;
- //}
- return this_cylinder_index;
-}
-
-inline double Dnn2piCylinder::NearestNeighbourDistance(const int & current) const {
- int main_index = _mirror_info[current].main_index;
- int mirror_index = _mirror_info[current].mirror_index;
- if (mirror_index == INEXISTENT_VERTEX ) {
- return _DNN->NearestNeighbourDistance(main_index);
- } else {
- return (
- _DNN->NearestNeighbourDistance(main_index) <
- _DNN->NearestNeighbourDistance(mirror_index)) ?
- _DNN->NearestNeighbourDistance(main_index) :
- _DNN->NearestNeighbourDistance(mirror_index) ;
- }
-
-}
-
-inline bool Dnn2piCylinder::Valid(const int & index) const {
- return (_DNN->Valid(_mirror_info[index].main_index));
-}
-
-
-inline Dnn2piCylinder::~Dnn2piCylinder() {
- delete _DNN;
-}
-
-
-} // fastjet namespace
-
-#endif // __FASTJET_DNN2PICYLINDER_HH__
-#endif //DROP_CGAL
+++ /dev/null
-//STARTHEADER
-// $Id: Dnn3piCylinder.hh 431 2007-01-20 10:44:55Z salam $
-//
-// 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 DROP_CGAL // in case we do not have the code for CGAL
-#ifndef __FASTJET_DNN3PICYLINDER_HH__
-#define __FASTJET_DNN3PICYLINDER_HH__
-
-#include "fastjet/internal/DynamicNearestNeighbours.hh"
-#include "fastjet/internal/DnnPlane.hh"
-#include "fastjet/internal/numconsts.hh"
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-/// class derived from DynamicNearestNeighbours that provides an
-/// implementation for the surface of cylinder (using one
-/// DnnPlane object spanning 0--3pi).
-class Dnn3piCylinder : public DynamicNearestNeighbours {
- public:
- /// empty initaliser
- Dnn3piCylinder() {}
-
- /// Initialiser from a set of points on an Eta-Phi plane, where
- /// eta can have an arbitrary ranges and phi must be in range
- /// 0 <= phi < 2pi;
- ///
- /// NB: this class is more efficient than the plain Dnn4piCylinder
- /// class, but can give wrong answers when the nearest neighbour is
- /// further away than 2pi (in this case a point's nearest neighbour
- /// becomes itself, because it is considered to be a distance 2pi
- /// away). For the kt-algorithm (e.g.) this is actually not a
- /// problem (the distance need only be accurate when it is less than
- /// R), so we can tell the routine to ignore this problem --
- /// alternatively the routine will crash if it detects it occurring
- /// (only when finding the nearest neighbour index, not its
- /// distance).
- Dnn3piCylinder(const std::vector<EtaPhi> &,
- const bool & ignore_nearest_is_mirror = false,
- const bool & verbose = false );
-
- /// Returns the index of the nearest neighbour of point labelled
- /// by ii (assumes ii is valid)
- int NearestNeighbourIndex(const int & ii) const ;
-
- /// Returns the distance to the nearest neighbour of point labelled
- /// by index ii (assumes ii is valid)
- double NearestNeighbourDistance(const int & ii) const ;
-
- /// Returns true iff the given index corresponds to a point that
- /// exists in the DNN structure (meaning that it has been added, and
- /// not removed in the meantime)
- bool Valid(const int & index) const;
-
- void RemoveAndAddPoints(const std::vector<int> & indices_to_remove,
- const std::vector<EtaPhi> & points_to_add,
- std::vector<int> & indices_added,
- std::vector<int> & indices_of_updated_neighbours);
-
- ~Dnn3piCylinder();
-
- private:
-
- // our extras to help us navigate, find distance, etc.
- const static int INEXISTENT_VERTEX=-3;
-
- bool _verbose;
-
- bool _ignore_nearest_is_mirror;
-
- /// Picture of how things will work... Copy 0--pi part of the 0--2pi
- /// cylinder into a region 2pi--3pi of a Euclidean plane. Below we
- /// show points labelled by + that have a mirror image in this
- /// manner, while points labelled by * do not have a mirror image.
- ///
- /// | . |
- /// | . |
- /// | . |
- /// | . |
- /// | 2 . |
- /// | * . |
- /// | + . + |
- /// | 0 . 1 |
- /// | . |
- /// 0 2pi 3pi
- ///
- /// Each "true" point has its true "cylinder" index (the index that
- /// is known externally to this class) as well as euclidean plane
- /// indices (main_index and mirror index in the MirrorVertexInfo
- /// structure), which are private concepts of this class.
- ///
- /// In above picture our structures would hold the following info
- /// (the picture shows the euclidean-plane numbering)
- ///
- /// _mirror_info[cylinder_index = 0] = (0, 1)
- /// _mirror_info[cylinder_index = 1] = (2, INEXISTENT_VERTEX)
- ///
- /// We also need to be able to go from the euclidean plane indices
- /// back to the "true" cylinder index, and for this purpose we use
- /// the vector _cylinder_index_of_plane_vertex[...], which in the above example has
- /// the following contents
- ///
- /// _cylinder_index_of_plane_vertex[0] = 0
- /// _cylinder_index_of_plane_vertex[1] = 0
- /// _cylinder_index_of_plane_vertex[2] = 1
- ///
-
- ///
- struct MirrorVertexInfo {
- /// index of the given point (appearing in the range 0--2pi) in the
- /// 0--3pi euclidean plane structure (position will coincide with
- /// that on the 0--2pi cylinder, but index labelling it will be
- /// different)
- int main_index;
- /// index of the mirror point (appearing in the range 2pi--3pi) in the
- /// 0--3pi euclidean plane structure
- int mirror_index;
- };
-
- // for each "true" vertex we have reference to indices in the euclidean
- // plane structure
- std::vector<MirrorVertexInfo> _mirror_info;
- // for each index in the euclidean 0--3pi plane structure we want to
- // be able to get back to the "true" vertex index on the overall
- // 0--2pi cylinder structure
- std::vector<int> _cylinder_index_of_plane_vertex;
-
- // NB: we define POINTERS here because the initialisation gave
- // us problems (things crashed!), perhaps because in practice
- // we were making a copy without being careful and defining
- // a proper copy constructor.
- DnnPlane * _DNN;
-
- /// given a phi value in the 0--2pi range return one
- /// in the pi--3pi range.
- inline EtaPhi _remap_phi(const EtaPhi & point) {
- double phi = point.second;
- if (phi < pi) { phi += twopi ;}
- return EtaPhi(point.first, phi);}
-
-
- //----------------------------------------------------------------------
- /// What on earth does this do?
- ///
- /// Example: last true "cylinder" index was 15
- /// last plane index was 23
- ///
- /// Then: _cylinder_index_of_plane_vertex.size() = 24 and
- /// _mirror_info.size() = 16
- ///
- /// IF cylinder_point's phi < pi then
- /// create: _mirror_info[16] = (main_index = 24, mirror_index=25)
- /// _cylinder_index_of_plane_vertex[24] = 16
- /// _cylinder_index_of_plane_vertex[25] = 16
- /// ELSE
- /// create: _mirror_info[16] = (main_index = 24, mirror_index=INEXISTENT..)
- /// _cylinder_index_of_plane_vertex[24] = 16
- ///
- /// ADDITIONALLY push the cylinder_point (and if it exists the mirror
- /// copy) onto the vector plane_points.
- void _RegisterCylinderPoint (const EtaPhi & cylinder_point,
- std::vector<EtaPhi> & plane_points);
-};
-
-
-// here follow some inline implementations of the simpler of the
-// functions defined above
-
-//----------------------------------------------------------------------
-/// Note: one of the difficulties of the 0--3pi mapping is that
-/// a point may have its mirror copy as its own nearest neighbour
-/// (if no other point is within a distance of 2pi). This does
-/// not matter for the kt_algorithm with
-/// reasonable values of radius, but might matter for a general use
-/// of this algorithm -- depending on whether or not the user has
-/// initialised the class with instructions to ignore this problem the
-/// program will detect and ignore it, or crash.
-inline int Dnn3piCylinder::NearestNeighbourIndex(const int & current) const {
- int main_index = _mirror_info[current].main_index;
- int mirror_index = _mirror_info[current].mirror_index;
- int plane_index;
- if (mirror_index == INEXISTENT_VERTEX ) {
- plane_index = _DNN->NearestNeighbourIndex(main_index);
- } else {
- plane_index = (
- _DNN->NearestNeighbourDistance(main_index) <
- _DNN->NearestNeighbourDistance(mirror_index)) ?
- _DNN->NearestNeighbourIndex(main_index) :
- _DNN->NearestNeighbourIndex(mirror_index) ;
- }
- int this_cylinder_index = _cylinder_index_of_plane_vertex[plane_index];
- // either the user has acknowledged the fact that they may get the
- // mirror copy as the closest point, or crash if it should occur
- // that mirror copy is the closest point.
- assert(_ignore_nearest_is_mirror || this_cylinder_index != current);
- //if (this_cylinder_index == current) {
- // std::cerr << "WARNING point "<<current<<
- // " has its mirror copy as its own nearest neighbour"<<endl;
- //}
- return this_cylinder_index;
-}
-
-inline double Dnn3piCylinder::NearestNeighbourDistance(const int & current) const {
- int main_index = _mirror_info[current].main_index;
- int mirror_index = _mirror_info[current].mirror_index;
- if (mirror_index == INEXISTENT_VERTEX ) {
- return _DNN->NearestNeighbourDistance(main_index);
- } else {
- return (
- _DNN->NearestNeighbourDistance(main_index) <
- _DNN->NearestNeighbourDistance(mirror_index)) ?
- _DNN->NearestNeighbourDistance(main_index) :
- _DNN->NearestNeighbourDistance(mirror_index) ;
- }
-
-}
-
-inline bool Dnn3piCylinder::Valid(const int & index) const {
- return (_DNN->Valid(_mirror_info[index].main_index));
-}
-
-
-inline Dnn3piCylinder::~Dnn3piCylinder() {
- delete _DNN;
-}
-
-
-} // fastjet namespace
-
-#endif // __FASTJET_DNN3PICYLINDER_HH__
-#endif // DROP_CGAL
+++ /dev/null
-//STARTHEADER
-// $Id: Dnn4piCylinder.hh 431 2007-01-20 10:44:55Z salam $
-//
-// 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 DROP_CGAL // in case we do not have the code for CGAL
-#ifndef __FASTJET_DNN4PICYLINDER_HH__
-#define __FASTJET_DNN4PICYLINDER_HH__
-
-#include "fastjet/internal/DynamicNearestNeighbours.hh"
-#include "fastjet/internal/DnnPlane.hh"
-#include "fastjet/internal/numconsts.hh"
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-/// class derived from DynamicNearestNeighbours that provides an
-/// implementation for the surface of cylinder (using two copies of
-/// DnnPlane, one running from 0--2pi, the other from pi--3pi).
-class Dnn4piCylinder : public DynamicNearestNeighbours {
- public:
- /// empty initaliser
- Dnn4piCylinder() {}
-
- /// Initialiser from a set of points on an Eta-Phi plane, where
- /// eta can have an arbitrary ranges and phi must be in range
- /// 0 <= phi < 2pi
- Dnn4piCylinder(const std::vector<EtaPhi> &, const bool & verbose = false );
-
- /// Returns the index of the nearest neighbour of point labelled
- /// by ii (assumes ii is valid)
- int NearestNeighbourIndex(const int & ii) const ;
-
- /// Returns the distance to the nearest neighbour of point labelled
- /// by index ii (assumes ii is valid)
- double NearestNeighbourDistance(const int & ii) const ;
-
- /// Returns true iff the given index corresponds to a point that
- /// exists in the DNN structure (meaning that it has been added, and
- /// not removed in the meantime)
- bool Valid(const int & index) const;
-
- void RemoveAndAddPoints(const std::vector<int> & indices_to_remove,
- const std::vector<EtaPhi> & points_to_add,
- std::vector<int> & indices_added,
- std::vector<int> & indices_of_updated_neighbours);
-
- ~Dnn4piCylinder();
-
- private:
-
- bool _verbose;
-
- // NB: we define POINTERS here because the initialisation gave
- // us problems (things crashed!), perhaps because in practice
- // we were making a copy without being careful and defining
- // a proper copy constructor.
- DnnPlane * _DNN1, * _DNN2;
-
- /// given a phi value in the 0--2pi range return one
- /// in the pi--3pi range.
- inline EtaPhi _remap_phi(const EtaPhi & point) {
- double phi = point.second;
- if (phi < pi) { phi += twopi ;}
- return EtaPhi(point.first, phi);}
-
-};
-
-
-// here follow some inline implementations of the simpler of the
-// functions defined above
-
-inline int Dnn4piCylinder::NearestNeighbourIndex(const int & current) const {
- return (_DNN1->NearestNeighbourDistance(current) <
- _DNN2->NearestNeighbourDistance(current)) ?
- _DNN1->NearestNeighbourIndex(current) :
- _DNN2->NearestNeighbourIndex(current) ;
-}
-
-inline double Dnn4piCylinder::NearestNeighbourDistance(const int & current) const {
- return (_DNN1->NearestNeighbourDistance(current) <
- _DNN2->NearestNeighbourDistance(current)) ?
- _DNN1->NearestNeighbourDistance(current) :
- _DNN2->NearestNeighbourDistance(current) ;
-}
-
-inline bool Dnn4piCylinder::Valid(const int & index) const {
- return (_DNN1->Valid(index) && _DNN2->Valid(index));
-}
-
-
-inline Dnn4piCylinder::~Dnn4piCylinder() {
- delete _DNN1;
- delete _DNN2;
-}
-
-
-} // fastjet namespace
-
-#endif // __FASTJET_DNN4PICYLINDER_HH__
-#endif // DROP_CGAL
+++ /dev/null
-//STARTHEADER
-// $Id: DnnPlane.hh 431 2007-01-20 10:44:55Z salam $
-//
-// 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 DROP_CGAL // in case we do not have the code for CGAL
-
-#ifndef __FASTJET_DNNPLANE_HH__
-#define __FASTJET_DNNPLANE_HH__
-
-#include "fastjet/internal/Triangulation.hh"
-#include "fastjet/internal/DynamicNearestNeighbours.hh"
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-
-/// class derived from DynamicNearestNeighbours that provides an
-/// implementation for the Euclidean plane
-class DnnPlane : public DynamicNearestNeighbours {
- public:
- /// empty initaliser
- DnnPlane() {}
-
- /// Initialiser from a set of points on an Eta-Phi plane, where both
- /// eta and phi can have arbitrary ranges
- DnnPlane(const std::vector<EtaPhi> &, const bool & verbose = false );
-
-
- /// Returns the index of the nearest neighbour of point labelled
- /// by ii (assumes ii is valid)
- int NearestNeighbourIndex(const int & ii) const ;
-
- /// Returns the distance to the nearest neighbour of point labelled
- /// by index ii (assumes ii is valid)
- double NearestNeighbourDistance(const int & ii) const ;
-
- /// Returns true iff the given index corresponds to a point that
- /// exists in the DNN structure (meaning that it has been added, and
- /// not removed in the meantime)
- bool Valid(const int & index) const;
-
- void RemoveAndAddPoints(const std::vector<int> & indices_to_remove,
- const std::vector<EtaPhi> & points_to_add,
- std::vector<int> & indices_added,
- std::vector<int> & indices_of_updated_neighbours);
-
- /// returns the EtaPhi of point with index i.
- EtaPhi etaphi(const int i) const;
- /// returns the eta point with index i.
- double eta(const int i) const;
- /// returns the phi point with index i.
- double phi(const int i) const;
-
- private:
-
- /// Structure containing a vertex_handle and cached information on
- /// the nearest neighbour.
- struct SuperVertex {
- Vertex_handle vertex; // NULL indicates inexistence...
- double NNdistance;
- int NNindex;
- // later on for cylinder put a second vertex?
- };
-
- std::vector<SuperVertex> _supervertex;
- //set<Vertex_handle> _vertex_set;
- bool _verbose;
-
- static const bool _crash_on_coincidence = true;
- //static const bool _crash_on_coincidence = false;
-
- Triangulation _TR; /// CGAL object for dealing with triangulations
-
- /// calculates and returns the euclidean distance between points p1
- /// and p2
- inline double _euclid_distance(const Point& p1, const Point& p2) const {
- double distx= p1.x()-p2.x();
- double disty= p1.y()-p2.y();
- return distx*distx+disty*disty;
- }
-
- //----------------------------------------------------------------------
- /// Determines the index and distance of the nearest neighbour to
- /// point j and puts the information into the _supervertex entry for j
- void _SetNearest(const int & j);
-
- //----------------------------------------------------------------------
- /// Determines and stores the nearest neighbour of j.
- ///
- /// For each voronoi neighbour D of j if the distance between j and D
- /// is less than D's own nearest neighbour, then update the
- /// nearest-neighbour info in D; push D's index onto
- /// indices_of_updated_neighbours
- ///
- /// Note that j is NOT pushed onto indices_of_updated_neighbours --
- /// if you want it there, put it there yourself.
- void _SetAndUpdateNearest(const int & j,
- std::vector<int> & indices_of_updated_neighbours);
-
- /// given a vertex_handle returned by CGAL on insertion of a new
- /// points, crash if it turns out that it corresponds to a vertex
- /// that we already knew about (usually because two points coincide)
- void _CrashIfVertexPresent(const Vertex_handle & vertex,
- const int & its_index);
-
-};
-
-
-// here follow some inline implementations of the simpler of the
-// functions defined above
-
-inline int DnnPlane::NearestNeighbourIndex(const int & ii) const {
- return _supervertex[ii].NNindex;}
-
-inline double DnnPlane::NearestNeighbourDistance(const int & ii) const {
- return _supervertex[ii].NNdistance;}
-
-inline bool DnnPlane::Valid(const int & index) const {
- if (index >= 0 && index < static_cast<int>(_supervertex.size())) {
- return (_supervertex[index].vertex != NULL);} else {return false;} }
-
-inline EtaPhi DnnPlane::etaphi(const int i) const {
- Point * p = & (_supervertex[i].vertex->point());
- return EtaPhi(p->x(),p->y()); }
-
-inline double DnnPlane::eta(const int i) const {
- return _supervertex[i].vertex->point().x(); }
-
-inline double DnnPlane::phi(const int i) const {
- return _supervertex[i].vertex->point().y(); }
-
-
-} // fastjet namespace
-
-#endif // __FASTJET_DNNPLANE_HH__
-
-#endif // DROP_CGAL
+++ /dev/null
-//STARTHEADER
-// $Id: DynamicNearestNeighbours.hh 293 2006-08-17 19:38:38Z salam $
-//
-// 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_DYNAMICNEARESTNEIGHBOURS_HH__
-#define __FASTJET_DYNAMICNEARESTNEIGHBOURS_HH__
-
-#include<vector>
-#include<string>
-#include<iostream>
-#include<sstream>
-#include<cassert>
-#include "fastjet/internal/numconsts.hh"
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-/// Shortcut for dealing with eta-phi coordinates.
-//typedef std::pair<double,double> EtaPhi;
-
-/// use a class instead of a pair so that phi can be sanitized
-/// and put into proper range on initialization.
-class EtaPhi {
-public:
- double first, second;
- EtaPhi() {}
- EtaPhi(double a, double b) {first = a; second = b;}
- /// put things into the desired range.
- void sanitize() {
- if (second < 0) second += twopi;
- if (second >= twopi) second -= twopi;
- }
-
-};
-
-/// class corresponding to errors that will be thrown by Dynamic
-/// Nearest Neighbours code
-class DnnError {
-public:
- // constructors
- DnnError() {;};
- DnnError(const std::string & message) {
- _message = message; std::cerr << message << std::endl;};
-
- std::string message() const {return _message;};
-
-private:
- std::string _message;
-};
-
-
-///
-/// Abstract base class for quick location of nearest neighbours in a set of
-/// points, with facilities for adding and removing points from the
-/// set after initialisation. Derived classes will be
-/// named according to the convention DnnSomeName (e.g. DnnPlane).
-///
-/// The main purpose of this abstract base class is to define the
-/// general interface of a whole set of classes that deal with
-/// nearest-neighbour location on different 2-d geometries and with
-/// various underlying data structures and algorithms.
-///
-class DynamicNearestNeighbours {
-
-public:
- /// Dummy initialiser --- does nothing!
- //virtual DynamicNearestNeighbours() {};
-
- /// Initialiser --- sets up the necessary structures to allow efficient
- /// nearest-neighbour finding on the std::vector<EtaPhi> of input points
- //virtual DynamicNearestNeighbours(const std::vector<EtaPhi> &,
- // const bool & verbose = false ) = 0;
-
- /// Returns the index of the nearest neighbour of point labelled
- /// by ii (assumes ii is valid)
- virtual int NearestNeighbourIndex(const int & ii) const = 0;
-
- /// Returns the distance to the nearest neighbour of point labelled
- /// by index ii (assumes ii is valid)
- virtual double NearestNeighbourDistance(const int & ii) const = 0;
-
- /// Returns true iff the given index corresponds to a point that
- /// exists in the DNN structure (meaning that it has been added, and
- /// not removed in the meantime)
- virtual bool Valid(const int & index) const = 0;
-
- /// remove the points labelled by the std::vector indices_to_remove, and
- /// add the points specified by the std::vector points_to_add
- /// (corresponding indices will be calculated automatically); the
- /// idea behind this routine is that the points to be added will
- /// somehow be close to the one or other of the points being removed
- /// and this can be used by the implementation to provide hints for
- /// inserting the new points in whatever structure it is using. In a
- /// kt-algorithm the points being added will be a result of a
- /// combination of the points to be removed -- hence the proximity
- /// is (more or less) guaranteed.
- virtual void RemoveAndAddPoints(const std::vector<int> & indices_to_remove,
- const std::vector<EtaPhi> & points_to_add,
- std::vector<int> & indices_added,
- std::vector<int> & indices_of_updated_neighbours) = 0;
-
-
- /// Remove the point labelled by index and return the list of
- /// points whose nearest neighbours have changed in the process
- inline void RemovePoint (const int & index,
- std::vector<int> & indices_of_updated_neighbours) {
- std::vector<int> indices_added;
- std::vector<EtaPhi> points_to_add;
- std::vector<int> indices_to_remove(1);
- indices_to_remove[0] = index;
- RemoveAndAddPoints(indices_to_remove, points_to_add, indices_added,
- indices_of_updated_neighbours
- );};
-
-
- /// Removes the two points labelled by index1, index2 and adds in the
- /// a point with coordinates newpoint; it returns an index for the new
- /// point (index 3) and a std::vector of indices of neighbours whose
- /// nearest neighbour has changed (the list includes index3, i.e. the new
- /// point).
- inline void RemoveCombinedAddCombination(
- const int & index1, const int & index2,
- const EtaPhi & newpoint,
- int & index3,
- std::vector<int> & indices_of_updated_neighbours) {
- std::vector<int> indices_added(1);
- std::vector<EtaPhi> points_to_add(1);
- std::vector<int> indices_to_remove(2);
- indices_to_remove[0] = index1;
- indices_to_remove[1] = index2;
- points_to_add[0] = newpoint;
- RemoveAndAddPoints(indices_to_remove, points_to_add, indices_added,
- indices_of_updated_neighbours
- );
- index3 = indices_added[0];
- };
-
- /// destructor -- here it is now implemented
- virtual ~DynamicNearestNeighbours () {}
-};
-
-
-} // fastjet namespace
-
-#endif // __FASTJET_DYNAMICNEARESTNEIGHBOURS_HH__
+++ /dev/null
-//STARTHEADER
-// $Id: LimitedWarning.hh 699 2007-06-04 20:20:42Z salam $
-//
-// 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_LIMITEDWARNING_HH__
-#define __FASTJET_LIMITEDWARNING_HH__
-
-#include<iostream>
-#include<string>
-
-/// class to provide facilities for giving warnings up to some maximum
-/// number of times
-class LimitedWarning {
-public:
-
- /// constructor that provides a default maximum number of warnings
- LimitedWarning() : _max_warn(_max_warn_default), _n_warn_so_far(0) {}
-
- /// constructor that provides a used-set max number of warnings
- LimitedWarning(int max_warn) : _max_warn(max_warn), _n_warn_so_far(0) {}
-
- /// output a warning to ostr
- void warn(const std::string & warning, std::ostream & ostr = std::cerr) {
- if (_n_warn_so_far < _max_warn) {
- ostr << "WARNING: ";
- ostr << warning;
- _n_warn_so_far++;
- if (_n_warn_so_far == _max_warn) ostr << " (LAST SUCH WARNING)";
- ostr << std::endl;
- }
- }
-
-private:
- int _max_warn, _n_warn_so_far;
- static const int _max_warn_default = 5;
-
-};
-
-#endif // __FASTJET_LIMITEDWARNING_HH__
+++ /dev/null
-//STARTHEADER
-// $Id: MinHeap.hh 293 2006-08-17 19:38:38Z salam $
-//
-// 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_MINHEAP__HH__
-#define __FASTJET_MINHEAP__HH__
-
-#include<vector>
-#include<cassert>
-#include<memory>
-#include<limits>
-#include "fastjet/internal/base.hh"
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-//======================================================================
-/// A class which provides a "heap"-like structure that allows
-/// access to a the minimal value of a dynamically changing set of numbers
-class MinHeap {
-public:
- /// construct a MinHeap from the vector of values, allowing future
- /// expansion to a maximum size max_size;
- MinHeap (const std::vector<double> & values, unsigned int max_size) :
- _heap(max_size) {_initialise(values);};
-
- /// constructor in which the the maximum size is the size of the values array
- MinHeap (const std::vector<double> & values) :
- _heap(values.size()) {_initialise(values);};
-
- /// return the location of the minimal value on the heap
- inline unsigned int minloc() const {
- return (_heap[0].minloc) - &(_heap[0]);};
-
- /// return the minimal value on the heap
- inline double minval() const {return _heap[0].minloc->value;};
-
- inline double operator[](int i) const {return _heap[i].value;};
-
- /// remove the value at the specified location (i.e. replace it with
- /// the largest possible value).
- void remove(unsigned int loc) {
- update(loc,std::numeric_limits<double>::max());};
-
- /// update the value at the specified location
- void update(unsigned int, double);
-
-private:
-
- struct ValueLoc{
- double value;
- ValueLoc * minloc;
- };
-
- std::vector<ValueLoc> _heap;
-
- void _initialise(const std::vector<double> & values);
-
-
-};
-
-
-} // fastjet namespace
-
-#endif // __FASTJET_MINHEAP__HH__
+++ /dev/null
-//STARTHEADER
-// $Id: SearchTree.hh 1203 2008-04-28 16:10:36Z salam $
-//
-// 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_SEARCHTREE_HH__
-#define __FASTJET_SEARCHTREE_HH__
-
-#include<vector>
-#include<cassert>
-#include<cstddef>
-#include "fastjet/internal/base.hh"
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-
-//======================================================================
-/// This is the class for a search tree designed to be especially efficient
-/// when looking for successors and predecessors (to be used in Chan's
-/// CP algorithm). It has the requirement that the maximum size of the
-/// search tree must be known in advance.
-template<class T> class SearchTree {
-public:
-
- class Node;
- class circulator;
- class const_circulator;
-
- /// constructor for a search tree from an ordered vector
- SearchTree(const std::vector<T> & init);
-
- /// constructor for a search tree from an ordered vector allowing
- /// for future growth beyond the current size, up to max_size
- SearchTree(const std::vector<T> & init, unsigned int max_size);
-
- /// remove the node corresponding to node_index from the search tree
- void remove(unsigned node_index);
- void remove(typename SearchTree::Node * node);
- void remove(typename SearchTree::circulator & circ);
-
- /// insert the supplied value into the tree and return a pointer to
- /// the relevant SearchTreeNode.
- //Node * insert(const T & value);
- circulator insert(const T & value);
-
- const Node & operator[](int i) const {return _nodes[i];};
-
- /// return the number of elements currently in the search tree
- unsigned int size() const {return _nodes.size() - _available_nodes.size();}
-
- /// check that the structure we've obtained makes sense...
- void verify_structure();
- void verify_structure_linear() const;
- void verify_structure_recursive(const Node * , const Node * , const Node * ) const;
-
- /// print out all elements...
- void print_elements();
-
- // tracking the depth may have some speed overhead -- so leave it
- // out for the time being...
-#ifdef TRACK_DEPTH
- /// the max depth the tree has ever reached
- inline unsigned int max_depth() const {return _max_depth;};
-#else
- inline unsigned int max_depth() const {return 0;};
-#endif
-
- int loc(const Node * node) const ;
-
- /// return predecessor by walking through the tree
- Node * _find_predecessor(const Node *);
- /// return successor by walking through the tree
- Node * _find_successor(const Node *);
-
- const Node & operator[](unsigned int i) const {return _nodes[i];};
-
- /// return a circulator to some place in the tree (with a circulator
- /// you don't care where...)
- const_circulator somewhere() const;
- circulator somewhere();
-
-private:
-
- void _initialize(const std::vector<T> & init);
-
- std::vector<Node> _nodes;
- std::vector<Node *> _available_nodes;
- Node * _top_node;
- unsigned int _n_removes;
-
-
- /// recursive routine for doing the initial connections assuming things
- /// are ordered. Assumes this_one's parent is labelled, and was
- /// generated at a scale "scale" -- connections will be carried out
- /// including left edge and excluding right edge
- void _do_initial_connections(unsigned int this_one, unsigned int scale,
- unsigned int left_edge, unsigned int right_edge,
- unsigned int depth);
-
-
-#ifdef TRACK_DEPTH
- unsigned int _max_depth;
-#endif
-
-};
-
-
-//======================================================================
-template<class T> class SearchTree<T>::Node{
-public:
- Node() {}; /// default constructor
-
-
- /// returns tree if all the tree-related links are set to null for this node
- bool treelinks_null() const {
- return ((parent==0) && (left==0) && (right==0));};
-
- /// set all the tree-related links are set to null for this node
- inline void nullify_treelinks() {
- parent = NULL;
- left = NULL;
- right = NULL;
- };
-
- /// if my parent exists, determine whether I am it's left or right
- /// node and set the relevant link equal to XX.
- void reset_parents_link_to_me(Node * XX);
-
- T value;
- Node * left;
- Node * right;
- Node * parent;
- Node * successor;
- Node * predecessor;
-};
-
-//----------------------------------------------------------------------
-template<class T> void SearchTree<T>::Node::reset_parents_link_to_me(typename SearchTree<T>::Node * XX) {
- if (parent == NULL) {return;}
- if (parent->right == this) {parent->right = XX;}
- else {parent->left = XX;}
-}
-
-
-
-//======================================================================
-template<class T> class SearchTree<T>::circulator{
-public:
-
- // so that it can access out _node object;
- friend class SearchTree<T>::const_circulator;
- friend class SearchTree<T>;
-
- circulator() : _node(NULL) {}
-
- circulator(Node * node) : _node(node) {}
-
- const T * operator->() const {return &(_node->value);}
- T * operator->() {return &(_node->value);}
- const T & operator*() const {return _node->value;}
- T & operator*() {return _node->value;}
-
- /// prefix increment (structure copied from stl_bvector.h)
- circulator & operator++() {
- _node = _node->successor;
- return *this;}
-
- /// postfix increment ["int" argument tells compiler it's postfix]
- /// (structure copied from stl_bvector.h)
- circulator operator++(int) {
- circulator tmp = *this;
- _node = _node->successor;
- return tmp;}
-
- /// prefix decrement (structure copied from stl_bvector.h)
- circulator & operator--() {
- _node = _node->predecessor;
- return *this;}
-
- /// postfix decrement ["int" argument tells compiler it's postfix]
- /// (structure copied from stl_bvector.h)
- circulator operator--(int) {
- circulator tmp = *this;
- _node = _node->predecessor;
- return tmp;}
-
- /// return a circulator referring to the next node
- circulator next() const {
- return circulator(_node->successor);}
-
- /// return a circulator referring to the previous node
- circulator previous() const {
- return circulator(_node->predecessor);}
-
- bool operator!=(const circulator & other) const {return other._node != _node;}
- bool operator==(const circulator & other) const {return other._node == _node;}
-
-private:
- Node * _node;
-};
-
-
-//======================================================================
-template<class T> class SearchTree<T>::const_circulator{
-public:
-
- const_circulator() : _node(NULL) {}
-
- const_circulator(const Node * node) : _node(node) {}
- const_circulator(const circulator & circ) :_node(circ._node) {}
-
- const T * operator->() {return &(_node->value);}
- const T & operator*() const {return _node->value;}
-
- /// prefix increment (structure copied from stl_bvector.h)
- const_circulator & operator++() {
- _node = _node->successor;
- return *this;}
-
- /// postfix increment ["int" argument tells compiler it's postfix]
- /// (structure copied from stl_bvector.h)
- const_circulator operator++(int) {
- const_circulator tmp = *this;
- _node = _node->successor;
- return tmp;}
-
-
- /// prefix decrement (structure copied from stl_bvector.h)
- const_circulator & operator--() {
- _node = _node->predecessor;
- return *this;}
-
- /// postfix decrement ["int" argument tells compiler it's postfix]
- /// (structure copied from stl_bvector.h)
- const_circulator operator--(int) {
- const_circulator tmp = *this;
- _node = _node->predecessor;
- return tmp;}
-
- /// return a circulator referring to the next node
- const_circulator next() const {
- return const_circulator(_node->successor);}
-
- /// return a circulator referring to the previous node
- const_circulator previous() const {
- return const_circulator(_node->predecessor);}
-
-
-
- bool operator!=(const const_circulator & other) const {return other._node != _node;}
- bool operator==(const const_circulator & other) const {return other._node == _node;}
-
-private:
- const Node * _node;
-};
-
-
-
-
-//----------------------------------------------------------------------
-/// initialise from a sorted initial array allowing for a larger
-/// maximum size of the array...
-template<class T> SearchTree<T>::SearchTree(const std::vector<T> & init,
- unsigned int max_size) :
- _nodes(max_size) {
-
- _available_nodes.reserve(max_size);
- _available_nodes.resize(max_size - init.size());
- for (unsigned int i = init.size(); i < max_size; i++) {
- _available_nodes[i-init.size()] = &(_nodes[i]);
- }
-
- _initialize(init);
-}
-
-//----------------------------------------------------------------------
-/// initialise from a sorted initial array
-template<class T> SearchTree<T>::SearchTree(const std::vector<T> & init) :
- _nodes(init.size()), _available_nodes(0) {
-
- // reserve space for the list of available nodes
- _available_nodes.reserve(init.size());
- _initialize(init);
-}
-
-//----------------------------------------------------------------------
-/// do the actual hard work of initialization
-template<class T> void SearchTree<T>::_initialize(const std::vector<T> & init) {
-
- _n_removes = 0;
- unsigned n = init.size();
- assert(n>=1);
-
- // reserve space for the list of available nodes
- //_available_nodes.reserve();
-
-#ifdef TRACK_DEPTH
- _max_depth = 0;
-#endif
-
-
- // validate the input
- for (unsigned int i = 1; i<n; i++) {
- assert(!(init[i] < init[i-1]));
- }
-
- // now initialise the vector; link neighbours in the sequence
- for(unsigned int i = 0; i < n; i++) {
- _nodes[i].value = init[i];
- _nodes[i].predecessor = (& (_nodes[i])) - 1;
- _nodes[i].successor = (& (_nodes[i])) + 1;
- _nodes[i].nullify_treelinks();
- }
- // make a loop structure so that we can circulate...
- _nodes[0].predecessor = (& (_nodes[n-1]));
- _nodes[n-1].successor = (& (_nodes[0]));
-
- // now label the rest of the nodes
- unsigned int scale = (n+1)/2;
- unsigned int top = std::min(n-1,scale);
- _nodes[top].parent = NULL;
- _top_node = &(_nodes[top]);
- _do_initial_connections(top, scale, 0, n, 0);
-
- // make sure things are sensible...
- //verify_structure();
-}
-
-
-
-//----------------------------------------------------------------------
-template<class T> inline int SearchTree<T>::loc(const Node * node) const {return node == NULL?
- -999 : node - &(_nodes[0]);}
-
-
-//----------------------------------------------------------------------
-/// Recursive creation of connections, assuming the _nodes vector is
-/// completely filled and ordered
-template<class T> void SearchTree<T>::_do_initial_connections(
- unsigned int this_one,
- unsigned int scale,
- unsigned int left_edge,
- unsigned int right_edge,
- unsigned int depth
- ) {
-
-#ifdef TRACK_DEPTH
- // keep track of tree depth for checking things stay reasonable...
- _max_depth = max(depth, _max_depth);
-#endif
-
- //std::cout << this_one << " "<< scale<< std::endl;
- unsigned int ref_new_scale = (scale+1)/2;
-
- // work through children to our left
- unsigned new_scale = ref_new_scale;
- bool did_child = false;
- while(true) {
- int left = this_one - new_scale; // be careful here to use signed int...
- // if there is something unitialised to our left, link to it
- if (left >= static_cast<int>(left_edge)
- && _nodes[left].treelinks_null() ) {
- _nodes[left].parent = &(_nodes[this_one]);
- _nodes[this_one].left = &(_nodes[left]);
- // create connections between left_edge and this_one
- _do_initial_connections(left, new_scale, left_edge, this_one, depth+1);
- did_child = true;
- break;
- }
- // reduce the scale so as to try again
- unsigned int old_new_scale = new_scale;
- new_scale = (old_new_scale + 1)/2;
- // unless we've reached end of tree
- if (new_scale == old_new_scale) break;
- }
- if (!did_child) {_nodes[this_one].left = NULL;}
-
-
- // work through children to our right
- new_scale = ref_new_scale;
- did_child = false;
- while(true) {
- unsigned int right = this_one + new_scale;
- if (right < right_edge && _nodes[right].treelinks_null()) {
- _nodes[right].parent = &(_nodes[this_one]);
- _nodes[this_one].right = &(_nodes[right]);
- // create connections between this_one+1 and right_edge
- _do_initial_connections(right, new_scale, this_one+1,right_edge,depth+1);
- did_child = true;
- break;
- }
- // reduce the scale so as to try again
- unsigned int old_new_scale = new_scale;
- new_scale = (old_new_scale + 1)/2;
- // unless we've reached end of tree
- if (new_scale == old_new_scale) break;
- }
- if (!did_child) {_nodes[this_one].right = NULL;}
-
-}
-
-
-
-//----------------------------------------------------------------------
-template<class T> void SearchTree<T>::remove(unsigned int node_index) {
- remove(&(_nodes[node_index]));
-}
-
-//----------------------------------------------------------------------
-template<class T> void SearchTree<T>::remove(circulator & circ) {
- remove(circ._node);
-}
-
-//----------------------------------------------------------------------
-// Useful reference for this:
-// http://en.wikipedia.org/wiki/Binary_search_tree#Deletion
-template<class T> void SearchTree<T>::remove(typename SearchTree<T>::Node * node) {
-
- // we don't remove things from the tree if we've reached the last
- // elements... (is this wise?)
- assert(size() > 1); // switch this to throw...?
- assert(!node->treelinks_null());
-
- // deal with relinking predecessor and successor
- node->predecessor->successor = node->successor;
- node->successor->predecessor = node->predecessor;
-
- if (node->left == NULL && node->right == NULL) {
- // node has no children, so remove it by nullifying the pointer
- // from the parent
- node->reset_parents_link_to_me(NULL);
-
- } else if (node->left != NULL && node->right == NULL){
- // make parent point to my child
- node->reset_parents_link_to_me(node->left);
- // and child to parent
- node->left->parent = node->parent;
- // sort out the top node...
- if (_top_node == node) {_top_node = node->left;}
-
- } else if (node->left == NULL && node->right != NULL){
- // make parent point to my child
- node->reset_parents_link_to_me(node->right);
- // and child to parent
- node->right->parent = node->parent;
- // sort out the top node...
- if (_top_node == node) {_top_node = node->right;}
-
- } else {
- // we have two children; we will put a replacement in our place
- Node * replacement;
- //SearchTree<T>::Node * replacements_child;
- // chose predecessor or successor (one, then other, then first, etc...)
- bool use_predecessor = (_n_removes % 2 == 1);
- if (use_predecessor) {
- // Option 1: put predecessor in our place, and have its parent
- // point to its left child (as a predecessor it has no right child)
- replacement = node->predecessor;
- assert(replacement->right == NULL); // guaranteed if it's our predecessor
- // we have to be careful of replacing certain links when the
- // replacement is this node's child
- if (replacement != node->left) {
- if (replacement->left != NULL) {
- replacement->left->parent = replacement->parent;}
- replacement->reset_parents_link_to_me(replacement->left);
- replacement->left = node->left;
- }
- replacement->parent = node->parent;
- replacement->right = node->right;
- } else {
- // Option 2: put successor in our place, and have its parent
- // point to its right child (as a successor it has no left child)
- replacement = node->successor;
- assert(replacement->left == NULL); // guaranteed if it's our successor
- if (replacement != node->right) {
- if (replacement->right != NULL) {
- replacement->right->parent = replacement->parent;}
- replacement->reset_parents_link_to_me(replacement->right);
- replacement->right = node->right;
- }
- replacement->parent = node->parent;
- replacement->left = node->left;
- }
- node->reset_parents_link_to_me(replacement);
-
- // make sure node's original children now point to the replacement
- if (node->left != replacement) {node->left->parent = replacement;}
- if (node->right != replacement) {node->right->parent = replacement;}
-
- // sort out the top node...
- if (_top_node == node) {_top_node = replacement;}
- }
-
- // make sure we leave something nice and clean...
- node->nullify_treelinks();
- node->predecessor = NULL;
- node->successor = NULL;
-
- // for bookkeeping (and choosing whether to use pred. or succ.)
- _n_removes++;
- // for when we next need access to a free node...
- _available_nodes.push_back(node);
-}
-
-
-//----------------------------------------------------------------------
-//template<class T> typename SearchTree<T>::Node * SearchTree<T>::insert(const T & value) {
-
-//----------------------------------------------------------------------
-template<class T> typename SearchTree<T>::circulator SearchTree<T>::insert(const T & value) {
- // make sure we don't exceed allowed number of nodes...
- assert(_available_nodes.size() > 0);
-
- Node * node = _available_nodes.back();
- _available_nodes.pop_back();
- node->value = value;
-
- Node * location = _top_node;
- Node * old_location = NULL;
- bool on_left = true; // (init not needed -- but soothes g++4)
- // work through tree until we reach its end
-#ifdef TRACK_DEPTH
- unsigned int depth = 0;
-#endif
- while(location != NULL) {
-#ifdef TRACK_DEPTH
- depth++;
-#endif
- old_location = location;
- on_left = value < location->value;
- if (on_left) {location = location->left;}
- else {location = location->right;}
- }
-#ifdef TRACK_DEPTH
- _max_depth = max(depth, _max_depth);
-#endif
- // now create tree links
- node->parent = old_location;
- if (on_left) {node->parent->left = node;}
- else {node->parent->right = node;}
- node->left = NULL;
- node->right = NULL;
- // and create predecessor / successor links
- node->predecessor = _find_predecessor(node);
- if (node->predecessor != NULL) {
- // it exists, so make use of its info (will include a cyclic case,
- // when successor is round the bend)
- node->successor = node->predecessor->successor;
- node->predecessor->successor = node;
- node->successor->predecessor = node;
- } else {
- // deal with case when we are left-most edge of tree (then successor
- // will exist...)
- node->successor = _find_successor(node);
- assert(node->successor != NULL); // can only happen if we're sole element
- // (but not allowed, since tree size>=1)
- node->predecessor = node->successor->predecessor;
- node->successor->predecessor = node;
- node->predecessor->successor = node;
- }
-
- return circulator(node);
-}
-
-
-//----------------------------------------------------------------------
-template<class T> void SearchTree<T>::verify_structure() {
-
- // do a check running through all elements
- verify_structure_linear();
-
- // do a recursive check down tree from top
-
- // first establish the extremities
- const Node * left_limit = _top_node;
- while (left_limit->left != NULL) {left_limit = left_limit->left;}
- const Node * right_limit = _top_node;
- while (right_limit->right != NULL) {right_limit = right_limit->right;}
-
- // then actually do recursion
- verify_structure_recursive(_top_node, left_limit, right_limit);
-}
-
-
-//----------------------------------------------------------------------
-template<class T> void SearchTree<T>::verify_structure_recursive(
- const typename SearchTree<T>::Node * element,
- const typename SearchTree<T>::Node * left_limit,
- const typename SearchTree<T>::Node * right_limit) const {
-
- assert(!(element->value < left_limit->value));
- assert(!(right_limit->value < element->value));
-
- const Node * left = element->left;
- if (left != NULL) {
- assert(!(element->value < left->value));
- if (left != left_limit) {
- // recurse down the tree with this element as the right-hand limit
- verify_structure_recursive(left, left_limit, element);}
- }
-
- const Node * right = element->right;
- if (right != NULL) {
- assert(!(right->value < element->value));
- if (right != right_limit) {
- // recurse down the tree with this element as the left-hand limit
- verify_structure_recursive(right, element, right_limit);}
- }
-}
-
-//----------------------------------------------------------------------
-template<class T> void SearchTree<T>::verify_structure_linear() const {
-
- //print_elements();
-
- unsigned n_top = 0;
- unsigned n_null = 0;
- for(unsigned i = 0; i < _nodes.size(); i++) {
- const typename SearchTree<T>::Node * node = &(_nodes[i]);
- // make sure node is defined
- if (node->treelinks_null()) {n_null++; continue;}
-
- // make sure of the number of "top" nodes
- if (node->parent == NULL) {
- n_top++;
- //assert(node->left != NULL);
- //assert(node->right != NULL);
- } else {
- // make sure that I am a child of my parent...
- //assert((node->parent->left == node) || (node->parent->right == node));
- assert((node->parent->left == node) ^ (node->parent->right == node));
- }
-
- // when there is a left child make sure it's value is ordered
- // (note use of !(b<a), to allow for a<=b while using just the <
- // operator)
- if (node->left != NULL) {
- assert(!(node->value < node->left->value ));}
-
- // when there is a right child make sure it's value is ordered
- if (node->right != NULL) {
- assert(!(node->right->value < node->value ));}
-
- }
- assert(n_top == 1 || (n_top == 0 && size() <= 1) );
- assert(n_null == _available_nodes.size() ||
- (n_null == _available_nodes.size() + 1 && size() == 1));
-}
-
-
-//----------------------------------------------------------------------
-template<class T> typename SearchTree<T>::Node * SearchTree<T>::_find_predecessor(const typename SearchTree<T>::Node * node) {
-
- typename SearchTree<T>::Node * newnode;
- if (node->left != NULL) {
- // go down left, and then down right as far as possible.
- newnode = node->left;
- while(newnode->right != NULL) {newnode = newnode->right;}
- return newnode;
- } else {
- const typename SearchTree<T>::Node * lastnode = node;
- newnode = node->parent;
- // go up the tree as long as we're going right (when we go left then
- // we've found something smaller, so stop)
- while(newnode != NULL) {
- if (newnode->right == lastnode) {return newnode;}
- lastnode = newnode;
- newnode = newnode->parent;
- }
- return newnode;
- }
-}
-
-
-//----------------------------------------------------------------------
-template<class T> typename SearchTree<T>::Node * SearchTree<T>::_find_successor(const typename SearchTree<T>::Node * node) {
-
- typename SearchTree<T>::Node * newnode;
- if (node->right != NULL) {
- // go down right, and then down left as far as possible.
- newnode = node->right;
- while(newnode->left != NULL) {newnode = newnode->left;}
- return newnode;
- } else {
- const typename SearchTree<T>::Node * lastnode = node;
- newnode = node->parent;
- // go up the tree as long as we're going left (when we go right then
- // we've found something larger, so stop)
- while(newnode != NULL) {
- if (newnode->left == lastnode) {return newnode;}
- lastnode = newnode;
- newnode = newnode->parent;
- }
- return newnode;
- }
-}
-
-
-//----------------------------------------------------------------------
-// print out all the elements for visual checking...
-template<class T> void SearchTree<T>::print_elements() {
- typename SearchTree<T>::Node * base_node = &(_nodes[0]);
- typename SearchTree<T>::Node * node = base_node;
-
- int n = _nodes.size();
- for(; node - base_node < n ; node++) {
- printf("%4d parent:%4d left:%4d right:%4d pred:%4d succ:%4d value:%10.6f\n",loc(node), loc(node->parent), loc(node->left), loc(node->right), loc(node->predecessor),loc(node->successor),node->value);
- }
-}
-
-//----------------------------------------------------------------------
-template<class T> typename SearchTree<T>::circulator SearchTree<T>::somewhere() {
- return circulator(_top_node);
-}
-
-
-//----------------------------------------------------------------------
-template<class T> typename SearchTree<T>::const_circulator SearchTree<T>::somewhere() const {
- return const_circulator(_top_node);
-}
-
-
-} // fastjet namespace
-
-#endif // __FASTJET_SEARCHTREE_HH__
+++ /dev/null
-//STARTHEADER
-// $Id: Triangulation.hh 293 2006-08-17 19:38:38Z salam $
-//
-// 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 DROP_CGAL // in case we do not have the code for CGAL
-#ifndef __FASTJET_TRIANGULATION__
-#define __FASTJET_TRIANGULATION__
-
-// file: examples/Triangulation_2/Voronoi.C
-#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
-#include <CGAL/Delaunay_triangulation_2.h>
-#include <CGAL/Triangulation_hierarchy_2.h>
-#include <CGAL/Triangulation_vertex_base_with_info_2.h>
-#include "fastjet/internal/base.hh"
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-/// the basic geometrical kernel that lies at the base of all CGAL
-/// operations
-#ifdef CGAL_SIMPLE_KERNEL
-struct K : CGAL::Simple_cartesian<double> {};
-#else
-struct K : CGAL::Exact_predicates_inexact_constructions_kernel {};
-#endif // CGAL_SIMPLE_KERNEL
-
-// our extras to help us navigate, find distance, etc.
-const int INFINITE_VERTEX=-1;
-const int NEW_VERTEX=-2;
-const double HUGE_DOUBLE=1e300;
-
-/// A class to provide an "int" with an initial value.
-class InitialisedInt {
- private:
- int _val;
- public:
- inline InitialisedInt () {_val=NEW_VERTEX;};
- inline InitialisedInt& operator= (int value) {_val = value; return *this;};
- inline int val() const {return _val;};
-};
-
-
-// We can have triangulations with and without hierarchies -- those with
-// are able to guarantee N ln N time for the construction of a large
-// triangulation, whereas those without go as N^{3/2} for points
-// sufficiently uniformly distributed in a plane.
-//
-//#define NOHIERARCHY
-#ifdef NOHIERARCHY
-typedef CGAL::Triangulation_vertex_base_with_info_2<InitialisedInt,K> Vb;
-typedef CGAL::Triangulation_face_base_2<K> Fb;
-typedef CGAL::Triangulation_data_structure_2<Vb,Fb> Tds;
-typedef CGAL::Delaunay_triangulation_2<K,Tds> Triangulation;
-#else
-typedef CGAL::Triangulation_vertex_base_with_info_2<InitialisedInt,K> Vbb;
-typedef CGAL::Triangulation_hierarchy_vertex_base_2<Vbb> Vb;
-typedef CGAL::Triangulation_face_base_2<K> Fb;
-typedef CGAL::Triangulation_data_structure_2<Vb,Fb> Tds;
-typedef CGAL::Delaunay_triangulation_2<K,Tds> Dt;
-typedef CGAL::Triangulation_hierarchy_2<Dt> Triangulation;
-#endif
-
-typedef Triangulation::Vertex_handle Vertex_handle;
-typedef Triangulation::Point Point; /// CGAL Point structure
-typedef Triangulation::Vertex_circulator Vertex_circulator;
-typedef Triangulation::Face_circulator Face_circulator;
-typedef Triangulation::Face_handle Face_handle;
-
-
-
-} // fastjet namespace
-
-#endif // __FASTJET_TRIANGULATION__
-#endif // DROP_CGAL
+++ /dev/null
-#ifndef __FASTJET__VORONOI_H__
-#define __FASTJET__VORONOI_H__
-
-//STARTHEADER
-// $Id: Voronoi.hh 1161 2008-04-01 20:29:38Z soyez $
-//
-// Copyright (c) 1994 by AT&T Bell Laboratories (see below)
-//
-//
-//----------------------------------------------------------------------
-// This file is included as part of FastJet but was mostly written by
-// S. Fortune in C, put into C++ with memory management by S
-// O'Sullivan, and with further interface and memeory management
-// modifications by Gregory Soyez.
-//
-// Permission to use, copy, modify, and distribute this software for
-// any purpose without fee is hereby granted, provided that this
-// entire notice is included in all copies of any software which is or
-// includes a copy or modification of this software and in all copies
-// of the supporting documentation for such software. THIS SOFTWARE IS
-// BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED WARRANTY.
-// IN PARTICULAR, NEITHER THE AUTHORS NOR AT&T MAKE ANY REPRESENTATION
-// OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY OF THIS
-// SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
-//
-//----------------------------------------------------------------------
-//ENDHEADER
-
-
-/*
-* The author of this software is Steven Fortune.
-* Copyright (c) 1994 by AT&T Bell Laboratories.
-* Permission to use, copy, modify, and distribute this software for any
-* purpose without fee is hereby granted, provided that this entire notice
-* is included in all copies of any software which is or includes a copy
-* or modification of this software and in all copies of the supporting
-* documentation for such software.
-* THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
-* WARRANTY. IN PARTICULAR, NEITHER THE AUTHORS NOR AT&T MAKE ANY
-* REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
-* OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
-*/
-
-/*
-* This code was originally written by Stephan Fortune in C code. I,
-* Shane O'Sullivan, have since modified it, encapsulating it in a C++
-* class and, fixing memory leaks and adding accessors to the Voronoi
-* Edges. Permission to use, copy, modify, and distribute this
-* software for any purpose without fee is hereby granted, provided
-* that this entire notice is included in all copies of any software
-* which is or includes a copy or modification of this software and in
-* all copies of the supporting documentation for such software. THIS
-* SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
-* WARRANTY. IN PARTICULAR, NEITHER THE AUTHORS NOR AT&T MAKE ANY
-* REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE
-* MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
-* PURPOSE.
-*/
-
-#include "fastjet/ClusterSequenceWithArea.hh"
-#include <vector>
-#include <math.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define DELETED -2
-#define le 0
-#define re 1
-
-//using namespace std;
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-/**
- * \class Point
- * class to handle a 2d point
- */
-class Point{
-public:
- /// defailt ctor
- Point() : x(0.0), y(0.0) {}
-
- /// ctor with initialisation
- Point(double _x, double _y) : x(_x), y(_y) {}
-
- /// addition
- inline Point operator + (const Point &p) const{
- return Point(x+p.x, y+p.y);
- }
-
- /// subtraction
- inline Point operator - (const Point &p) const{
- return Point(x-p.x, y-p.y);
- }
-
- /// scalar multiplication
- inline Point operator * (const double t) const{
- return Point(x*t, y*t);
- }
-
- /// vector coordinates
- double x,y;
-};
-
-
-/// norm of a vector
-inline double norm(const Point p){
- return p.x*p.x+p.y*p.y;
-}
-
-
-/// 2D vector product
-inline double vector_product(const Point &p1, const Point &p2){
- return p1.x*p2.y-p1.y*p2.x;
-}
-
-
-/// scalar product
-inline double scalar_product(const Point &p1, const Point &p2){
- return p1.x*p2.x+p1.y*p2.y;
-}
-
-
-/**
- * \class GraphEdge
- * handle an edge of the Voronoi Diagram.
- */
-class GraphEdge{
-public:
- /// coordinates of the extreme points
- double x1,y1,x2,y2;
-
- /// indices of the parent sites that define the edge
- int point1, point2;
-
- /// pointer to the next edge
- GraphEdge* next;
-};
-
-
-/**
- * \class Site
- * structure used both for particle sites and for vertices.
- */
-class Site{
- public:
- Point coord;
- int sitenbr;
- int refcnt;
-};
-
-
-
-class Freenode{
-public:
- Freenode *nextfree;
-};
-
-
-class FreeNodeArrayList{
-public:
- Freenode* memory;
- FreeNodeArrayList* next;
-};
-
-
-class Freelist{
-public:
- Freenode *head;
- int nodesize;
-};
-
-class Edge{
-public:
- double a,b,c;
- Site *ep[2];
- Site *reg[2];
- int edgenbr;
-};
-
-
-class Halfedge{
-public:
- Halfedge *ELleft, *ELright;
- Edge *ELedge;
- int ELrefcnt;
- char ELpm;
- Site *vertex;
- volatile double ystar;
- Halfedge *PQnext;
-};
-
-
-class VoronoiDiagramGenerator{
-public:
- VoronoiDiagramGenerator();
- ~VoronoiDiagramGenerator();
-
- bool generateVoronoi(std::vector<Point> *_parent_sites,
- double minX, double maxX, double minY, double maxY,
- double minDist=0);
-
- inline void resetIterator(){
- iteratorEdges = allEdges;
- }
-
- bool getNext(GraphEdge **e){
- if(iteratorEdges == 0)
- return false;
-
- *e = iteratorEdges;
- iteratorEdges = iteratorEdges->next;
- return true;
- }
-
- std::vector<Point> *parent_sites;
- int n_parent_sites;
-
-private:
- void cleanup();
- void cleanupEdges();
- char *getfree(Freelist *fl);
- Halfedge *PQfind();
- int PQempty();
-
- Halfedge **ELhash;
- Halfedge *HEcreate(), *ELleft(), *ELright(), *ELleftbnd();
- Halfedge *HEcreate(Edge *e,int pm);
-
- Point PQ_min();
- Halfedge *PQextractmin();
- void freeinit(Freelist *fl,int size);
- void makefree(Freenode *curr,Freelist *fl);
- void geominit();
- void plotinit();
- bool voronoi(int triangulate);
- void ref(Site *v);
- void deref(Site *v);
- void endpoint(Edge *e,int lr,Site * s);
-
- void ELdelete(Halfedge *he);
- Halfedge *ELleftbnd(Point *p);
- Halfedge *ELright(Halfedge *he);
- void makevertex(Site *v);
- void out_triple(Site *s1, Site *s2,Site * s3);
-
- void PQinsert(Halfedge *he,Site * v, double offset);
- void PQdelete(Halfedge *he);
- bool ELinitialize();
- void ELinsert(Halfedge *lb, Halfedge *newHe);
- Halfedge * ELgethash(int b);
- Halfedge *ELleft(Halfedge *he);
- Site *leftreg(Halfedge *he);
- void out_site(Site *s);
- bool PQinitialize();
- int PQbucket(Halfedge *he);
- void clip_line(Edge *e);
- char *myalloc(unsigned n);
- int right_of(Halfedge *el,Point *p);
-
- Site *rightreg(Halfedge *he);
- Edge *bisect(Site *s1, Site *s2);
- double dist(Site *s,Site *t);
- Site *intersect(Halfedge *el1, Halfedge *el2, Point *p=0);
-
- void out_bisector(Edge *e);
- void out_ep(Edge *e);
- void out_vertex(Site *v);
- Site *nextone();
-
- void pushGraphEdge(double x1, double y1, double x2, double y2,
- Site *s1, Site *s2);
-
- void openpl();
- void circle(double x, double y, double radius);
- void range(double minX, double minY, double maxX, double maxY);
-
- Freelist hfl;
- Halfedge *ELleftend, *ELrightend;
- int ELhashsize;
-
- int triangulate, sorted, plot, debug;
- double xmin, xmax, ymin, ymax, deltax, deltay;
-
- Site *sites;
- int nsites;
- int siteidx;
- int sqrt_nsites;
- int nvertices;
- Freelist sfl;
- Site *bottomsite;
-
- int nedges;
- Freelist efl;
- int PQhashsize;
- Halfedge *PQhash;
- int PQcount;
- int PQmin;
-
- int ntry, totalsearch;
- double pxmin, pxmax, pymin, pymax, cradius;
- int total_alloc;
-
- double borderMinX, borderMaxX, borderMinY, borderMaxY;
-
- FreeNodeArrayList* allMemoryList;
- FreeNodeArrayList* currentMemoryBlock;
-
- GraphEdge* allEdges;
- GraphEdge* iteratorEdges;
-
- double minDistanceBetweenSites;
-};
-
-int scomp(const void *p1,const void *p2);
-
-
-} // fastjet namespace
-
-#endif
+++ /dev/null
-
-//STARTHEADER
-// $Id: base.hh 293 2006-08-17 19:38:38Z salam $
-//
-// 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_FASTJET_BASE_HH__
-#define __FASTJET_FASTJET_BASE_HH__
-
-// define this for easier readability (and obfuscation?) in
-// a range of places
-// #define FASTJET_BEGIN_NAMESPACE namespace fastjet {
-// #define FASTJET_END_NAMESPACE }
-
-#endif // __FASTJET_FASTJET_BASE_HH__
+++ /dev/null
-//STARTHEADER
-// $Id: numconsts.hh 293 2006-08-17 19:38:38Z salam $
-//
-// 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_NUMCONSTS__
-#define __FASTJET_NUMCONSTS__
-
-#include "fastjet/internal/base.hh"
-
-namespace fastjet { // defined in fastjet/internal/base.hh
-
-// some common useful constants!
-
-const double pi = 3.141592653589793238462643383279502884197;
-const double twopi = 6.283185307179586476925286766559005768394;
-const double pisq = 9.869604401089358618834490999876151135314;
-const double zeta2 = 1.644934066848226436472415166646025189219;
-const double zeta3 = 1.202056903159594285399738161511449990765;
-const double eulergamma = 0.577215664901532860606512090082402431042;
-const double ln2 = 0.693147180559945309417232121458176568076;
-
-
-} // fastjet namespace
-
-#endif // __FASTJET_NUMCONSTS__
+++ /dev/null
-//STARTHEADER
-// $Id: version.hh 939 2007-11-08 12:18:08Z salam $
-//
-// Copyright (c) 2005-2007, 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_VERSION_HH__
-#define __FASTJET_VERSION_HH__
-
-#include<string>
-#include "fastjet/config.h"
-
-namespace fastjet {
-
-const char* fastjet_version = PACKAGE_VERSION;
-
-} // fastjet namespace
-
-#endif // __FASTJET_VERSION_HH__
+++ /dev/null
-// -*- C++ -*-
-///////////////////////////////////////////////////////////////////////////////
-// File: area.h //
-// Description: header file for the computation of jet area //
-// This file is part of the SISCone project. //
-// For more details, see http://projects.hepforge.org/siscone //
-// //
-// Copyright (c) 2006 Gavin Salam and Gregory Soyez //
-// //
-// This program 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. //
-// //
-// This program 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 this program; if not, write to the Free Software //
-// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
-// //
-// $Revision:: 149 $//
-// $Date:: 2007-03-15 00:13:58 +0100 (Thu, 15 Mar 2007) $//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef __SISCONE_AREA_H__
-#define __SISCONE_AREA_H__
-
-#include "momentum.h"
-#include "siscone.h"
-
-namespace siscone{
-
-/**
- * \class Cjet_area
- * real Jet information, including its area(s)
- *
- * This class contains information for one single jet.
- * That is, first, its momentum carrying information
- * about its centre and pT, and second, its particle
- * contents.
- * Compared to the Cjet class, it also includes the
- * passive and active areas of the jet computed using
- * the Carea class.
- */
-class Cjet_area : public Cjet{
- public:
- /// default ctor
- Cjet_area();
-
- /// jet-initialised ctor
- Cjet_area(Cjet &j);
-
- /// default dtor
- ~Cjet_area();
-
- // area information
- double passive_area; ///< passive area
- double active_area; ///< active area
-};
-
-/**
- * \class Carea
- * class for the computation of jet areas.
- *
- * This is the class user should use whenever you want to compute
- * the jet area (passive and active). .
- * It uses the SISCone algorithm to perform the jet analysis.
- */
-class Carea : public Csiscone{
- public:
- /// default ctor
- Carea();
-
- /// default dtor
- ~Carea();
-
- /**
- * compute the jet areas from a given particle set.
- * The parameters of this method are the ones which control the jet clustering alghorithn.
- * Note that the pt_min is not allowed here soince the jet-area determination involves soft
- * particles/jets and thus is used internally.
- * \param _particles list of particles
- * \param _radius cone radius
- * \param _f shared energy threshold for splitting&merging
- * \param _n_pass_max maximum number of passes (0=full search, the default)
- * \param _split_merge_scale the scale choice for the split-merge procedure
- * NOTE: SM_pt leads to IR unsafety for some events with momentum conservation.
- * SM_Et is IR safe but not boost invariant and not implemented(!)
- * SM_mt is IR safe for hadronic events, but not for decays of two
- * back-to-back particles of identical mass
- * SM_pttilde
- * is always IR safe, and also boost invariant (default)
- * \param _hard_only when this is set on, only hard jets are computed
- * and not the purely ghosted jets (default: false)
- * \return the number of jets (including pure-ghost ones if they are included)
- */
- int compute_areas(std::vector<Cmomentum> &_particles, double _radius, double _f,
- int _n_pass_max=0, Esplit_merge_scale _split_merge_scale=SM_pttilde,
- bool _hard_only=false);
-
- /**
- * compute the jet active areas from a given particle set.
- * The parameters of this method are the ones which control the jet clustering alghorithn.
- * Note that the pt_min is not allowed here soince the jet-area determination involves soft
- * particles/jets and thus is used internally.
- * See compute_areas for paramters definition.
- * \return the number of jets (including pure-ghost ones if they are included)
- */
- int compute_active_areas(std::vector<Cmomentum> &_particles, double _radius, double _f,
- int _n_pass_max=0, Esplit_merge_scale _split_merge_scale=SM_pttilde,
- bool _hard_only=false);
-
- /**
- * compute the jet passive areas from a given particle set.
- * The parameters of this method are the ones which control the jet clustering alghorithn.
- * Note that the pt_min is not allowed here soince the jet-area determination involves soft
- * particles/jets and thus is used internally.
- * See compute_areas for paramters definition.
- */
- int compute_passive_areas(std::vector<Cmomentum> &_particles, double _radius, double _f,
- int _n_pass_max=0, Esplit_merge_scale _split_merge_scale=SM_pttilde);
-
- int grid_size; ///< size of the grid we add soft particles on (N_soft=(grid_size^2))
- double grid_eta_max; ///< maximal value of eta we add soft particles on
- double grid_shift; ///< fractional (random) displacement of the points om the grid
-
- double pt_soft; ///< pt of the soft particles added
- double pt_shift; ///< amplitude of the pt random shift
- double pt_soft_min; ///< pt_min used in SM to compute passive areas
-
- /// jets with their areas
- std::vector<Cjet_area> jet_areas;
-};
-
-}
-#endif
+++ /dev/null
-// -*- C++ -*-
-///////////////////////////////////////////////////////////////////////////////
-// File: circulator.h //
-// Description: header file for circulator (circulator class) //
-// This file is part of the SISCone project. //
-// For more details, see http://projects.hepforge.org/siscone //
-// //
-// Copyright (c) 2006 Gavin Salam and Gregory Soyez //
-// //
-// This program 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. //
-// //
-// This program 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 this program; if not, write to the Free Software //
-// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
-// //
-// $Revision:: 103 $//
-// $Date:: 2007-02-18 17:07:34 +0100 (Sun, 18 Feb 2007) $//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef __CIRCULATOR_H__
-#define __CIRCULATOR_H__
-
-namespace siscone{
-
-/// \class circulator
-/// a circulator that is foreseen to take as template member either a
-/// pointer or an iterator;
-template<class T> class circulator {
-
-public:
- /// ctor with iniitalisation from iterators
- /// \param here the current position
- /// \param begin the first position
- /// \param end the last position
- inline circulator(T here, T begin, T end) : m_here(here), m_begin(begin), m_end(end) {}
-
- /// copy ctor
- /// \param other the circulator to copy
- inline circulator(const circulator<T> & other) : m_here(other.m_here), m_begin(other.m_begin), m_end(other.m_end) {}
-
- /// set just the position without resetting the begin and end elements
- /// \param other the circulator to grab position from
- void set_position(const circulator<T> & other) {m_here = other.m_here;}
-
- /// set just the position without resetting the begin and end elements
- /// \param pointer the iterator to use as the new position
- void set_position(T pointer) {m_here = pointer;}
-
- /// get the current object
- T operator()() {return m_here;}
-
- /// position incrementation
- inline circulator<T> & operator++() {
- ++m_here;
- if (m_here == m_end) m_here = m_begin;
- return *this;
- }
-
- /// position decrementation
- inline circulator<T> & operator--() {
- if (m_here == m_begin) m_here = m_end;
- --m_here;
- return *this;
- }
-
- /// check if the current elements are the same
- /// NB: for efficiency, this checks only the here element
- /// \param other the circulator to compare to the current one
- bool operator==(const circulator & other) const {return m_here == other.m_here;}
-
- /// check if the current elements are different
- /// NB: for efficiency, this checks only the here element
- /// \param other the circulator to compare to the current one
- bool operator!=(const circulator & other) const {return m_here != other.m_here;}
-
-private:
- T m_here, m_begin, m_end; ///< the current, beginning and ending iterators/pointers
-};
-
-}
-
-#endif // __CIRCULATOR_H__
+++ /dev/null
-/* siscone/config.h. Generated from config.h.in by configure. */
-/* config.h.in. Generated from configure.ac by autoheader. */
-
-/* Define to 1 if you have the <dlfcn.h> header file. */
-#define HAVE_DLFCN_H 1
-
-/* Define to 1 if you have the <inttypes.h> header file. */
-#define HAVE_INTTYPES_H 1
-
-/* Define to 1 if you have the `m' library (-lm). */
-#define HAVE_LIBM 1
-
-/* Define to 1 if you have the <memory.h> header file. */
-#define HAVE_MEMORY_H 1
-
-/* Define to 1 if you have the <stdint.h> header file. */
-#define HAVE_STDINT_H 1
-
-/* Define to 1 if you have the <stdlib.h> header file. */
-#define HAVE_STDLIB_H 1
-
-/* Define to 1 if you have the <strings.h> header file. */
-#define HAVE_STRINGS_H 1
-
-/* Define to 1 if you have the <string.h> header file. */
-#define HAVE_STRING_H 1
-
-/* Define to 1 if you have the <sys/stat.h> header file. */
-#define HAVE_SYS_STAT_H 1
-
-/* Define to 1 if you have the <sys/types.h> header file. */
-#define HAVE_SYS_TYPES_H 1
-
-/* Define to 1 if you have the <unistd.h> header file. */
-#define HAVE_UNISTD_H 1
-
-/* Name of package */
-#define PACKAGE "siscone"
-
-/* Define to the address where bug reports for this package should be sent. */
-#define PACKAGE_BUGREPORT ""
-
-/* Define to the full name of this package. */
-#define PACKAGE_NAME "SISCone"
-
-/* Define to the full name and version of this package. */
-#define PACKAGE_STRING "SISCone 2.0.0"
-
-/* Define to the one symbol short name of this package. */
-#define PACKAGE_TARNAME "siscone"
-
-/* Define to the version of this package. */
-#define PACKAGE_VERSION "2.0.0"
-
-/* Define to 1 if you have the ANSI C header files. */
-#define STDC_HEADERS 1
-
-/* Version number of package */
-#define VERSION "2.0.0"
+++ /dev/null
-// -*- C++ -*-
-///////////////////////////////////////////////////////////////////////////////
-// File: defines.h //
-// Description: header file for generic parameters definitions //
-// This file is part of the SISCone project. //
-// For more details, see http://projects.hepforge.org/siscone //
-// //
-// Copyright (c) 2006 Gavin Salam and Gregory Soyez //
-// //
-// This program 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. //
-// //
-// This program 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 this program; if not, write to the Free Software //
-// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
-// //
-// $Revision:: 225 $//
-// $Date:: 2008-05-20 16:59:47 +0200 (Tue, 20 May 2008) $//
-///////////////////////////////////////////////////////////////////////////////
-
-//! \file defines.h
-#ifndef __DEFINES_H__
-#define __DEFINES_H__
-
-/// program name
-// we get "SISCone" by calling
-// siscone::siscone_package_name
-// defined in siscone.h
-// Otherwise, config.h
-// It is also defined as "PACKAGE_NAME" in config.h but this method
-// might lead to conflicts
-//#define PROGRAM PACKAGE_NAME
-
-// program version
-// we get it from
-// siscone::siscone_version
-// defined in siscone.h
-// It is also defined as "VERSION" in config.h but this method
-// might lead to conflicts
-
-/// perform final stability check using the quadtree
-/// With the following define enabled, the final check for stability
-/// is performed using the quadtree rather than the explicit list of
-/// particles (see Cstable_cone::proceed_with_stability())
-//#define USE_QUADTREE_FOR_STABILITY_TEST
-
-
-/// threshold for recomoutation of the cone (see Cstable_cones::update_cone())
-/// When traversing cone candidates along the angular ordering,
-/// the momentum of the protojet candidate is computed incrementally
-/// from the particles that enter and leave the cone.
-/// When the cumulative change in "|px|+|py|" exceeds the cone "|px|+|py|"
-/// we explicitely recompute the cone contents
-#define PT_TSHOLD 1000.0
-
-
-/// The following parameter controls collinear safety. For the set of
-/// particles used in the search of stable cones, we gather particles
-/// if their distance in eta and phi is smaller than EPSILON_COLLINEAR.
-///
-/// NB: for things to behave sensibly one requires
-/// 1e-15 << EPSILON_COCIRCULAR << EPSILON_COLLINEAR << 1
-///
-/// among the scales that appear in practice (e.g. in deciding to use
-/// special strategies), we have EPSILON_COLLINEAR, EPSILON_COCIRCULAR,
-/// sqrt(EPSILON_COCIRCULAR) and EPSILON_COLLINEAR / EPSILON_COCIRCULAR.
-///
-#define EPSILON_COLLINEAR 1e-8
-
-
-/// The following parameter controls cocircular situations.
-/// When consecutive particles in the ordered vicinity list are separated
-/// (in angle) by less that that limit, we consider that we face a situation
-/// of cocircularity.
-#define EPSILON_COCIRCULAR 1e-12
-
-
-/// The following define enables you to allow for identical protocones
-/// to be merged automatically after each split-merge step before
-/// anything else happens. Whether this happens depends on teh value
-/// of the merge_identical_protocones flag in Csplit_merge.
-///
-/// It we allow such a merging and define allow
-/// MERGE_IDENTICAL_PROTOCONES_DEFAULT_TRUE then the
-/// 'merge_identical_protocones' flag in Csplit_merge to be set to
-/// 'true'. It may be manually reset to false in which case the
-/// merging of identical protocones (protojets) will be turned off.
-///
-/// Note that this merging identical protocones makes the algorithm
-/// infrared-unsafe, so it should be disabled except for testing
-/// purposes.
-//#define ALLOW_MERGE_IDENTICAL_PROTOCONES
-//#define MERGE_IDENTICAL_PROTOCONES_DEFAULT_TRUE
-
-
-/// if EPSILON_SPLITMERGE is defined then, during the split-merge
-/// step, when two jets are found with PTs that are identical to
-/// within a relative difference of EPSILON_SPLITMERGE they are
-/// compared element-by-element to see where the differences are, and
-/// one then uses pt1^2-pt2^2 = (pt1-pt2).(pt1+pt2) as an estimator of
-/// which is harder. NB: in unfortunate cases, this can take the split
-/// merge step up to N n * ln N time, though on normal events there
-/// don't seem to have been any major problems yet.
-#define EPSILON_SPLITMERGE 1e-12
-
-/// definition of 2*M_PI which is useful a bit everyhere!
-const double twopi = 6.283185307179586476925286766559005768394;
-
-/// debugging information
-//#define DEBUG_STABLE_CONES ///< debug messages in stable cones search
-//#define DEBUG_SPLIT_MERGE ///< debug messages in split-merge
-//#define DEBUG ///< all debug messages !
-
-// in case all debug massages allowed, allow them in practice !
-#ifdef DEBUG
-#define DEBUG_STABLE_CONES
-#define DEBUG_SPLIT_MERGE
-#endif
-
-#endif // __DEFINES_H__
-
+++ /dev/null
-// -*- C++ -*-
-///////////////////////////////////////////////////////////////////////////////
-// File: geom_2d.h //
-// Description: header file for two-dimensional geometry tools //
-// This file is part of the SISCone project. //
-// For more details, see http://projects.hepforge.org/siscone //
-// //
-// Copyright (c) 2006 Gavin Salam and Gregory Soyez //
-// //
-// This program 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. //
-// //
-// This program 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 this program; if not, write to the Free Software //
-// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
-// //
-// $Revision:: 268 $//
-// $Date:: 2009-03-12 21:24:16 +0100 (Thu, 12 Mar 2009) $//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef __GEOM_2D_H__
-#define __GEOM_2D_H__
-
-#include <iostream>
-#include <math.h>
-#include "defines.h"
-
-#ifndef M_PI
-#define M_PI 3.141592653589793238462643383279502884197
-#endif
-
-namespace siscone{
-
-/// return a result that corresponds to phi, but in the
-/// range (-pi..pi]; the result is only correct if -3pi < phi <= 3pi
-inline double phi_in_range(double phi) {
- if (phi <= -M_PI) phi += twopi;
- else if (phi > M_PI) phi -= twopi;
- return phi;
-}
-
-/// return the difference between the two phi values,
-/// placed in the correct range (-pi..pi], , assuming that phi1,phi2
-/// are already in the correct range.
-inline double dphi(double phi1, double phi2) {
- return phi_in_range(phi1-phi2);
-}
-
-
-/// return the absolute difference between the two phi values,
-/// placed in the correct range, assuming that phi1,phi2 are already
-/// in the correct range.
-inline double abs_dphi(double phi1, double phi2) {
- double delta = fabs(phi1-phi2);
- return delta > M_PI ? twopi-delta : delta;
-}
-
-/// return the square of the argument
-inline double pow2(double x) {return x*x;}
-
-
-/**
- * \class Ctwovect
- * \brief class for holding a two-vector
- */
-class Ctwovect {
-public:
- /// default ctor
- Ctwovect() : x(0.0), y(0.0) {}
-
- /// ctor with initialisation
- /// \param _x first coordinate
- /// \param _y second coordinate
- Ctwovect(double _x, double _y) : x(_x), y(_y) {}
-
- /// vector coordinates
- double x, y;
-
- /// norm (modulud square) of the vector
- inline double mod2() const {return pow2(x)+pow2(y);}
-
- /// modulus of the vector
- inline double modulus() const {return sqrt(mod2());}
-};
-
-
-/// dot product of two 2-vectors
-/// \param a first 2-vect
-/// \param b second 2-vect
-/// \return a.b is returned
-inline double dot_product(const Ctwovect & a, const Ctwovect & b) {
- return a.x*b.x + a.y*b.y;
-}
-
-
-/// cross product of two 2-vectors
-/// \param a first 2-vect
-/// \param b second 2-vect
-/// \return a x b is returned
-inline double cross_product(const Ctwovect & a, const Ctwovect & b) {
- return a.x*b.y - a.y*b.x;
-}
-
-
-/**
- * \class Ceta_phi_range
- * \brief class for holding a covering range in eta-phi
- *
- * This class deals with ranges in the eta-phi plane. It
- * implements methods to test if two ranges overlap and
- * to take the union of two overlapping intervals.
- */
-class Ceta_phi_range{
-public:
- /// default ctor
- Ceta_phi_range();
-
- /// ctor with initialisation
- /// we initialise with a centre (in eta,phi) and a radius
- /// \param c_eta eta coordinate of the centre
- /// \param c_phi phi coordinate of the centre
- /// \param R radius
- Ceta_phi_range(double c_eta, double c_phi, double R);
-
- /// assignment of range
- /// \param r range to assign to current one
- Ceta_phi_range& operator = (const Ceta_phi_range &r);
-
- /// add a particle to the range
- /// \param eta eta coordinate of the particle
- /// \param phi phi coordinate of the particle
- /// \return 0 on success, 1 on error
- int add_particle(const double eta, const double phi);
-
- /// eta range as a binary coding of covered cells
- unsigned int eta_range;
-
- /// phi range as a binary coding of covered cells
- unsigned int phi_range;
-
- // extremal value for eta
- static double eta_min; ///< minimal value for eta
- static double eta_max; ///< maximal value for eta
-
-private:
- /// return the cell index corrsponding to an eta value
- inline unsigned int get_eta_cell(double eta){
- return (unsigned int) (1 << ((int) (32*((eta-eta_min)/(eta_max-eta_min)))));
- }
-
- /// return the cell index corrsponding to a phi value
- inline unsigned int get_phi_cell(double phi){
- return (unsigned int) (1 << ((int) (32*phi/twopi+16)%32));
- }
-};
-
-/// test overlap
-/// \param r1 first range
-/// \param r2 second range
-/// \return true if overlap, false otherwise.
-bool is_range_overlap(const Ceta_phi_range &r1, const Ceta_phi_range &r2);
-
-/// compute union
-/// Note: we assume that the two intervals overlap
-/// \param r1 first range
-/// \param r2 second range
-/// \return union of the two ranges
-const Ceta_phi_range range_union(const Ceta_phi_range &r1, const Ceta_phi_range &r2);
-
-}
-
-#endif
+++ /dev/null
-// -*- C++ -*-
-///////////////////////////////////////////////////////////////////////////////
-// File: hash.h //
-// Description: header file for classes hash_element and hash_cones //
-// This file is part of the SISCone project. //
-// For more details, see http://projects.hepforge.org/siscone //
-// //
-// Copyright (c) 2006 Gavin Salam and Gregory Soyez //
-// //
-// This program 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. //
-// //
-// This program 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 this program; if not, write to the Free Software //
-// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
-// //
-// $Revision:: 224 $//
-// $Date:: 2008-05-16 19:58:30 +0200 (Fri, 16 May 2008) $//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef __HASH_H__
-#define __HASH_H__
-
-#include "momentum.h"
-#include "reference.h"
-
-namespace siscone{
-
-/**
- * \class hash_element
- * information on store cones candidates.
- *
- * We store in this class the information used to count all
- * protocones in a first pass. This first pass only count
- * cones with different references and test their stbility
- * with the parent-child particles (border particles).
- */
-class hash_element{
- public:
- Creference ref; ///< reference
- double eta; ///< centre: eta coordinate
- double phi; ///< centre: phi coordinate
- bool is_stable; ///< true if stable w.r.t. "border particles"
-
- hash_element *next; ///< pointer to the next element
-};
-
-/**
- * \class hash_cones
- * list of cones candidates.
- *
- * We store in this class all the hash_elements and give
- * functions to manipulate them.
- */
-class hash_cones{
- public:
- /// constructor with initialisation
- /// \param _Np number of particles
- /// \param _R2 cone radius (squared)
- hash_cones(int _Np, double _R2);
-
- /// destructor
- ~hash_cones();
-
- /**
- * insert a new candidate into the hash.
- * \param v 4-momentum of te cone to add
- * \param parent parent particle defining the cone
- * \param child child particle defining the cone
- * \param p_io whether the parent has to belong to the cone or not
- * \param c_io whether the child has to belong to the cone or not
- * \return 0 on success, 1 on error
- */
- int insert(Cmomentum *v, Cmomentum *parent, Cmomentum *child, bool p_io, bool c_io);
-
- /**
- * insert a new candidate into the hash.
- * \param v 4-momentum of te cone to add
- * Note, in this case, we assume stability. We also assume
- * that eta and phi are computed for v
- * \return 0 on success, 1 on error
- */
- int insert(Cmomentum *v);
-
- /// the cone data itself
- hash_element **hash_array;
-
- /// number of elements
- int n_cones;
-
- /// number of occupied cells
-#ifdef DEBUG_STABLE_CONES
- int n_occupied_cells;
-#endif
-
- /// number of cells-1
- int mask;
-
- /// circle radius (squared)
- /// NOTE: need to be set before any call to 'insert'
- double R2;
-
- /**
- * test if a particle is inside a cone of given centre.
- * check if the particle of coordinates 'v' is inside the circle of radius R
- * centered at 'centre'.
- * \param centre centre of the circle
- * \param v particle to test
- * \return true if inside, false if outside
- */
- inline bool is_inside(Cmomentum *centre, Cmomentum *v);
-};
-
-}
-#endif
+++ /dev/null
-// -*- C++ -*-
-///////////////////////////////////////////////////////////////////////////////
-// File: momentum.h //
-// Description: header file for 4-momentum class Cmomentum //
-// This file is part of the SISCone project. //
-// For more details, see http://projects.hepforge.org/siscone //
-// //
-// Copyright (c) 2006 Gavin Salam and Gregory Soyez //
-// //
-// This program 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. //
-// //
-// This program 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 this program; if not, write to the Free Software //
-// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
-// //
-// $Revision:: 163 $//
-// $Date:: 2007-04-26 22:31:02 +0200 (Thu, 26 Apr 2007) $//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef __VECTOR_H__
-#define __VECTOR_H__
-
-#include <vector>
-#include <math.h>
-#include "reference.h"
-#include "geom_2d.h"
-#include "defines.h"
-
-namespace siscone{
-
-/**
- * \class Cmomentum
- * \brief base class for dynamic coordinates management
- *
- * This class contains the information for particle or group of
- * particles management.
- * It includes all Lorentz properties as well as tools for summing them.
- * Note: 'sums' over phi angles are indeed averages. This allows to
- * deal with periodicity at each step
- */
-class Cmomentum{
- public:
- /// default ctor
- Cmomentum();
-
- /// ctor with initialisation
- Cmomentum(double _px, double _py, double _pz, double _E);
-
- /// ctor with detailed initialisation
- Cmomentum(double _eta, double _phi, Creference _ref);
-
- /// default dtor
- ~Cmomentum();
-
- /// computes pT
- inline double perp() const {return sqrt(perp2());}
-
- /// computes pT^2
- inline double perp2() const {return px*px+py*py;}
-
- /// computes m
- inline double mass() const {return sqrt(mass2());}
-
- /// computes m^2
- inline double mass2() const {return perpmass2()-perp2();}
-
- /// transverse mass, mt = sqrt(pt^2+m^2) = sqrt(E^2 - pz^2)
- inline double perpmass() const {return sqrt((E-pz)*(E+pz));}
-
- /// transverse mass squared, mt^2 = pt^2+m^2 = E^2 - pz^2
- inline double perpmass2() const {return (E-pz)*(E+pz);}
-
- /// computes transverse energy
- inline double Et() const {return E/sqrt(1.0+pz*pz/perp2());}
-
- /// computes transverse energy (squared)
- inline double Et2() const {return E*E/(1.0+pz*pz/perp2());}
-
- /// assignment of vectors
- Cmomentum& operator = (const Cmomentum &v);
-
- /// addition of vectors
- /// !!! WARNING !!! no updating of eta and phi !!!
- const Cmomentum operator + (const Cmomentum &v);
-
- /// incrementation of vectors
- /// !!! WARNING !!! no updating of eta and phi !!!
- Cmomentum& operator += (const Cmomentum &v);
-
- /// decrementation of vectors
- /// !!! WARNING !!! no updating of eta and phi !!!
- Cmomentum& operator -= (const Cmomentum &v);
-
- /// build eta-phi from 4-momentum info
- /// !!! WARNING !!!
- /// !!! computing eta and phi is time-consuming !!!
- /// !!! use this whenever you need eta or phi !!!
- /// !!! automatically called for single-particle !!!
- void build_etaphi();
-
- double px; ///< x-momentum
- double py; ///< y-momentum
- double pz; ///< z-momentum
- double E; ///< energy
-
- double eta; ///< particle pseudo-rapidity
- double phi; ///< particle azimuthal angle
- int parent_index; ///< particle number in the parent list
- int index; ///< internal particle number
-
- //////////////////////////////////////////////
- // the following part is used for checksums //
- //////////////////////////////////////////////
- Creference ref; ///< reference number for the vector
-};
-
-/// ordering of two vectors
-/// this is by default done w.r.t. their references
-bool operator < (const Cmomentum &v1, const Cmomentum &v2);
-
-/// ordering of vectors in eta (e.g. used in collinear tests)
-bool momentum_eta_less(const Cmomentum &v1, const Cmomentum &v2);
-
-/// ordering of vectors in pt
-bool momentum_pt_less(const Cmomentum &v1, const Cmomentum &v2);
-
-
-//////////////////////////
-// some handy utilities //
-//////////////////////////
-
-/// get distance between to eta-phi points
-/// \param eta eta coordinate of first point
-/// \param phi phi coordinate of first point
-/// \param v vector defining the second point
-inline double get_distance(double eta, double phi, Cmomentum *v){
- double dx, dy;
-
- dx = eta - v->eta;
- dy = fabs(phi - v->phi);
- if (dy>M_PI)
- dy -= twopi;
-
- return dx*dx+dy*dy;
-}
-
-}
-
-#endif
+++ /dev/null
-// -*- C++ -*-
-///////////////////////////////////////////////////////////////////////////////
-// File: protocones.h //
-// Description: header file for stable cones determination (Cstable_cones) //
-// This file is part of the SISCone project. //
-// For more details, see http://projects.hepforge.org/siscone //
-// //
-// Copyright (c) 2006 Gavin Salam and Gregory Soyez //
-// //
-// This program 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. //
-// //
-// This program 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 this program; if not, write to the Free Software //
-// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
-// //
-// $Revision:: 224 $//
-// $Date:: 2008-05-16 19:58:30 +0200 (Fri, 16 May 2008) $//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef __PROTOCONES_H__
-#define __PROTOCONES_H__
-
-#include "momentum.h"
-#include "vicinity.h"
-#include <stdio.h>
-#include <vector>
-#include <list>
-#include "hash.h"
-
-#include "defines.h"
-
-namespace siscone{
-
-/**
- * \class Cborder_store
- *
- * class for storing a border momentum (in context of co-circularity
- * checks).
-
- * This class essentially calculates angle of border point w.r.t.
- * circle center (eta & phi), and provides a store of information
- * about whether we are currently including this point in the
- * candidate
- */
-class Cborder_store{
-public:
- /// default ctor
- Cborder_store(Cmomentum * momentum, double centre_eta, double centre_phi) :
- mom(momentum), is_in(false) {
- angle = atan2(mom->phi - centre_phi, mom->eta - centre_eta);
- }
-
- Cmomentum * mom; ///< particle momentum
- double angle; ///< angle w.r.t. circle centre
- bool is_in; ///< inclusion status of the particle
-};
-
-
-/// allows easy sorting of Cborder_store objects (which need to be
-/// ordered in angle).
-inline bool operator<(const Cborder_store & a, const Cborder_store & b) {
- return a.angle < b.angle;
-}
-
-
-/**
- * \class Cstable_cones
- * \brief Computes the list of stable comes from a particle list.
- *
- * This class does the first fundamental task of te cone algorithm:
- * it is used to compute the list of stable cones given a list
- * of particles.
- */
-class Cstable_cones : public Cvicinity{
- public:
- /// default ctor
- Cstable_cones();
-
- /// ctor with initialisation (sse init for details)
- Cstable_cones(std::vector<Cmomentum> &_particle_list);
-
- /// default dtor
- ~Cstable_cones();
-
- /**
- * initialisation
- * \param _particle_list list of particles
- */
- void init(std::vector<Cmomentum> &_particle_list);
-
- /**
- * compute stable cones.
- * This function really does the job i.e. computes
- * the list of stable cones (in a seedless way)
- * \param _radius radius of the cones
- * \return The number of stable cones found is returned
- */
- int get_stable_cones(double _radius);
-
- /// list of stable cones
- std::vector<Cmomentum> protocones;
-
- /// list of candidates
- hash_cones *hc;
-
- /// total number of tested cones
- int nb_tot;
-#ifdef DEBUG_STABLE_CONES
- int nb_hash_cones, nb_hash_occupied;
-#endif
-
- protected:
- /// cone radius
- double R;
-
- /// cone radius SQUARED
- double R2;
-
- private:
- /// cone with a given particle as parent
- /// this reduction to a single vector assumes we trust the checksums
- Cmomentum cone;
-
- /// child particle, taken in the 'vicinity' list
- Cmomentum *child;
-
- /// centre of the tested cone
- Cvicinity_elm *centre;
-
- /// index in the particle list;
- unsigned int centre_idx;
-
- /// first cone used in the vicinity list
- unsigned int first_cone;
-
- /**
- * initialise the cone.
- * We take the first particle in the angular ordering to compute this one
- * \return 0 on success, 1 on error
- */
- int init_cone();
-
- /**
- * test cones.
- * We check if the cone(s) build with the present parent and child
- * are stable
- * \return 0 on success 1 on error
- */
- int test_cone();
-
- /**
- * update the cone
- * go to the next child for that parent and update 'cone' appropriately
- * \return 0 if update candidate found, 1 otherwise
- */
- int update_cone();
-
- /*
- * run through the vicinity of the current parent and for each child
- * indicate which members are cocircular...
- */
- void prepare_cocircular_lists();
-
- /**
- * check if we are in a situation of cocircularity.
- * if it is the case, update and test in the corresponding way
- * \return 'false' if no cocircularity detected, 'true' otherwise
- * Note that if cocircularity is detected, we need to
- * recall 'update' from 'update' !!!
- */
- bool cocircular_check();
-
- /**
- * Routine for testing cocircular configurations in p^3 time,
- * rather than 2^p time;
- */
- void test_cone_cocircular(Cmomentum & borderless_cone,
- std::list<Cmomentum *> & border_list);
-
- /**
- * carry out the computations needed for the stability check of the
- * candidate, using the border_vect to indicate which particles
- * should / should not be in the stable cone; if the cone is stable
- * insert it into the hash.
- */
- void test_stability(Cmomentum & candidate,
- const std::vector<Cborder_store> & border_vect);
-
- /**
- * compute the cone contents by going once around the full set of
- * circles and tracking the entry/exit status each time -- this sets
- * up the inclusion information, which can then be directly used to
- * calculate the cone momentum.
- */
- void compute_cone_contents();
-
- /**
- * compute the cone momentum from particle list.
- * in this version, we use the 'pincluded' information
- * from the Cviinity class
- */
- void recompute_cone_contents();
-
- /*
- * if we have gone beyond the acceptable threshold of change, compute
- * the cone momentum from particle list. in this version, we use the
- * 'pincluded' information from the Cvicinity class, but we don't
- * change the member cone, only the locally supplied one
- */
- void recompute_cone_contents_if_needed(Cmomentum & this_cone, double & this_dpt);
-
- /**
- * compute stability of all enumerated candidates.
- * For all candidate cones which are stable w.r.t. their border particles,
- * pass the last test: stability with quadtree intersection
- */
- int proceed_with_stability();
-
- /*
- * circle intersection.
- * computes the intersection with a circle of given centre and radius.
- * The output takes the form of a checkxor of the intersection's particles
- * - cx circle centre x coordinate
- * - cy circle centre y coordinate
- * return the checkxor for the intersection
- ******************************************************************/
- Creference circle_intersect(double cx, double cy);
-
- /// present candidate cone
- Cmomentum cone_candidate;
-
- /// in case of co-circular points, vector for them
- std::vector<Cmomentum*> child_list;
-
- /// list of cocircular enclusures already studied
- /// first element if cone contents, second is cone border
- std::vector< std::pair<Creference,Creference> > multiple_centre_done;
-
- // information for updating cone contents to avoid rounding errors
- double dpt; ///< sums of Delta P_t
-
- /**
- * test if a particle is inside a cone of given centre.
- * check if the particle of coordinates 'v' is inside the circle of radius R
- * centered at 'centre'.
- * \param centre centre of the circle
- * \param v particle to test
- * \return true if inside, false if outside
- */
- inline bool is_inside(Cmomentum *centre, Cmomentum *v);
-};
-
-/*
- * compute the absolute value of the difference between 2 angles.
- * We take care of the 2pi periodicity
- * \param angle1 first angle
- * \param angle2 second angle
- * \return the absolute value of the difference between the angles
- *****************************************************************/
-inline double abs_dangle(double &angle1, double &angle2);
-
-}
-#endif
+++ /dev/null
-// -*- C++ -*-
-///////////////////////////////////////////////////////////////////////////////
-// File: quadtree.h //
-// Description: header file for quadtree management (Cquadtree class) //
-// This file is part of the SISCone project. //
-// For more details, see http://projects.hepforge.org/siscone //
-// //
-// Copyright (c) 2006 Gavin Salam and Gregory Soyez //
-// //
-// This program 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. //
-// //
-// This program 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 this program; if not, write to the Free Software //
-// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
-// //
-// $Revision:: 123 $//
-// $Date:: 2007-03-01 02:52:16 +0100 (Thu, 01 Mar 2007) $//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef __QUADTREE_H__
-#define __QUADTREE_H__
-
-#include "momentum.h"
-#include <stdio.h>
-
-namespace siscone{
-
-/**
- * \class Cquadtree
- * \brief Implementation of a 2D quadtree.
- *
- * This class implements the traditional two-dimensional quadtree.
- * The elements at each node are of 'Cmomentum' type.
- */
-class Cquadtree{
- public:
- /// default ctor
- Cquadtree();
-
- /// ctor with initialisation (see init for details)
- Cquadtree(double _x, double _y, double _half_size_x, double _half_size_y);
-
- /// default destructor
- /// at destruction, everything is destroyed except
- /// physical values at the leaves
- ~Cquadtree();
-
- /**
- * init the tree.
- * By initializing the tree, we mean setting the cell parameters
- * and preparing the object to act as a seed for a new tree.
- * \param _x x-position of the center
- * \param _y y-position of the center
- * \param _half_size_x x-size of the cell
- * \param _half_size_y y-size of the cell
- * \return 0 on success, 1 on error. Note that if the cell or its
- * parent is already filled, we return an error.
- */
- int init(double _x, double _y, double _half_size_x, double _half_size_y);
-
- /**
- * adding a particle to the tree.
- * This method adds one vector to the quadtree structure which
- * is updated consequently.
- * \param v_add vector to add
- * \return 0 on success 1 on error
- */
- int add(Cmomentum *v_add);
-
- /**
- * circle intersection.
- * computes the intersection with a circle of given centre and radius.
- * The output takes the form of a quadtree with all squares included
- * in the circle.
- * \param cx circle centre x coordinate
- * \param cy circle centre y coordinate
- * \param cR2 circle radius SQUARED
- * \return the checksum for that intersection
- */
- Creference circle_intersect(double cx, double cy, double cR2);
-
- /**
- * output a data file for drawing the grid.
- * This can be used to output a data file containing all the
- * grid subdivisions. The file contents is as follows:
- * first and second columns give center of the cell, the third
- * gives the size.
- * \param flux opened stream to write to
- * \return 0 on success, 1 on error
- */
- int save(FILE *flux);
-
- /**
- * output a data file for drawing the tree leaves.
- * This can be used to output a data file containing all the
- * tree leaves. The file contents is as follows:
- * first and second columns give center of the cell, the third
- * gives the size.
- * \param flux opened stream to write to
- * \return 0 on success, 1 on error
- */
- int save_leaves(FILE *flux);
-
- double centre_x; ///< x-position of the centre of the cell
- double centre_y; ///< y-position of the centre of the cell
- double half_size_x; ///< HALF size of the cell
- double half_size_y; ///< HALF size of the cell
-
- Cmomentum *v; ///< physical contents
-
- Cquadtree* children[2][2]; ///< sub-cells ( 0,1->left-right; 0,1->bottom,top)
- bool has_child; ///< true if not a leaf
-};
-
-}
-#endif
+++ /dev/null
-//! \file ranlux.h
-
-#ifndef __RANLUX_H__
-#define __RANLUX_H__
-
-/* This is a lagged fibonacci generator with skipping developed by Luescher.
- The sequence is a series of 24-bit integers, x_n,
-
- x_n = d_n + b_n
-
- where d_n = x_{n-10} - x_{n-24} - c_{n-1}, b_n = 0 if d_n >= 0 and
- b_n = 2^24 if d_n < 0, c_n = 0 if d_n >= 0 and c_n = 1 if d_n < 0,
- where after 24 samples a group of p integers are "skipped", to
- reduce correlations. By default p = 199, but can be increased to
- 365.
-
- The period of the generator is around 10^171.
-
- From: M. Luescher, "A portable high-quality random number generator
- for lattice field theory calculations", Computer Physics
- Communications, 79 (1994) 100-110.
-
- Available on the net as hep-lat/9309020 at http://xxx.lanl.gov/
-
- See also,
-
- F. James, "RANLUX: A Fortran implementation of the high-quality
- pseudo-random number generator of Luscher", Computer Physics
- Communications, 79 (1994) 111-114
-
- Kenneth G. Hamilton, F. James, "Acceleration of RANLUX", Computer
- Physics Communications, 101 (1997) 241-248
-
- Kenneth G. Hamilton, "Assembler RANLUX for PCs", Computer Physics
- Communications, 101 (1997) 249-253 */
-
-namespace siscone{
-
-/// initialize 'ranlux' generator
-void ranlux_init();
-
-/// generate random value (24 bits)
-unsigned long int ranlux_get();
-
-/// save state of the generator
-void ranlux_print_state();
-
-}
-#endif
+++ /dev/null
-// -*- C++ -*-
-///////////////////////////////////////////////////////////////////////////////
-// File: reference.h //
-// Description: header file for checkxor management (Creference class) //
-// This file is part of the SISCone project. //
-// For more details, see http://projects.hepforge.org/siscone //
-// //
-// Copyright (c) 2006 Gavin Salam and Gregory Soyez //
-// //
-// This program 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. //
-// //
-// This program 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 this program; if not, write to the Free Software //
-// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
-// //
-// $Revision:: 123 $//
-// $Date:: 2007-03-01 02:52:16 +0100 (Thu, 01 Mar 2007) $//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef __REFERENCE_H__
-#define __REFERENCE_H__
-
-namespace siscone{
-
-/**
- * \class Creference
- * \brief references used for checksums.
- *
- * This class implements some reference variable
- * that can be used for checksums. Those checksums
- * are useful to disentengle between contents of two
- * cones without looking into their explicit particle
- * contents.
- */
-class Creference{
- public:
- /// default constructor
- Creference();
-
- /// create a random reference
- void randomize();
-
- /// test emptyness
- bool is_empty();
-
- /// test non-emptyness
- bool not_empty();
-
- /// assignment of reference
- Creference& operator = (const Creference &r);
-
- /// addition of reference
- Creference operator + (const Creference &r);
-
- /// incrementation of reference
- Creference& operator += (const Creference &r);
-
- /// decrementation of reference
- Creference& operator -= (const Creference &r);
-
- /// accessing the reference
- inline unsigned int operator[] (int i) {return ref[i];}
-
- unsigned int ref[3]; ///< actual data for the reference
-};
-
-/// addition of two references
-Creference operator + (Creference &r1, Creference &r2);
-
-/// equality test of two references
-bool operator == (const Creference &r1, const Creference &r2);
-
-/// difference test of two references
-bool operator != (const Creference &r1, const Creference &r2);
-
-/// ordering of two references
-bool operator < (const Creference &r1, const Creference &r2);
-
-
-//=============== inline material ================
-
-// equality test for two references
-//----------------------------------
-inline bool operator == (const Creference &r1, const Creference &r2){
- return (r1.ref[0]==r2.ref[0]) && (r1.ref[1]==r2.ref[1]) && (r1.ref[2]==r2.ref[2]);
-}
-
-// difference test for two references
-//----------------------------------
-inline bool operator != (const Creference &r1, const Creference &r2){
- return (r1.ref[0]!=r2.ref[0]) || (r1.ref[1]!=r2.ref[1]) || (r1.ref[2]!=r2.ref[2]);
-}
-
-// difference test for two references
-//----------------------------------
-inline bool operator < (const Creference &r1, const Creference &r2){
- return (r1.ref[0]<r2.ref[0]) || ((r1.ref[0]==r2.ref[0]) &&
- ((r1.ref[1]<r2.ref[1]) || ((r1.ref[1]==r2.ref[1]) && (r1.ref[2]<r2.ref[2]))
- ));
-}
-
-}
-#endif
+++ /dev/null
-// -*- C++ -*-
-///////////////////////////////////////////////////////////////////////////////
-// File: siscone.h //
-// Description: header file for the main SISCone class //
-// This file is part of the SISCone project. //
-// For more details, see http://projects.hepforge.org/siscone //
-// //
-// Copyright (c) 2006 Gavin Salam and Gregory Soyez //
-// //
-// This program 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. //
-// //
-// This program 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 this program; if not, write to the Free Software //
-// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
-// //
-// $Revision:: 224 $//
-// $Date:: 2008-05-16 19:58:30 +0200 (Fri, 16 May 2008) $//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef __SISCONE_H__
-#define __SISCONE_H__
-
-#include "protocones.h"
-#include "split_merge.h"
-
-namespace siscone{
-
-/**
- * \class Csiscone
- * final class: gather everything to compute the jet contents.
- *
- * This is the class user should use.
- * It computes the jet contents of a list of particles
- * given a cone radius and a threshold for splitting/merging.
- *
- * After the call to 'perform', the vector jets is filled with
- * the jets found. the 'contents' field of each jets contains
- * the indices of the particles included in that jet.
- */
-class Csiscone : public Cstable_cones, public Csplit_merge{
- public:
- /// default ctor
- Csiscone();
-
- /// default dtor
- ~Csiscone();
-
- /**
- * compute the jets from a given particle set.
- * We are doing multiple passes such pass n_pass looks for jets among
- * all particles not put into jets during previous passes.
- * By default the number of passes is infinite (0).
- * \param _particles list of particles
- * \param _radius cone radius
- * \param _f shared energy threshold for splitting&merging
- * \param _n_pass_max maximum number of passes (0=full search)
- * \param _ptmin minimum pT of the protojets
- * \param _split_merge_scale the scale choice for the split-merge procedure
- * NOTE: SM_pt leads to IR unsafety for some events with momentum conservation.
- * SM_Et is IR safe but not boost invariant and not implemented(!)
- * SM_mt is IR safe for hadronic events, but not for decays of two
- * back-to-back particles of identical mass
- * SM_pttilde
- * is always IR safe, and also boost invariant (default)
- *
- * \return the number of jets found.
- */
- int compute_jets(std::vector<Cmomentum> &_particles, double _radius, double _f,
- int _n_pass_max=0, double _ptmin=0.0,
- Esplit_merge_scale _split_merge_scale=SM_pttilde);
-
- /**
- * recompute the jets with a different overlap parameter.
- * we use the same particles and R as in the preceeding call.
- * \param _f shared energy threshold for splitting&merging
- * \param _ptmin minimum pT of the protojets
- * \param _split_merge_scale the scale choice for the split-merge procedure
- * split--merge variable
- * NOTE: using pt leads to IR unsafety for some events with momentum
- * conservation. So we strongly advise not to change the default
- * value.
- * \return the number of jets found, -1 if recomputation not allowed.
- */
- int recompute_jets(double _f, double _ptmin = 0.0,
- Esplit_merge_scale _split_merge_scale=SM_pttilde);
-
- /// list of protocones found pass-by-pass
- std::vector<std::vector<Cmomentum> > protocones_list;
-
- // random number initialisation
- static bool init_done; ///< check random generator initialisation
-
-#ifdef DEBUG_STABLE_CONES
- int nb_hash_cones_total, nb_hash_occupied_total;
-#endif
-
- private:
- bool rerun_allowed; ///< is recompute_jets allowed ?
-};
-
-
-// finally, a bunch of functions to access to
-// basic information (package name, version)
-//---------------------------------------------
-
-/**
- * return SISCone package name.
- * This is nothing but "SISCone", it is a replacement to the
- * PACKAGE_NAME string defined in config.h and which is not
- * public by default.
- * \return the SISCone name as a string
- */
-std::string siscone_package_name();
-
-/**
- * return SISCone version number.
- * \return a string of the form "X.Y.Z" with possible additional tag
- * (alpha, beta, devel) to mention stability status
- */
-std::string siscone_version();
-
-}
-#endif
+++ /dev/null
-// -*- C++ -*-
-///////////////////////////////////////////////////////////////////////////////
-// File: siscone_error.h //
-// Description: header file for SISCone error messages (Csiscone_error) //
-// This file is part of the SISCone project. //
-// For more details, see http://projects.hepforge.org/siscone //
-// //
-// Copyright (c) 2006 Gavin Salam and Gregory Soyez //
-// //
-// This program 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. //
-// //
-// This program 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 this program; if not, write to the Free Software //
-// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
-// //
-// $Revision:: 268 $//
-// $Date:: 2009-03-12 21:24:16 +0100 (Thu, 12 Mar 2009) $//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef __SISCONE_ERROR_H__
-#define __SISCONE_ERROR_H__
-
-#include<iostream>
-#include<string>
-
-namespace siscone{
-
-/// \class Csiscone_error
-/// class corresponding to errors that will be thrown by siscone
-class Csiscone_error {
-public:
- /// default ctor
- Csiscone_error() {;};
-
- /// ctor with a given error message
- /// \param message the error message to be printed
- Csiscone_error(const std::string & message) {
- m_message = message;
- if (m_print_errors) std::cerr << "siscone::Csiscone_error: "<<message << std::endl;
- };
-
- /// access to the error message
- std::string message() const {return m_message;};
-
- /// switch on/off the error message printing
- /// \param print_errors errors will be printed when true
- static void setm_print_errors(bool print_errors) {
- m_print_errors = print_errors;};
-
-private:
- std::string m_message; ///< the error message
- static bool m_print_errors; ///< do we print error messages?
-};
-
-}
-#endif
+++ /dev/null
-// -*- C++ -*-
-///////////////////////////////////////////////////////////////////////////////
-// File: geom_2d.h //
-// Description: header file for two-dimensional geometry tools //
-// This file is part of the SISCone project. //
-// WARNING: this is not the main SISCone trunk but //
-// an adaptation to spherical coordinates //
-// For more details, see http://projects.hepforge.org/siscone //
-// //
-// Copyright (c) 2006-2008 Gavin Salam and Gregory Soyez //
-// //
-// This program 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. //
-// //
-// This program 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 this program; if not, write to the Free Software //
-// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
-// //
-// $Revision:: 268 $//
-// $Date:: 2009-03-12 21:24:16 +0100 (Thu, 12 Mar 2009) $//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef __SPH_GEOM_2D_H__
-#define __SPH_GEOM_2D_H__
-
-#include <iostream>
-#include <math.h>
-#include <siscone/defines.h>
-#include <siscone/geom_2d.h>
-
-#ifndef M_PI
-#define M_PI 3.141592653589793238462643383279502884197
-#endif
-
-namespace siscone_spherical{
-
-/**
- * \class CSphtheta_phi_range
- * \brief class for holding a covering range in eta-phi
- *
- * This class deals with ranges in the eta-phi plane. It
- * implements methods to test if two ranges overlap and
- * to take the union of two overlapping intervals.
- */
-class CSphtheta_phi_range{
-public:
- /// default ctor
- CSphtheta_phi_range();
-
- /// ctor with initialisation
- /// we initialise with a centre (in theta,phi) and a radius
- /// \param c_theta theta coordinate of the centre
- /// \param c_phi phi coordinate of the centre
- /// \param R radius
- CSphtheta_phi_range(double c_theta, double c_phi, double R);
-
- /// assignment of range
- /// \param r range to assign to current one
- CSphtheta_phi_range& operator = (const CSphtheta_phi_range &r);
-
- /// add a particle to the range
- /// \param theta theta coordinate of the particle
- /// \param phi phi coordinate of the particle
- /// \return 0 on success, 1 on error
- int add_particle(const double theta, const double phi);
-
- /// theta range as a binary coding of covered cells
- unsigned int theta_range;
-
- /// phi range as a binary coding of covered cells
- unsigned int phi_range;
-
- /// extremal value for theta
- static double theta_min; ///< minimal value for theta (set to 0)
- static double theta_max; ///< maximal value for theta (set to pi)
-
-private:
- /// return the cell index corrsponding to an theta value
- inline unsigned int get_theta_cell(double theta){
- return (unsigned int) (1 << ((int) (32*((theta-theta_min)/(theta_max-theta_min)))));
- }
-
- /// return the cell index corrsponding to a phi value
- inline unsigned int get_phi_cell(double phi){
- return (unsigned int) (1 << ((int) (32*phi/twopi+16)%32));
- }
-};
-
-/// test overlap
-/// \param r1 first range
-/// \param r2 second range
-/// \return true if overlap, false otherwise.
-bool is_range_overlap(const CSphtheta_phi_range &r1, const CSphtheta_phi_range &r2);
-
-/// compute union
-/// Note: we assume that the two intervals overlap
-/// \param r1 first range
-/// \param r2 second range
-/// \return union of the two ranges
-const CSphtheta_phi_range range_union(const CSphtheta_phi_range &r1, const CSphtheta_phi_range &r2);
-
-}
-
-#endif
+++ /dev/null
-// -*- C++ -*-
-///////////////////////////////////////////////////////////////////////////////
-// File: hash.h //
-// Description: header file for classes hash_element and hash_cones //
-// This file is part of the SISCone project. //
-// WARNING: this is not the main SISCone trunk but //
-// an adaptation to spherical coordinates //
-// For more details, see http://projects.hepforge.org/siscone //
-// //
-// Copyright (c) 2006-2008 Gavin Salam and Gregory Soyez //
-// //
-// This program 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. //
-// //
-// This program 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 this program; if not, write to the Free Software //
-// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
-// //
-// $Revision:: 268 $//
-// $Date:: 2009-03-12 21:24:16 +0100 (Thu, 12 Mar 2009) $//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef __SPH_HASH_H__
-#define __SPH_HASH_H__
-
-#include "momentum.h"
-
-namespace siscone_spherical{
-
-/**
- * \class sph_hash_element
- * information on store cones candidates.
- *
- * We store in this class the information used to count all
- * protocones in a first pass. This first pass only count
- * cones with different references and test their stbility
- * with the parent-child particles (border particles).
- */
-class sph_hash_element{
- public:
- CSph3vector centre; ///< centre of the cone
- bool is_stable; ///< true if stable w.r.t. "border particles"
-
- sph_hash_element *next; ///< pointer to the next element
-};
-
-/**
- * \class sph_hash_cones
- * list of cones candidates.
- *
- * We store in this class all the hash_elements and give
- * functions to manipulate them.
- */
-class sph_hash_cones{
- public:
- /// constructor with initialisation
- /// \param _Np number of particles
- /// \param _R2 cone radius (squared)
- sph_hash_cones(int _Np, double _R2);
-
- /// destructor
- ~sph_hash_cones();
-
- /**
- * insert a new candidate into the hash.
- * \param v 4-momentum of te cone to add
- * \param parent parent particle defining the cone
- * \param child child particle defining the cone
- * \param p_io whether the parent has to belong to the cone or not
- * \param c_io whether the child has to belong to the cone or not
- * \return 0 on success, 1 on error
- */
- int insert(CSphmomentum *v, CSphmomentum *parent, CSphmomentum *child, bool p_io, bool c_io);
-
- /**
- * insert a new candidate into the hash.
- * \param v 4-momentum of te cone to add
- * Note, in this case, we assume stability. We also assume
- * that eta and phi are computed for v
- * \return 0 on success, 1 on error
- */
- int insert(CSphmomentum *v);
-
- /// the cone data itself
- sph_hash_element **hash_array;
-
- /// number of elements
- int n_cones;
-
- /// number of occupied cells
-#ifdef DEBUG_STABLE_CONES
- int n_occupied_cells;
-#endif
-
- /// number of cells-1
- int mask;
-
- /// circle radius (squared)
- /// NOTE: need to be set before any call to 'insert'
- double R2;
-
- /// its squreed tangent
- double tan2R;
-};
-
-}
-#endif
+++ /dev/null
-// -*- C++ -*-
-///////////////////////////////////////////////////////////////////////////////
-// File: momentum.h //
-// Description: header file for 4-momentum class Cmomentum //
-// This file is part of the SISCone project. //
-// WARNING: this is not the main SISCone trunk but //
-// an adaptation to spherical coordinates //
-// For more details, see http://projects.hepforge.org/siscone //
-// //
-// Copyright (c) 2006-2008 Gavin Salam and Gregory Soyez //
-// //
-// This program 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. //
-// //
-// This program 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 this program; if not, write to the Free Software //
-// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
-// //
-// $Revision:: 256 $//
-// $Date:: 2008-07-14 13:52:16 +0200 (Mon, 14 Jul 2008) $//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef __SPH_VECTOR_H__
-#define __SPH_VECTOR_H__
-
-#include <vector>
-#include <math.h>
-#include <siscone/reference.h>
-#include "geom_2d.h"
-#include <siscone/defines.h>
-
-namespace siscone_spherical{
-
-/**
- * \class CSph3vector
- * \brief base class for managing the spatial part of Cmomentum (defined after)
- *
- * This class contains the information for particle or group of
- * particles management.
- * It is adapted to use spherical geometry, where, for our purposes,
- * the only time-consuming operation we need is the computation of
- * the norm. To compute it once-and-for-all and store it in a local
- * variable, you should call the 'build_norm' method.
- * On top of that, the angle phi is computed from the x-axis
- * and theta from the "north pole".
- */
-class CSph3vector{
- public:
- /// default ctor
- CSph3vector();
-
- /// ctor with initialisation
- CSph3vector(double _px, double _py, double _pz);
-
- /// default dtor
- ~CSph3vector();
-
- /// assignment of vectors
- CSph3vector& operator = (const CSph3vector &v);
-
- /// addition of vectors
- /// WARNING= norm is not updated
- const CSph3vector operator + (const CSph3vector &v);
-
- /// subtraction of vectors
- /// WARNING= norm is not updated
- const CSph3vector operator - (const CSph3vector &v);
-
- /// division by a constant
- /// WARNING= norm is not updated
- const CSph3vector operator / (const double &r);
-
- /// incrementation of vectors
- /// WARNING= norm is not updated
- CSph3vector& operator += (const CSph3vector &v);
-
- /// decrementation of vectors
- /// WARNING= norm is not updated
- CSph3vector& operator -= (const CSph3vector &v);
-
- /// multiplication by a constant
- /// WARNING= norm is not updated
- CSph3vector& operator *= (const double &r);
-
- /// division by a constant
- /// WARNING= norm is not updated
- CSph3vector& operator /= (const double &r);
-
- /// computes pT
- inline double perp() const {return sqrt(perp2());}
-
- /// computes pT^2
- inline double perp2() const {return px*px+py*py;}
-
- /// 3-vect norm
- inline double norm() const {return sqrt(px*px+py*py+pz*pz);}
-
- /// 3-vect norm squared
- inline double norm2() const {return px*px+py*py+pz*pz;}
-
- /// 3-vect azimuthal angle
- inline double phi() const {return atan2(py, px);}
-
- /// 3-vect polar angle
- inline double theta() const {return atan2(perp(),pz);}
-
- /// build the spatial normfrom 4-momentum info
- /// !!! WARNING !!!
- /// !!! computing the norm is the only time-consuming !!!
- /// !!! information we need in all computations. !!!
- /// !!! use this whenever you need repeated access !!!
- /// !!! to the norm to store it in the local variable !!!
- void build_norm();
-
- /// just a useful tool to store theta and phi
- /// locally (in _theta and _phi) in case you need
- /// repeated access
- void build_thetaphi();
-
- /// for this direction, compute the two reference directions
- /// used to measure angles
- void get_angular_directions(CSph3vector &angular_dir1, CSph3vector &angular_dir2);
-
- double px; ///< x-momentum
- double py; ///< y-momentum
- double pz; ///< z-momentum
-
- double _norm; ///< particle spatial norm (available ONLY after a call to build_norm)
- double _theta; ///< particle theta angle (available ONLY after a call to build_thetaphi)
- double _phi; ///< particle phi angle (available ONLY after a call to build_thetaphi)
-
- //////////////////////////////////////////////
- // the following part is used for checksums //
- //////////////////////////////////////////////
- siscone::Creference ref; ///< reference number for the vector
-};
-
-/**
- * \class CSphmomentum
- * \brief base class for dynamic coordinates management
- *
- * This class contains the information for particle or group of
- * particles management.
- * It is adapted to use spherical geometry, where, for our purposes,
- * the only time-consuming operation we need is the computation of
- * the norm. To compute it once-and-for-all and store it in a local
- * variable, you should call the 'build_norm' method.
- * On top of that, the angle phi is computed from the x-axis
- * and theta from the "north pole".
- */
-class CSphmomentum : public CSph3vector{
- public:
- /// default ctor
- CSphmomentum();
-
- /// init from a 3-vect
- CSphmomentum(CSph3vector &init, double E=0.0);
-
- /// ctor with initialisation
- CSphmomentum(double _px, double _py, double _pz, double _E);
-
- /// ctor with detailed initialisation
- //CSphmomentum(double _eta, double _phi, siscone::Creference _ref);
-
- /// default dtor
- ~CSphmomentum();
-
- /// computes m
- inline double mass() const {return sqrt(mass2());}
-
- /// computes m^2
- inline double mass2() const {return perpmass2()-perp2();}
-
- /// transverse mass, mt = sqrt(pt^2+m^2) = sqrt(E^2 - pz^2)
- inline double perpmass() const {return sqrt((E-pz)*(E+pz));}
-
- /// transverse mass squared, mt^2 = pt^2+m^2 = E^2 - pz^2
- inline double perpmass2() const {return (E-pz)*(E+pz);}
-
- /// computes transverse energy
- inline double Et() const {return E/sqrt(1.0+pz*pz/perp2());}
-
- /// computes transverse energy (squared)
- inline double Et2() const {return E*E/(1.0+pz*pz/perp2());}
-
- /// assignment of vectors
- CSphmomentum& operator = (const CSphmomentum &v);
-
- /// addition of vectors
- /// !!! WARNING !!! no updating of eta and phi !!!
- const CSphmomentum operator + (const CSphmomentum &v);
-
- /// incrementation of vectors
- /// !!! WARNING !!! no updating of eta and phi !!!
- CSphmomentum& operator += (const CSphmomentum &v);
-
- /// decrementation of vectors
- /// !!! WARNING !!! no updating of eta and phi !!!
- CSphmomentum& operator -= (const CSphmomentum &v);
-
- double E; ///< energy
-
- int parent_index; ///< particle number in the parent list
- int index; ///< internal particle number
-};
-
-/// ordering of two vectors
-/// this is by default done w.r.t. their references
-bool operator < (const CSphmomentum &v1, const CSphmomentum &v2);
-
-/// ordering of vectors in eta (e.g. used in collinear tests)
-bool momentum_theta_less(const CSphmomentum &v1, const CSphmomentum &v2);
-
-/// ordering of vectors in pt
-bool momentum_pt_less(const CSphmomentum &v1, const CSphmomentum &v2);
-
-
-//////////////////////////
-// some handy utilities //
-//////////////////////////
-
-/// square
-inline double sqr(double x){return x*x;}
-
-/// dot product for te spatial 3-vect
-/// \param v1 first 4-vect
-/// \param v2 second 4-vect
-inline double dot_product3(const CSph3vector &v1, const CSph3vector &v2){
- //double tmp = v1.px*v2.px + v1.py*v2.py + v1.pz*v2.pz;
- //if (!isfinite(tmp)){
- // std::cout << "dot_product inf: " << std::endl;
- // std::cout << " angles: " << v1._theta << " " << v1._phi << " and " << v2._theta << " " << v2._phi << std::endl;
- // std::cout << " moms : " << v1.px << " " << v1.py << " " << v1.pz
- // << " and " << v2.px << " " << v2.py << " " << v2.pz << std::endl;
- //}
- return v1.px*v2.px + v1.py*v2.py + v1.pz*v2.pz;
-}
-
-/// cross product for the spatial 3-vect
-/// \param v1 first 4-vect
-/// \param v2 second 4-vect
-inline CSph3vector cross_product3(const CSph3vector &v1, const CSph3vector &v2){
- //CSph3vector tmp;
- //tmp.px = v1.py*v2.pz-v1.pz*v2.py;
- //tmp.py = v1.pz*v2.px-v1.px*v2.pz;
- //tmp.pz = v1.px*v2.py-v1.py*v2.px;
- //return tmp;
- return CSph3vector(v1.py*v2.pz-v1.pz*v2.py,
- v1.pz*v2.px-v1.px*v2.pz,
- v1.px*v2.py-v1.py*v2.px);
-}
-
-/// squared norm of the cross product for the spatial 3-vect (energy is set to 0)
-/// \param v1 first 4-vect
-/// \param v2 second 4-vect
-inline double norm2_cross_product3(const CSph3vector &v1, const CSph3vector &v2){
- return sqr(v1.py*v2.pz-v1.pz*v2.py) + sqr(v1.pz*v2.px-v1.px*v2.pz) + sqr(v1.px*v2.py-v1.py*v2.px);
-}
-
-/// get tangent squared of the spherical distance between two vectors
-/// \param v1 vector defining the first point
-/// \param v2 vector defining the second point
-inline double get_tan2_distance(const CSphmomentum &v1, const CSphmomentum &v2){
- return norm2_cross_product3(v1,v2)/sqr(dot_product3(v1,v2));
-}
-
-/// get spherical distance between to vectors
-/// \param v1 vector defining the first point
-/// \param v2 vector defining the second point
-inline double get_distance(const CSph3vector *v1, const CSph3vector *v2){
- return atan2(sqrt(norm2_cross_product3(*v1,*v2)), dot_product3(*v1,*v2));
-}
-
-/// return true if the two points are distant by less than get spherical distance between two vectors
-/// \param v1 vector defining the first point
-/// \param v2 vector defining the second point
-/// \param tan2R tangent squared of the max distance
-/// WARNING: using the tangent here is dangerous for R>pi/2.
-/// this never happens per se for "regular R" but
-/// it may in the vicinity computation as we're using
-/// 2R there.
-inline bool is_closer(const CSph3vector *v1, const CSph3vector *v2, const double tan2R){
- double dot = dot_product3(*v1,*v2);
- return (dot>=0) && (norm2_cross_product3(*v1,*v2)<=tan2R*dot*dot);
-}
-
-/// return true if the two points are distant by less than get spherical distance between to vectors
-/// \param v1 vector defining the first point
-/// \param v2 vector defining the second point
-/// \param tan2R tangent squared of the max distance
-/// safer version but computes the norm
-inline bool is_closer_safer(const CSph3vector *v1, const CSph3vector *v2, const double cosR){
- return dot_product3(*v1,*v2)>=cosR*sqrt(v1->norm2()*v2->norm2());
- //double dot = dot_product3(*v1,*v2);
- //return (dot>=0) && (norm2_cross_product3(*v1,*v2)<tan2R*dot*dot);
-}
-
-/// multiply a vector by a constant
-/// WARNING: norm not updated
-inline CSph3vector operator * (const double &r, const CSph3vector &v){
- CSph3vector tmp = v;
- return tmp*=r;
-}
-}
-#endif
+++ /dev/null
-// -*- C++ -*-
-///////////////////////////////////////////////////////////////////////////////
-// File: protocones.h //
-// Description: header file for stable cones determination (Cstable_cones) //
-// This file is part of the SISCone project. //
-// WARNING: this is not the main SISCone trunk but //
-// an adaptation to spherical coordinates //
-// For more details, see http://projects.hepforge.org/siscone //
-// //
-// Copyright (c) 2006-2008 Gavin Salam and Gregory Soyez //
-// //
-// This program 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. //
-// //
-// This program 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 this program; if not, write to the Free Software //
-// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
-// //
-// $Revision:: 255 $//
-// $Date:: 2008-07-12 17:40:35 +0200 (Sat, 12 Jul 2008) $//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef __SPH_PROTOCONES_H__
-#define __SPH_PROTOCONES_H__
-
-#include "momentum.h"
-#include "vicinity.h"
-#include <stdio.h>
-#include <vector>
-#include <list>
-#include "hash.h"
-
-#include <siscone/defines.h>
-
-namespace siscone_spherical{
-
-/**
- * \class CSphborder_store
- *
- * class for storing a border momentum (in context of co-circularity
- * checks).
-
- * This class essentially calculates angle of border point w.r.t.
- * circle center (eta & phi), and provides a store of information
- * about whether we are currently including this point in the
- * candidate
- */
-class CSphborder_store{
-public:
- /// default ctor
- CSphborder_store(CSphmomentum * momentum, CSph3vector ¢re, CSph3vector &angl_dir1, CSph3vector &angl_dir2) :
- mom(momentum), is_in(false) {
- CSph3vector diff = (*momentum) - centre;
- angle = atan2(dot_product3(diff, angl_dir2), dot_product3(diff, angl_dir1));
-#ifdef DEBUG_STABLE_CONES
- std::cout << " adding point " << momentum->_theta << ", " << momentum->_phi
- << " at an angle of " << angle << std::endl;
-#endif
- }
-
- CSphmomentum * mom; ///< particle momentum
- double angle; ///< angle w.r.t. circle centre
- bool is_in; ///< inclusion status of the particle
-};
-
-
-/// allows easy sorting of CSphborder_store objects (which need to be
-/// ordered in angle).
-inline bool operator<(const CSphborder_store & a, const CSphborder_store & b) {
- return a.angle < b.angle;
-}
-
-
-/**
- * \class CSphstable_cones
- * \brief Computes the list of stable comes from a particle list.
- *
- * This class does the first fundamental task of te cone algorithm:
- * it is used to compute the list of stable cones given a list
- * of particles.
- */
-class CSphstable_cones : public CSphvicinity{
- public:
- /// default ctor
- CSphstable_cones();
-
- /// ctor with initialisation (sse init for details)
- CSphstable_cones(std::vector<CSphmomentum> &_particle_list);
-
- /// default dtor
- ~CSphstable_cones();
-
- /**
- * initialisation
- * \param _particle_list list of particles
- */
- void init(std::vector<CSphmomentum> &_particle_list);
-
- /**
- * compute stable cones.
- * This function really does the job i.e. computes
- * the list of stable cones (in a seedless way)
- * \param _radius radius of the cones
- * \return The number of stable cones found is returned
- */
- int get_stable_cones(double _radius);
-
- /// list of stable cones
- std::vector<CSphmomentum> protocones;
-
- /// list of candidates
- sph_hash_cones *hc;
-
- /// total number of tested cones
- int nb_tot;
-#ifdef DEBUG_STABLE_CONES
- int nb_hash_cones, nb_hash_occupied;
-#endif
-
- protected:
- /// cone radius
- double R;
-
- /// cone radius SQUARED
- double R2;
-
- /// squared tangent of the cone radius
- double tan2R;
-
- private:
- /// cone with a given particle as parent
- /// this reduction to a single vector assumes we trust the checksums
- CSphmomentum cone;
-
- /// child particle, taken in the 'vicinity' list
- CSphmomentum *child;
-
- /// centre of the tested cone
- CSphvicinity_elm *centre;
-
- /// index in the particle list;
- unsigned int centre_idx;
-
- /// first cone used in the vicinity list
- unsigned int first_cone;
-
- /**
- * initialise the cone.
- * We take the first particle in the angular ordering to compute this one
- * \return 0 on success, 1 on error
- */
- int init_cone();
-
- /**
- * test cones.
- * We check if the cone(s) build with the present parent and child
- * are stable
- * \return 0 on success 1 on error
- */
- int test_cone();
-
- /**
- * update the cone
- * go to the next child for that parent and update 'cone' appropriately
- * \return 0 if update candidate found, 1 otherwise
- */
- int update_cone();
-
- /*
- * run through the vicinity of the current parent and for each child
- * indicate which members are cocircular...
- */
- void prepare_cocircular_lists();
-
- /**
- * check if we are in a situation of cocircularity.
- * if it is the case, update and test in the corresponding way
- * \return 'false' if no cocircularity detected, 'true' otherwise
- * Note that if cocircularity is detected, we need to
- * recall 'update' from 'update' !!!
- */
- bool cocircular_check();
-
- /**
- * Routine for testing cocircular configurations in p^3 time,
- * rather than 2^p time;
- */
- void test_cone_cocircular(CSphmomentum & borderless_cone,
- std::list<CSphmomentum *> & border_list);
-
- /**
- * carry out the computations needed for the stability check of the
- * candidate, using the border_vect to indicate which particles
- * should / should not be in the stable cone; if the cone is stable
- * insert it into the hash.
- */
- void test_stability(CSphmomentum & candidate,
- const std::vector<CSphborder_store> & border_vect);
-
- /**
- * compute the cone contents by going once around the full set of
- * circles and tracking the entry/exit status each time -- this sets
- * up the inclusion information, which can then be directly used to
- * calculate the cone momentum.
- */
- void compute_cone_contents();
-
- /**
- * compute the cone momentum from particle list.
- * in this version, we use the 'pincluded' information
- * from the CSphvicinity class
- */
- void recompute_cone_contents();
-
- /*
- * if we have gone beyond the acceptable threshold of change, compute
- * the cone momentum from particle list. in this version, we use the
- * 'pincluded' information from the CSphvicinity class, but we don't
- * change the member cone, only the locally supplied one
- */
- void recompute_cone_contents_if_needed(CSphmomentum & this_cone, double & this_dpt);
-
- /**
- * compute stability of all enumerated candidates.
- * For all candidate cones which are stable w.r.t. their border particles,
- * pass the last test: stability with quadtree intersection
- */
- int proceed_with_stability();
-
- /*
- * circle intersection.
- * computes the intersection with a circle of given centre and radius.
- * The output takes the form of a checkxor of the intersection's particles
- * - cx circle centre x coordinate
- * - cy circle centre y coordinate
- * return the checkxor for the intersection
- ******************************************************************/
- siscone::Creference circle_intersect(CSph3vector &cone_centre);
-
- /// present candidate cone
- CSphmomentum cone_candidate;
-
- /// in case of co-circular points, vector for them
- std::vector<CSphmomentum*> child_list;
-
- /// list of cocircular enclusures already studied
- /// first element if cone contents, second is cone border
- std::vector< std::pair<siscone::Creference,siscone::Creference> > multiple_centre_done;
-
- // information for updating cone contents to avoid rounding errors
- double dpt; ///< sums of Delta P_t
-};
-
-}
-#endif
+++ /dev/null
-// -*- C++ -*-
-///////////////////////////////////////////////////////////////////////////////
-// File: siscone.h //
-// Description: header file for the main SISCone class //
-// This file is part of the SISCone project. //
-// WARNING: this is not the main SISCone trunk but //
-// an adaptation to spherical coordinates //
-// For more details, see http://projects.hepforge.org/siscone //
-// //
-// Copyright (c) 2006-2008 Gavin Salam and Gregory Soyez //
-// //
-// This program 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. //
-// //
-// This program 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 this program; if not, write to the Free Software //
-// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
-// //
-// $Revision:: 261 $//
-// $Date:: 2008-07-23 17:54:30 +0200 (Wed, 23 Jul 2008) $//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef __SPH_SISCONE_H__
-#define __SPH_SISCONE_H__
-
-#include "protocones.h"
-#include "split_merge.h"
-
-namespace siscone_spherical{
-
-/**
- * \class CSphsiscone
- * final class: gather everything to compute the jet contents.
- *
- * This is the class user should use.
- * It computes the jet contents of a list of particles
- * given a cone radius and a threshold for splitting/merging.
- *
- * After the call to 'perform', the vector jets is filled with
- * the jets found. the 'contents' field of each jets contains
- * the indices of the particles included in that jet.
- */
-class CSphsiscone : public CSphstable_cones, public CSphsplit_merge{
- public:
- /// default ctor
- CSphsiscone();
-
- /// default dtor
- ~CSphsiscone();
-
- /**
- * compute the jets from a given particle set.
- * We are doing multiple passes such pass n_pass looks for jets among
- * all particles not put into jets during previous passes.
- * By default the number of passes is infinite (0).
- * \param _particles list of particles
- * \param _radius cone radius
- * \param _f shared energy threshold for splitting&merging
- * \param _n_pass_max maximum number of passes (0=full search)
- * \param _Emin minimum energy of the protojets
- * \param _split_merge_scale the scale choice for the split-merge procedure
- * NOTE: SM_Etilde
- * is always IR safe
- * SM_E
- * is IR unsafe for events with mom. conservation
- *
- * \return the number of jets found.
- */
- int compute_jets(std::vector<CSphmomentum> &_particles, double _radius, double _f,
- int _n_pass_max=0, double _Emin=0.0,
- Esplit_merge_scale _split_merge_scale=SM_Etilde);
-
- /**
- * recompute the jets with a different overlap parameter.
- * we use the same particles and R as in the preceeding call.
- * \param _f shared energy threshold for splitting&merging
- * \param _Emin minimum energy of the protojets
- * \param _split_merge_scale the scale choice for the split-merge procedure
- * split--merge variable
- * NOTE: using pt leads to IR unsafety for some events with momentum
- * conservation. So we strongly advise not to change the default
- * value.
- * \return the number of jets found, -1 if recomputation not allowed.
- */
- int recompute_jets(double _f, double _Emin = 0.0,
- Esplit_merge_scale _split_merge_scale=SM_Etilde);
-
- /// list of protocones found pass-by-pass
- std::vector<std::vector<CSphmomentum> > protocones_list;
-
- // random number initialisation
- static bool init_done; ///< check random generator initialisation
-
-#ifdef DEBUG_STABLE_CONES
- int nb_hash_cones_total, nb_hash_occupied_total;
-#endif
-
- private:
- bool rerun_allowed; ///< is recompute_jets allowed ?
-};
-
-
-// finally, a bunch of functions to access to
-// basic information (package name, version)
-//---------------------------------------------
-
-/**
- * return SISCone package name.
- * This is nothing but "SISCone", it is a replacement to the
- * PACKAGE_NAME string defined in config.h and which is not
- * public by default.
- * \return the SISCone name as a string
- */
-std::string siscone_package_name();
-
-/**
- * return SISCone version number.
- * \return a string of the form "X.Y.Z" with possible additional tag
- * (alpha, beta, devel) to mention stability status
- */
-std::string siscone_version();
-
-}
-#endif
+++ /dev/null
-// -*- C++ -*-
-///////////////////////////////////////////////////////////////////////////////
-// File: split_merge.h //
-// Description: header file for splitting/merging (contains the CJet class) //
-// This file is part of the SISCone project. //
-// WARNING: this is not the main SISCone trunk but //
-// an adaptation to spherical coordinates //
-// For more details, see http://projects.hepforge.org/siscone //
-// //
-// Copyright (c) 2006-2008 Gavin Salam and Gregory Soyez //
-// //
-// This program 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. //
-// //
-// This program 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 this program; if not, write to the Free Software //
-// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
-// //
-// $Revision:: 268 $//
-// $Date:: 2009-03-12 21:24:16 +0100 (Thu, 12 Mar 2009) $//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef __SPH_SPLIT_MERGE_H__
-#define __SPH_SPLIT_MERGE_H__
-
-#include <siscone/defines.h>
-#include "geom_2d.h"
-#include "momentum.h"
-#include <stdio.h>
-#include <vector>
-#include <set>
-#include <memory>
-#include <string>
-
-namespace siscone_spherical{
-
-/**
- * \class CSphjet
- * real Jet information.
- *
- * This class contains information for one single jet.
- * That is, first, its momentum carrying information
- * about its centre and pT, and second, its particle
- * contents
- */
-class CSphjet{
- public:
- /// default ctor
- CSphjet();
-
- /// default dtor
- ~CSphjet();
-
- CSphmomentum v; ///< jet momentum
- double E_tilde; ///< sum of E_i [1+sin^2(theta_iJ)]
- int n; ///< number of particles inside
- std::vector<int> contents; ///< particle contents (list of indices)
-
- /// ordering variable used for ordering and overlap in the
- /// split--merge. This variable is automatically set either to
- /// E_tilde or E depending on the siscone parameter.
- ///
- /// Note that the default behaviour is E_tilde and that other
- /// choices may lead to infrared unsafe situations.
- ///
- /// Note: we use the square of the varible rather than the variable
- /// itself
- ///
- /// Note 2: for the overlap computation, we shall use the jet energy!
- double sm_var2;
-
- /// covered range in eta-phi
- CSphtheta_phi_range range;
-
- /// pass at which the jet has been found
- /// It starts at 0 (first pass), -1 means infinite rapidity
- int pass;
-};
-
-/// ordering of jets in pt
-///bool jets_pt_less(const CSphjet &j1, const CSphjet &j2);
-
-/// ordering of jets in energy (e.g. used in final jets ordering)
-bool jets_E_less(const CSphjet &j1, const CSphjet &j2);
-
-
-/// the choices of scale variable that can be used in the split-merge
-/// step, both for ordering the protojets and for measuing their
-/// overlap; E is defined in E-scheme (4-momentum) recombination;
-/// Etilde = \sum_{i\in jet} E_i [1+sin^2(theta_{i,jet})]
-///
-/// NB: if one changes the order here, one _MUST_ also change the order
-/// in the SISCone plugin
-enum Esplit_merge_scale {
- SM_E, ///< Energy (IR unsafe with momentum conservation)
- SM_Etilde ///< sum_{i \in jet} E_i [1+sin^2(theta_iJ)]
-};
-
-/// return the name of the split-merge scale choice
-std::string split_merge_scale_name(Esplit_merge_scale sms);
-
-/**
- * \class CSphsplit_merge_ptcomparison
- * a class that allows us to carry out comparisons of pt of jets, using
- * information from exact particle contents where necessary.
- */
-class CSphsplit_merge_ptcomparison{
-public:
- /// default ctor
- CSphsplit_merge_ptcomparison() :
- particles(0), split_merge_scale(SM_Etilde){};
-
- /// return the name corresponding to the SM scale variable
- std::string SM_scale_name() const {
- return split_merge_scale_name(split_merge_scale);}
-
- std::vector<CSphmomentum> * particles; ///< pointer to the list of particles
- std::vector<double> * particles_norm2; ///< pointer to the particles's norm^2
-
- /// comparison of 2 CSphjet
- bool operator()(const CSphjet &jet1, const CSphjet &jet2) const;
-
- /**
- * get the difference between 2 jets, calculated such that rounding
- * errors will not affect the result even if the two jets have
- * almost the same content (so that the difference is below the
- * rounding errors)
- *
- * \param j1 first jet
- * \param j2 second jet
- * \param v jet1-jet2
- * \param E_tilde jet1-jet2 E_tilde
- */
- void get_difference(const CSphjet &j1, const CSphjet &j2, CSphmomentum *v, double *E_tilde) const;
-
- /// the following parameter controls the variable we're using for
- /// the split-merge process i.e. the variable we use for
- /// 1. ordering jet candidates;
- /// 2. computing the overlap fraction of two candidates.
- /// The default value uses Etilde. The other alternative is E
- /// NOTE: Modifying the default choice can have nasty effects:
- /// - using E is IR-safe for QCD jets but the IR unsafety remains
- /// for back-to-back jets of unstable narrow-width particles
- /// (e.g. Higgs).
- /// Therefore, keeping the default value is strongly advised.
- Esplit_merge_scale split_merge_scale;
-};
-
-
-// iterator types
-/// iterator definition for the jet candidates structure
-typedef std::multiset<siscone_spherical::CSphjet,CSphsplit_merge_ptcomparison>::iterator cjet_iterator;
-
-/// iterator definition for the jet structure
-typedef std::vector<siscone_spherical::CSphjet>::iterator jet_iterator;
-
-
-
-/**
- * \class CSphsplit_merge
- * Class used to split and merge jets.
- */
-class CSphsplit_merge{
- public:
- /// default ctor
- CSphsplit_merge();
-
- /// default dtor
- ~CSphsplit_merge();
-
-
- //////////////////////////////
- // initialisation functions //
- //////////////////////////////
-
- /**
- * initialisation function
- * \param _particles list of particles
- * \param protocones list of protocones (initial jet candidates)
- * \param R2 cone radius (squared)
- * \param Emin minimal energy allowed for jets
- * \return 0 on success, 1 on error
- */
- int init(std::vector<CSphmomentum> &_particles, std::vector<CSphmomentum> *protocones, double R2, double Emin=0.0);
-
- /**
- * initialisation function for particle list
- * \param _particles list of particles
- * \return 0 on success, 1 on error
- */
- int init_particles(std::vector<CSphmomentum> &_particles);
-
- /**
- * build initial list of left particles
- */
- int init_pleft();
-
- /**
- * use an energy-dependent boundary for splitting
- * When called with true, the criterium for splitting two protojets
- * will be to compare D1^2/kt1^2 vs. D2^2/kt2^2, the (anti-)kt-weighted
- * distance instead of the plain distance D1^2 vs. D2^2.
- * This can be set in order to produce more circular hard jets,
- * with the same underlying philosophy as for the anti-kt algorithm.
- * We thus expect a behaviour closer to the IterativeCone one.
- * By default, we use the standard D1^2 vs. D2^2 comparison and this
- * function is not called.
- */
- inline int set_E_weighted_splitting(bool _use_E_weighted_splitting){
- use_E_weighted_splitting = _use_E_weighted_splitting;
- return 0;
- }
-
- ////////////////////////
- // cleaning functions //
- ////////////////////////
-
- /// partial clearance
- int partial_clear();
-
- /// full clearance
- int full_clear();
-
-
- /////////////////////////////////
- // main parts of the algorithm //
- /////////////////////////////////
-
- /**
- * build the list 'p_uncol_hard' from p_remain by clustering
- * collinear particles
- * note that thins in only used for stable-cone detection
- * so the parent_index field is unnecessary
- *
- * Note that soft particles are not removed here
- * This is just a remnant from the trunk version
- */
- int merge_collinear_and_remove_soft();
-
- /**
- * add a list of protocones
- * \param protocones list of protocones (initial jet candidates)
- * \param R2 cone radius (squared)
- * \param Emin minimal emergy allowed for jets
- * \return 0 on success, 1 on error
- */
- int add_protocones(std::vector<CSphmomentum> *protocones, double R2, double Emin=0.0);
-
- /**
- * really do the splitting and merging
- * At the end, the vector jets is filled with the jets found.
- * the 'contents' field of each jets contains the indices
- * of the particles included in that jet.
- * \param overlap_tshold threshold for splitting/merging transition
- * \param Emin minimal energy allowed for jets
- * \return the number of jets is returned
- */
- int perform(double overlap_tshold, double Emin=0.0);
-
-
- //////////////////////////////
- // save and debug functions //
- //////////////////////////////
-
- /// save final jets
- /// \param flux stream to save the jet contentss
- int save_contents(FILE *flux);
-
- /// show jets/candidates status
- int show();
-
- // particle information
- int n; ///< number of particles
- std::vector<CSphmomentum> particles; ///< list of particles
- std::vector<double> particles_norm2; ///< norm^2 of the particle (3-vect part)
- int n_left; ///< numer of particles that does not belong to any jet
- std::vector<CSphmomentum> p_remain; ///< list of particles remaining to deal with
- std::vector<CSphmomentum> p_uncol_hard; ///< list of particles remaining with collinear clustering
- int n_pass; ///< index of the run
-
- /// minimal difference in squared distance between a particle and
- /// two overlapping protojets when doing a split (useful when
- /// testing approx. collinear safety)
- double most_ambiguous_split;
-
- // jets information
- std::vector<CSphjet> jets; ///< list of jets
-
- // working entries
- int *indices; ///< maximal size array for indices works
- int idx_size; ///< number of elements in indices1
-
- /// The following flag indicates that identical protocones
- /// are to be merged automatically each time around the split-merge
- /// loop and before anything else happens.
- ///
- /// This flag is only effective if ALLOW_MERGE_IDENTICAL_PROTOCONES
- /// is set in 'defines.h'
- /// Note that this lead to infrared-unsafety so it is disabled
- /// by default
- bool merge_identical_protocones;
-
- /// member used for detailed comparisons of pt's
- CSphsplit_merge_ptcomparison ptcomparison;
-
- /// stop split--merge when the SM_var of the hardest protojet
- /// is below this cut-off.
- /// This is not collinear-safe so you should not use this
- /// variable unless you really know what you are doing
- /// Note that the cut-off is set on the variable squared.
- double SM_var2_hardest_cut_off;
-
- /// Energy cutoff for the particles to put in p_uncol_hard
- /// this is meant to allow removing soft particles in the
- /// stable-cone search.
- double stable_cone_soft_E2_cutoff;
-
- private:
- /**
- * get the overlap between 2 jets
- * \param j1 first jet
- * \param j2 second jet
- * \param v returned overlap^2 (determined by the choice of SM variable)
- * \return true if overlapping, false if disjoint
- */
- bool get_overlap(const CSphjet &j1, const CSphjet &j2, double *v);
-
-
- /**
- * split the two given jets.
- * during this procedure, the jets j1 & j2 are replaced
- * by 2 new jets. Common particles are associted to the
- * closest initial jet.
- * \param it_j1 iterator of the first jet in 'candidates'
- * \param it_j2 iterator of the second jet in 'candidates'
- * \param j1 first jet (CSphjet instance)
- * \param j2 second jet (CSphjet instance)
- * \return true on success, false on error
- */
- bool split(cjet_iterator &it_j1, cjet_iterator &it_j2);
-
- /**
- * merge the two given jet.
- * during this procedure, the jets j1 & j2 are replaced
- * by 1 single jets containing both of them.
- * \param it_j1 iterator of the first jet in 'candidates'
- * \param it_j2 iterator of the second jet in 'candidates'
- * \return true on success, false on error
- */
- bool merge(cjet_iterator &it_j1, cjet_iterator &it_j2);
-
- /**
- * Check whether or not a jet has to be inserted in the
- * list of protojets. If it has, set its sm_variable and
- * insert it to the list of protojets.
- * \param jet jet to insert
- */
- bool insert(CSphjet &jet);
-
- /**
- * given a 4-momentum and its associated pT, return the
- * variable tht has to be used for SM
- * \param v 4 momentum of the protojet
- * \param E_tilde E_tilde of the protojet
- */
- double get_sm_var2(CSphmomentum &v, double &E_tilde);
-
- /// compute Etilde for a given jet
- void compute_Etilde(CSphjet &j);
-
- // jet information
- /// list of jet candidates
- std::auto_ptr<std::multiset<CSphjet,CSphsplit_merge_ptcomparison> > candidates;
-
- /// minimal E
- double E_min;
-
- /**
- * do we have or not to use the energy-weighted splitting
- * (see description for set_E_weighted_splitting)
- * This will be false by default
- */
- bool use_E_weighted_splitting;
-
-#ifdef ALLOW_MERGE_IDENTICAL_PROTOCONES
- /// checkxor for the candidates (to avoid having twice the same contents)
- std::set<siscone::Creference> cand_refs;
-#endif
-};
-
-}
-
-
-#endif
+++ /dev/null
-// -*- C++ -*-
-///////////////////////////////////////////////////////////////////////////////
-// File: vicinity.h //
-// Description: header file for particle vicinity (Cvicinity class) //
-// This file is part of the SISCone project. //
-// WARNING: this is not the main SISCone trunk but //
-// an adaptation to spherical coordinates //
-// For more details, see http://projects.hepforge.org/siscone //
-// //
-// Copyright (c) 2006-2008 Gavin Salam and Gregory Soyez //
-// //
-// This program 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. //
-// //
-// This program 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 this program; if not, write to the Free Software //
-// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
-// //
-// $Revision:: 255 $//
-// $Date:: 2008-07-12 17:40:35 +0200 (Sat, 12 Jul 2008) $//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef __SPH_VICINITY_H__
-#define __SPH_VICINITY_H__
-
-#include <siscone/vicinity.h>
-#include <vector>
-#include <list>
-#include "momentum.h"
-#include <siscone/defines.h>
-#ifdef USE_QUADTREE_FOR_STABILITY_TEST
-#include <siscone/quadtree.h>
-#endif
-
-namespace siscone_spherical{
-
-
-/**
- * \class CSphvicinity_elm
- * \brief element in the vicinity of a parent.
- *
- * class used to manage one points in the vicinity
- * of a parent point.
- */
-class CSphvicinity_elm{
- public:
- /// pointer to the second borderline particle
- CSphmomentum *v;
-
- /// variable to tell if the particle is inside or outside the cone
- siscone::Cvicinity_inclusion *is_inside;
-
- // centre variables
- CSph3vector centre; ///< direction of the centre
- double angle; ///< angle with parent
- bool side; ///< true if angle on the positive side, false otherwise
- double cocircular_range; ///< amount by which the angle can be varied while
- ///< maintaining this point within co-circularity margin
-
- /// list of elements co-circular with this one
- /// NB: empty list uses less mem than vector
- std::list<CSphvicinity_elm * > cocircular;
-};
-
-/// ordering pointers to CSphvicinity_elm
-bool ve_less(CSphvicinity_elm *ve1, CSphvicinity_elm *ve2);
-
-
-/**
- * \class CSphvicinity
- * \brief list of element in the vicinity of a parent.
- *
- * class used to manage the points which are in the vicinity
- * of a parent point.
- */
-class CSphvicinity{
- public:
- /// default constructor
- CSphvicinity();
-
- /// constructor with initialisation (see set_particle_list)
- CSphvicinity(std::vector<CSphmomentum> &_particle_list);
-
- /// default destructor
- ~CSphvicinity();
-
- /**
- * set the particle_list
- * \param _particle_list list of particles (type CSphmomentum)
- */
- void set_particle_list(std::vector<CSphmomentum> &_particle_list);
-
- /**
- * build the vicinity list from the list of points.
- * \param _parent reference particle
- * \param _VR vicinity radius
- */
- void build(CSphmomentum *_parent, double _VR);
-
- // cone kinematical information
- CSphmomentum *parent; ///< parent vector
- double VR; ///< radius of the vicinity
- double VR2; ///< squared radius of the vicinity
- double cosVR; ///< cosine of the radius of the vicinity
- double R; ///< normal radius
- double R2; ///< squared normal radius
- double tan2R; ///< squared tangent of the normal radius
- double D2_R; ///< euclidian distance (squared) corresp. to the arc R
- double inv_R_EPS_COCIRC; ///< R / EPSILON_COCIRCULAR
- double inv_R_2EPS_COCIRC; ///< R / (2*EPSILON_COCIRCULAR)
-
- // particle list information
- int n_part; ///< number of particles
- std::vector<CSphmomentum> plist; ///< the list of particles
- /// the inclusion state of particles
- std::vector<siscone::Cvicinity_inclusion> pincluded;
- CSphvicinity_elm *ve_list; ///< list of vicinity elements built from particle list (size=2*n)
-#ifdef USE_QUADTREE_FOR_STABILITY_TEST
- siscone::Cquadtree *quadtree; ///< quadtree used for final stability tests
-#endif
-
- // vicinity information
- std::vector<CSphvicinity_elm*> vicinity; ///< list of points in parent's vicinity
- unsigned int vicinity_size; ///< number of elements in vicinity
-
- protected:
- /**
- * append a particle to the 'vicinity' list after
- * having tested it and computed the angular-ordering quantities
- * \param v vector to test
- */
- void append_to_vicinity(CSphmomentum *v);
-
- // internal variables
- CSph3vector parent_centre; ///< parent centre
- CSph3vector angular_dir1; ///< main direction to measure angles
- CSph3vector angular_dir2; ///< second direction to measure angles (sign)
-};
-
-}
-
-#endif
+++ /dev/null
-// -*- C++ -*-
-///////////////////////////////////////////////////////////////////////////////
-// File: split_merge.h //
-// Description: header file for splitting/merging (contains the CJet class) //
-// This file is part of the SISCone project. //
-// For more details, see http://projects.hepforge.org/siscone //
-// //
-// Copyright (c) 2006 Gavin Salam and Gregory Soyez //
-// //
-// This program 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. //
-// //
-// This program 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 this program; if not, write to the Free Software //
-// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
-// //
-// $Revision:: 268 $//
-// $Date:: 2009-03-12 21:24:16 +0100 (Thu, 12 Mar 2009) $//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef __SPLIT_MERGE_H__
-#define __SPLIT_MERGE_H__
-
-#include "defines.h"
-#include "geom_2d.h"
-#include "momentum.h"
-#include <stdio.h>
-#include <vector>
-#include <set>
-#include <memory>
-#include <string>
-
-namespace siscone{
-
-/**
- * \class Cjet
- * real Jet information.
- *
- * This class contains information for one single jet.
- * That is, first, its momentum carrying information
- * about its centre and pT, and second, its particle
- * contents
- */
-class Cjet{
- public:
- /// default ctor
- Cjet();
-
- /// default dtor
- ~Cjet();
-
- Cmomentum v; ///< jet momentum
- double pt_tilde; ///< p-scheme pt
- int n; ///< number of particles inside
- std::vector<int> contents; ///< particle contents (list of indices)
-
- /// ordering variable used for ordering and overlap in the
- /// split--merge. This variable is automatically set either to
- /// pt_tilde, or to mt or to pt, depending on the siscone
- /// parameter. Note that the default behaviour is pt_tilde and that
- /// other chices may lead to infrared unsafe situations.
- /// Note: we use the square of the varible rather than the variable itself
- double sm_var2;
-
- /// covered range in eta-phi
- Ceta_phi_range range;
-
- /// pass at which the jet has been found
- /// It starts at 0 (first pass), -1 means infinite rapidity
- int pass;
-};
-
-/// ordering of jets in pt (e.g. used in final jets ordering)
-bool jets_pt_less(const Cjet &j1, const Cjet &j2);
-
-
-/// the choices of scale variable that can be used in the split-merge
-/// step, both for ordering the protojets and for measuing their
-/// overlap; pt, Et and mt=sqrt(pt^2+m^2) are all defined in E-scheme
-/// (4-momentum) recombination; pttilde = \sum_{i\in jet} |p_{t,i}|
-///
-/// NB: if one changes the order here, one _MUST_ also change the order
-/// in the SISCone plugin
-enum Esplit_merge_scale {
- SM_pt, ///< transverse momentum (E-scheme), IR unsafe
- SM_Et, ///< transverse energy (E-scheme), not long. boost inv.
- ///< original run-II choice [may not be implemented]
- SM_mt, ///< transverse mass (E-scheme), IR safe except
- ///< in decays of two identical narrow heavy particles
- SM_pttilde ///< pt-scheme pt = \sum_{i in jet} |p_{ti}|, should
- ///< be IR safe in all cases
-};
-
-/// return the name of the split-merge scale choice
-std::string split_merge_scale_name(Esplit_merge_scale sms);
-
-/**
- * \class Csplit_merge_ptcomparison
- * comparison of jets for split--merge ordering
- *
- * a class that allows us to carry out comparisons of pt of jets, using
- * information from exact particle contents where necessary.
- */
-class Csplit_merge_ptcomparison{
-public:
- /// default ctor
- Csplit_merge_ptcomparison() :
- particles(0), split_merge_scale(SM_pttilde){};
-
- /// return the name corresponding to the SM scale variable
- std::string SM_scale_name() const {
- return split_merge_scale_name(split_merge_scale);}
-
- std::vector<Cmomentum> * particles; ///< pointer to the list of particles
- std::vector<double> * pt; ///< pointer to the pt of the particles
-
- /// comparison between 2 jets
- bool operator()(const Cjet &jet1, const Cjet &jet2) const;
-
- /**
- * get the difference between 2 jets, calculated such that rounding
- * errors will not affect the result even if the two jets have
- * almost the same content (so that the difference is below the
- * rounding errors)
- *
- * \param j1 first jet
- * \param j2 second jet
- * \param v jet1-jet2
- * \param pt_tilde jet1-jet2 pt_tilde
- */
- void get_difference(const Cjet &j1, const Cjet &j2, Cmomentum *v, double *pt_tilde) const;
-
- /// the following parameter controls the variable we're using for
- /// the split-merge process i.e. the variable we use for
- /// 1. ordering jet candidates;
- /// 2. computing te overlap fraction of two candidates.
- /// The default value uses pttile (p-scheme pt). Other alternatives are
- /// pt, mt=sqrt(pt^2+m^2)=sqrt(E^2-pz^2) or Et.
- /// NOTE: Modifying the default choice can have nasty effects:
- /// - using pt leads to some IR unsafety when we have two jets,
- /// e.g. back-to-back, with the same pt. In that case, their ordering
- /// in pt is random and can be affected by the addition of a
- /// soft particle. Hence, we highly recommand to keep this to
- /// the default value i.e. to use pt only for the purpose of
- /// investigating the IR issue
- /// - using Et is safe but do not respect boost invariance
- /// - using mt solves the IR unsafety issues with the pt variable
- /// for QCD jets but the IR unsafety remains for nack-to-back
- /// jets of unstable narrow-width particles (e.g. Higgs).
- /// Therefore, keeping the default value is strongly advised.
- Esplit_merge_scale split_merge_scale;
-};
-
-
-// iterator types
-/// iterator definition for the jet candidates structure
-typedef std::multiset<siscone::Cjet,Csplit_merge_ptcomparison>::iterator cjet_iterator;
-
-/// iterator definition for the jet structure
-typedef std::vector<siscone::Cjet>::iterator jet_iterator;
-
-
-
-/**
- * \class Csplit_merge
- * Class used to split and merge jets.
- */
-class Csplit_merge{
- public:
- /// default ctor
- Csplit_merge();
-
- /// default dtor
- ~Csplit_merge();
-
-
- //////////////////////////////
- // initialisation functions //
- //////////////////////////////
-
- /**
- * initialisation function
- * \param _particles list of particles
- * \param protocones list of protocones (initial jet candidates)
- * \param R2 cone radius (squared)
- * \param ptmin minimal pT allowed for jets
- * \return 0 on success, 1 on error
- */
- int init(std::vector<Cmomentum> &_particles, std::vector<Cmomentum> *protocones, double R2, double ptmin=0.0);
-
- /**
- * initialisation function for particle list
- * \param _particles list of particles
- * \return 0 on success, 1 on error
- */
- int init_particles(std::vector<Cmomentum> &_particles);
-
- /**
- * build initial list of left particles
- */
- int init_pleft();
-
- /**
- * use a pt-dependent boundary for splitting
- * When called with true, the criterium for splitting two protojets
- * will be to compare D1^2/kt1^2 vs. D2^2/kt2^2, the (anti-)kt-weighted
- * distance instead of the plain distance D1^2 vs. D2^2.
- * This can be set in order to produce more circular hard jets,
- * with the same underlying philosophy as for the anti-kt algorithm.
- * We thus expect a behaviour closer to the IterativeCone one.
- * By default, we use the standard D1^2 vs. D2^2 comparison and this
- * function is not called.
- */
- inline int set_pt_weighted_splitting(bool _use_pt_weighted_splitting){
- use_pt_weighted_splitting = _use_pt_weighted_splitting;
- return 0;
- }
-
- ////////////////////////
- // cleaning functions //
- ////////////////////////
-
- /// partial clearance
- int partial_clear();
-
- /// full clearance
- int full_clear();
-
-
- /////////////////////////////////
- // main parts of the algorithm //
- /////////////////////////////////
-
- /**
- * build the list 'p_uncol_hard' from p_remain by clustering
- * collinear particles and removing particles softer than
- * stable_cone_soft_pt2_cutoff
- * note that thins in only used for stable-cone detection
- * so the parent_index field is unnecessary
- */
- int merge_collinear_and_remove_soft();
-
- /**
- * add a list of protocones
- * \param protocones list of protocones (initial jet candidates)
- * \param R2 cone radius (squared)
- * \param ptmin minimal pT allowed for jets
- * \return 0 on success, 1 on error
- */
- int add_protocones(std::vector<Cmomentum> *protocones, double R2, double ptmin=0.0);
-
- /**
- * really do the splitting and merging
- * At the end, the vector jets is filled with the jets found.
- * the 'contents' field of each jets contains the indices
- * of the particles included in that jet.
- * \param overlap_tshold threshold for splitting/merging transition
- * \param ptmin minimal pT allowed for jets
- * \return the number of jets is returned
- */
- int perform(double overlap_tshold, double ptmin=0.0);
-
-
- //////////////////////////////
- // save and debug functions //
- //////////////////////////////
-
- /// save final jets
- /// \param flux stream to save the jet contentss
- int save_contents(FILE *flux);
-
- /// show jets/candidates status
- int show();
-
- // particle information
- int n; ///< number of particles
- std::vector<Cmomentum> particles; ///< list of particles
- std::vector<double> pt; ///< list of particles' pt
- int n_left; ///< numer of particles that does not belong to any jet
- std::vector<Cmomentum> p_remain; ///< list of particles remaining to deal with
- std::vector<Cmomentum> p_uncol_hard; ///< list of particles remaining with collinear clustering
- int n_pass; ///< index of the run
-
- /// minimal difference in squared distance between a particle and
- /// two overlapping protojets when doing a split (useful when
- /// testing approx. collinear safety)
- double most_ambiguous_split;
-
- // jets information
- std::vector<Cjet> jets; ///< list of jets
-
- // working entries
- int *indices; ///< maximal size array for indices works
- int idx_size; ///< number of elements in indices1
-
- /// The following flag indicates that identical protocones
- /// are to be merged automatically each time around the split-merge
- /// loop and before anything else happens.
- ///
- /// This flag is only effective if ALLOW_MERGE_IDENTICAL_PROTOCONES
- /// is set in 'defines.h'
- /// Note that this lead to infrared-unsafety so it is disabled
- /// by default
- bool merge_identical_protocones;
-
- /// member used for detailed comparisons of pt's
- Csplit_merge_ptcomparison ptcomparison;
-
- /// stop split--merge when the SM_var of the hardest protojet
- /// is below this cut-off.
- /// This is not collinear-safe so you should not use this
- /// variable unless you really know what you are doing
- /// Note that the cut-off is set on the variable squared.
- double SM_var2_hardest_cut_off;
-
- /// pt cutoff for the particles to put in p_uncol_hard
- /// this is meant to allow removing soft particles in the
- /// stable-cone search.
- double stable_cone_soft_pt2_cutoff;
-
- private:
- /**
- * get the overlap between 2 jets
- * \param j1 first jet
- * \param j2 second jet
- * \param v returned overlap^2 (determined by the choice of SM variable)
- * \return true if overlapping, false if disjoint
- */
- bool get_overlap(const Cjet &j1, const Cjet &j2, double *v);
-
-
- /**
- * split the two given jets.
- * during this procedure, the jets j1 & j2 are replaced
- * by 2 new jets. Common particles are associted to the
- * closest initial jet.
- * \param it_j1 iterator of the first jet in 'candidates'
- * \param it_j2 iterator of the second jet in 'candidates'
- * \param j1 first jet (Cjet instance)
- * \param j2 second jet (Cjet instance)
- * \return true on success, false on error
- */
- bool split(cjet_iterator &it_j1, cjet_iterator &it_j2);
-
- /**
- * merge the two given jet.
- * during this procedure, the jets j1 & j2 are replaced
- * by 1 single jets containing both of them.
- * \param it_j1 iterator of the first jet in 'candidates'
- * \param it_j2 iterator of the second jet in 'candidates'
- * \return true on success, false on error
- */
- bool merge(cjet_iterator &it_j1, cjet_iterator &it_j2);
-
- /**
- * Check whether or not a jet has to be inserted in the
- * list of protojets. If it has, set its sm_variable and
- * insert it to the list of protojets.
- * \param jet jet to insert
- */
- bool insert(Cjet &jet);
-
- /**
- * given a 4-momentum and its associated pT, return the
- * variable tht has to be used for SM
- * \param v 4 momentum of the protojet
- * \param pt_tilde pt_tilde of the protojet
- */
- double get_sm_var2(Cmomentum &v, double &pt_tilde);
-
- // jet information
- /// list of jet candidates
- std::auto_ptr<std::multiset<Cjet,Csplit_merge_ptcomparison> > candidates;
-
- /// minimal pt2
- double pt_min2;
-
- /**
- * do we have or not to use the pt-weighted splitting
- * (see description for set_pt_weighted_splitting)
- * This will be false by default
- */
- bool use_pt_weighted_splitting;
-
-#ifdef ALLOW_MERGE_IDENTICAL_PROTOCONES
- /// checkxor for the candidates (to avoid having twice the same contents)
- std::set<Creference> cand_refs;
-#endif
-};
-
-}
-
-
-#endif
+++ /dev/null
-// -*- C++ -*-
-///////////////////////////////////////////////////////////////////////////////
-// File: vicinity.h //
-// Description: header file for particle vicinity (Cvicinity class) //
-// This file is part of the SISCone project. //
-// For more details, see http://projects.hepforge.org/siscone //
-// //
-// Copyright (c) 2006 Gavin Salam and Gregory Soyez //
-// //
-// This program 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. //
-// //
-// This program 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 this program; if not, write to the Free Software //
-// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
-// //
-// $Revision:: 123 $//
-// $Date:: 2007-03-01 02:52:16 +0100 (Thu, 01 Mar 2007) $//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef __VICINITY_H__
-#define __VICINITY_H__
-
-#include <vector>
-#include <list>
-#include "momentum.h"
-#include "defines.h"
-#include "quadtree.h"
-
-namespace siscone{
-
-
-
-/**
- * \class Cvicinity_inclusion
- * \brief a class to keep track of inclusion status in cone and in cocircular region
- * while using minimal resources
- */
-class Cvicinity_inclusion {
-public:
- /// default ctor
- Cvicinity_inclusion() : cone(false), cocirc(false) {}
-
- bool cone; ///< flag for particle inclusion in the cone
- bool cocirc; ///< flag for particle inclusion in the border
-};
-
-
-/**
- * \class Cvicinity_elm
- * \brief element in the vicinity of a parent.
- *
- * class used to manage one points in the vicinity
- * of a parent point.
- */
-class Cvicinity_elm{
- public:
- /// pointer to the second borderline particle
- Cmomentum *v;
-
- /// variable to tell if the particle is inside or outside the cone
- Cvicinity_inclusion *is_inside;
-
- // centre variables
- double eta; ///< eta coordinate of the center
- double phi; ///< phi coordinate of the center
- double angle; ///< angle with parent
- bool side; ///< true if angle on the positive side, false otherwise
- double cocircular_range; ///< amount by which the angle can be varied while
- ///< maintaining this point within co-circularity margin
-
- /// list of elements co-circular with this one
- /// NB: empty list uses less mem than vector
- std::list<Cvicinity_elm * > cocircular;
-};
-
-/// ordering pointers to Cvicinity_elm
-bool ve_less(Cvicinity_elm *ve1, Cvicinity_elm *ve2);
-
-
-/**
- * \class Cvicinity
- * \brief list of element in the vicinity of a parent.
- *
- * class used to manage the points which are in the vicinity
- * of a parent point.
- */
-class Cvicinity{
- public:
- /// default constructor
- Cvicinity();
-
- /// constructor with initialisation (see set_particle_list)
- Cvicinity(std::vector<Cmomentum> &_particle_list);
-
- /// default destructor
- ~Cvicinity();
-
- /**
- * set the particle_list
- * \param _particle_list list of particles (type Cmomentum)
- */
- void set_particle_list(std::vector<Cmomentum> &_particle_list);
-
- /**
- * build the vicinity list from the list of points.
- * \param _parent reference particle
- * \param _VR vicinity radius
- */
- void build(Cmomentum *_parent, double _VR);
-
- // cone kinematical information
- Cmomentum *parent; ///< parent vector
- double VR; ///< radius of the vicinity
- double VR2; ///< squared radius of the vicinity
- double R; ///< normal radius
- double R2; ///< squared normal radius
- double inv_R_EPS_COCIRC; ///< R / EPSILON_COCIRCULAR
- double inv_R_2EPS_COCIRC; ///< R / (2*EPSILON_COCIRCULAR)
-
- // particle list information
- int n_part; ///< number of particles
- std::vector<Cmomentum> plist; ///< the list of particles
- std::vector<Cvicinity_inclusion> pincluded; ///< the inclusion state of particles
- Cvicinity_elm *ve_list; ///< list of vicinity elements built from particle list (size=2*n)
-#ifdef USE_QUADTREE_FOR_STABILITY_TEST
- Cquadtree *quadtree; ///< quadtree used for final stability tests
-#endif
-
- // vicinity information
- std::vector<Cvicinity_elm*> vicinity; ///< list of points in parent's vicinity
- unsigned int vicinity_size; ///< number of elements in vicinity
-
- protected:
- /**
- * append a particle to the 'vicinity' list after
- * having tested it and computed the angular-ordering quantities
- * \param v vector to test
- */
- void append_to_vicinity(Cmomentum *v);
-
- // internal variables
- double pcx; ///< parent centre (eta)
- double pcy; ///< parent centre (phi)
-};
-
-}
-
-#endif
AliPWG4HighPtQATPConly.cxx
AliPWG4HighPtSpectra.cxx
AliPWG4HighPtTrackQA.cxx
- UserTasks/AliAnalysisTaskCheckSingleTrackJetRejection.cxx
- UserTasks/AliAnalysisTaskJetHadronCorrelation.cxx
- UserTasks/AliAnalysisTaskJetHBOM.cxx
UserTasks/AliAnalysisTaskJetShape.cxx
UserTasks/AliAnalysisTaskJetsTriggerTRD.cxx
UserTasks/AliAnalysisTaskJetProtonCorr.cxx
UserTasks/AliIDFFUtils.cxx
)
+set(FASTJET_ROOT $ENV{FASTJET_ROOT})
+
+# Add code that needs fastjet or FJWrapper here
+if (FASTJET_ROOT)
+ LIST(APPEND SRCS
+ UserTasks/AliAnalysisTaskCheckSingleTrackJetRejection.cxx
+ UserTasks/AliAnalysisTaskJetHadronCorrelation.cxx
+ UserTasks/AliAnalysisTaskJetHBOM.cxx
+ )
+ set ( CINTFLAGS ${CINTFLAGS} -DHAVE_FASTJET)
+endif(FASTJET_ROOT)
+
string ( REPLACE ".cxx" ".h" HDRS "${SRCS}" )
set ( DHDR PWGJELinkDef.h)
string ( REPLACE ".cxx" ".h" EXPORT "${SRCS}" )
-set ( HDRS ${HDRS} EMCALJetTasks/FJ_includes.h )
-
-set(FASTJET_ROOT $ENV{FASTJET_ROOT})
-
if(FASTJET_ROOT)
set (FASTJET_INC ${FASTJET_ROOT}/include)
+ set ( EINCLUDE ${FASTJET_INC} ANALYSIS JETAN CORRFW PWGJE PWG/Tools PWGCF/Correlations/Base STEER/AOD STEER/ESD STEER/STEERBase)
+ set ( HDRS ${HDRS} EMCALJetTasks/FJ_includes.h )
else()
- set (FASTJET_INC JETAN/fastjet)
+ set ( EINCLUDE ANALYSIS JETAN CORRFW PWGJE PWG/Tools PWGCF/Correlations/Base STEER/AOD STEER/ESD STEER/STEERBase)
endif(FASTJET_ROOT)
-#set ( EDEFINE -isystem${FASTJET_INC})
-set ( EINCLUDE ${FASTJET_INC} ANALYSIS JETAN CORRFW PWGJE PWG/Tools PWGCF/Correlations/Base STEER/AOD STEER/ESD STEER/STEERBase)
-#set ( EINCLUDE ANALYSIS JETAN CORRFW PWGJE PWG/Tools PWGCF/Correlations/Base STEER/AOD STEER/ESD STEER/STEERBase)
install (DIRECTORY macros
DESTINATION PWGJE
#--------------------------------------------------------------------------------#
set ( SRCS
- EMCALJetTasks/AliFJWrapper.cxx
EMCALJetTasks/AliAnalysisTaskDeltaPt.cxx
EMCALJetTasks/AliAnalysisTaskEmcalJet.cxx
EMCALJetTasks/AliAnalysisTaskEmcalJetSample.cxx
EMCALJetTasks/AliAnalysisTaskLocalRho.cxx
EMCALJetTasks/AliAnalysisTaskScale.cxx
EMCALJetTasks/AliEmcalJet.cxx
- EMCALJetTasks/AliEmcalJetTask.cxx
EMCALJetTasks/AliJetConstituentTagCopier.cxx
EMCALJetTasks/AliJetContainer.cxx
- EMCALJetTasks/AliJetEmbeddingFromAODTask.cxx
EMCALJetTasks/AliJetEmbeddingFromGenTask.cxx
EMCALJetTasks/AliJetEmbeddingFromPYTHIATask.cxx
EMCALJetTasks/AliJetEmbeddingTask.cxx
EMCALJetTasks/AliJetResponseMaker.cxx
EMCALJetTasks/AliRhoParameter.cxx
EMCALJetTasks/AliLocalRhoParameter.cxx
- EMCALJetTasks/AliEmcalJetFinder.cxx
EMCALJetTasks/AliJetTriggerSelectionTask.cxx
EMCALJetTasks/UserTasks/AliAnalysisTaskCLQA.cxx
EMCALJetTasks/UserTasks/AliAnalysisTaskChargedJetsPA.cxx
EMCALJetTasks/UserTasks/AliAnalysisTaskEmcalJetTagger.cxx
EMCALJetTasks/UserTasks/AliAnalysisTaskEmcalJetTriggerQA.cxx
EMCALJetTasks/UserTasks/AliAnalysisTaskEmcalTriggerInfoQA.cxx
- EMCALJetTasks/UserTasks/AliAnalysisTaskFullpAJets.cxx
- EMCALJetTasks/UserTasks/AliAnalysisTaskFullppJet.cxx
EMCALJetTasks/UserTasks/AliAnalysisTaskHJetEmbed.cxx
- EMCALJetTasks/UserTasks/AliAnalysisTaskHJetDphi.cxx
EMCALJetTasks/UserTasks/AliAnalysisTaskRhoVnModulation.cxx
EMCALJetTasks/UserTasks/AliAnalysisTaskJetMatching.cxx
EMCALJetTasks/UserTasks/AliAnalysisTaskSAJF.cxx
EMCALJetTasks/UserTasks/AliAnalysisTaskSOH.cxx
)
+set ( FASTJET_ROOT $ENV{FASTJET_ROOT} ) # Can be done in CMakeList.txt?
+
+# Add code that needs fastjet or FJWrapper here
+if (FASTJET_ROOT)
+LIST(APPEND SRCS
+ EMCALJetTasks/AliFJWrapper.cxx
+ EMCALJetTasks/AliEmcalJetTask.cxx
+ EMCALJetTasks/AliEmcalJetFinder.cxx
+ EMCALJetTasks/AliJetEmbeddingFromAODTask.cxx
+ EMCALJetTasks/UserTasks/AliAnalysisTaskFullpAJets.cxx
+ EMCALJetTasks/UserTasks/AliAnalysisTaskFullppJet.cxx
+ EMCALJetTasks/UserTasks/AliAnalysisTaskHJetDphi.cxx
+)
+endif(FASTJET_ROOT)
+
set ( DHDR PWGJEEMCALJetTasksLinkDef.h)
string ( REPLACE ".cxx" ".h" EXPORT "${SRCS}" )
-set ( SRCS ${SRCS} EMCALJetTasks/AliFJWrapper.cxx )
-
string ( REPLACE ".cxx" ".h" HDRS "${SRCS}" )
-set ( HDRS ${HDRS} EMCALJetTasks/FJ_includes.h )
-
-set ( FASTJET_ROOT $ENV{FASTJET_ROOT} )
if(FASTJET_ROOT)
set (FASTJET_INC ${FASTJET_ROOT}/include)
+ set ( EDEFINE -isystem${FASTJET_INC})
+ set ( EINCLUDE ${FASTJET_INC} PWGJE/EMCALJetTasks PWG/EMCAL EMCAL OADB STEER/ESD STEER/STEERBase ANALYSIS)
+ set ( HDRS ${HDRS} EMCALJetTasks/FJ_includes.h )
else()
- set (FASTJET_INC ${ALICE_ROOT}/JETAN/fastjet)
+ set ( EINCLUDE PWGJE/EMCALJetTasks PWG/EMCAL EMCAL OADB STEER/ESD STEER/STEERBase ANALYSIS)
endif(FASTJET_ROOT)
-set ( EDEFINE -isystem${FASTJET_INC})
-set ( EINCLUDE ${FASTJET_INC} PWGJE/EMCALJetTasks PWG/EMCAL EMCAL OADB STEER/ESD STEER/STEERBase ANALYSIS)
#pragma link C++ class AliAnalysisTaskDeltaPt+;
#pragma link C++ class AliAnalysisTaskScale+;
#pragma link C++ class AliEmcalJet+;
-#pragma link C++ class AliEmcalJetTask+;
#pragma link C++ class AliJetContainer+;
#pragma link C++ class AliJetEmbeddingTask+;
#pragma link C++ class AliJetEmbeddingFromGenTask+;
-#pragma link C++ class AliJetEmbeddingFromAODTask+;
#pragma link C++ class AliJetEmbeddingFromPYTHIATask+;
#pragma link C++ class AliJetModelBaseTask+;
#pragma link C++ class AliJetModelMergeBranches+;
#pragma link C++ class AliJetResponseMaker+;
#pragma link C++ class AliRhoParameter+;
#pragma link C++ class AliLocalRhoParameter+;
-#pragma link C++ class AliEmcalJetFinder+;
#pragma link C++ class AliJetTriggerSelectionTask+;
// user tasks
#pragma link C++ class AliAnalysisTaskEmcalJetTagger+;
#pragma link C++ class AliAnalysisTaskEmcalJetTriggerQA+;
#pragma link C++ class AliAnalysisTaskEmcalTriggerInfoQA+;
-#pragma link C++ class AliAnalysisTaskFullpAJets+;
-#pragma link C++ class AliAnalysisTaskFullppJet;
#pragma link C++ class AliAnalysisTaskHJetEmbed+;
-#pragma link C++ class AliAnalysisTaskHJetDphi+;
#pragma link C++ class AliAnalysisTaskRhoVnModulation+;
#pragma link C++ class AliAnalysisTaskJetMatching+;
#pragma link C++ class AliAnalysisTaskSAJF+;
#pragma link C++ class AliAnalysisTaskSOH+;
#pragma link C++ class AliNtupCumInfo+;
#pragma link C++ class AliNtupZdcInfo+;
+
+#ifdef HAVE_FASTJET
+#pragma link C++ class AliEmcalJetTask+;
+#pragma link C++ class AliEmcalJetFinder+;
+#pragma link C++ class AliJetEmbeddingFromAODTask+;
+#pragma link C++ class AliAnalysisTaskFullpAJets+;
+#pragma link C++ class AliAnalysisTaskFullppJet;
+#pragma link C++ class AliAnalysisTaskHJetDphi+;
+#endif
#endif
#pragma link C++ class AliAnalysisTaskJetResponseV2+;
#pragma link C++ class AliAnalysisTaskPartonDisc+;
#pragma link C++ class AliAnaChargedJetResponseMaker+;
-#pragma link C++ class AliAnalysisTaskCheckSingleTrackJetRejection+;
-#pragma link C++ class AliAnalysisTaskJetHadronCorrelation+;
-#pragma link C++ class AliAnalysisTaskJetHBOM+;
#pragma link C++ class AliAnalysisTaskJetShape+;
#pragma link C++ class AliAnalysisTaskJetShape::AliAnalysisTaskJetShapeTool+;
#pragma link C++ class AliAnalysisTaskJetShape::AliAnalysisTaskJetShapeHM+;
#pragma link C++ class AliAnalysisTaskIDFFTCF::AliFragFuncQATrackHistos+;
#pragma link C++ class AliAnalysisTaskIDFFTCF::AliFragFuncQAJetHistos+;
#pragma link C++ class AliIDFFUtils+;
+
+#ifdef HAVE_FASTJET
+#pragma link C++ class AliAnalysisTaskCheckSingleTrackJetRejection+;
+#pragma link C++ class AliAnalysisTaskJetHadronCorrelation+;
+#pragma link C++ class AliAnalysisTaskJetHBOM+;
+#endif
#endif
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff