fastjet_timing_plugins.cc

Go to the documentation of this file.

//STARTHEADER
// $Id: fastjet_timing.cc 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


//----------------------------------------------------------------------
#include "fastjet/PseudoJet.hh"
#include "fastjet/ClusterSequence.hh"
#include<iostream>
#include<sstream>
#include<fstream>
#include<valarray>
#include<vector>
#include <cstdlib>
#include<cstddef> // for size_t
#include "CmdLine.hh"

// get info on how fastjet was configured
#include "fastjet/config.h"

#ifdef ENABLE_PLUGIN_SISCONE
#include "fastjet/SISConePlugin.hh"
#endif
#ifdef ENABLE_PLUGIN_CDFCONES
#include "fastjet/CDFMidPointPlugin.hh"
#include "fastjet/CDFJetCluPlugin.hh"
#endif
#ifdef ENABLE_PLUGIN_PXCONE
#include "fastjet/PxConePlugin.hh"
#endif

using namespace std;

// to avoid excessive typing, define an abbreviation for the 
// fastjet namespace
namespace fj = fastjet;

inline double pow2(const double x) {return x*x;}

int main (int argc, char ** argv) {

  CmdLine cmdline(argc,argv);
  // allow the use to specify the fj::Strategy either through the
  // -clever or the -strategy options (both will take numerical
  // values); the latter will override the former.
  fj::Strategy  strategy  = fj::Strategy(cmdline.int_val("-strategy",
                                        cmdline.int_val("-clever", fj::Best)));
  int  repeat  = cmdline.int_val("-repeat",1);
  int  combine = cmdline.int_val("-combine",1);
  bool write   = cmdline.present("-write");
  bool unique_write = cmdline.present("-unique_write");
  bool hydjet  = cmdline.present("-hydjet");
  double ktR   = cmdline.double_val("-r",1.0);
  ktR   = cmdline.double_val("-R",ktR); // allow -r and -R
  double inclkt = cmdline.double_val("-incl",-1.0);
  int    excln  = cmdline.int_val   ("-excln",-1);
  double excld  = cmdline.double_val("-excld",-1.0);
  double etamax = cmdline.double_val("-etamax",1.0e305);
  bool   show_constituents = cmdline.present("-const");
  bool   massless = cmdline.present("-massless");
  int  nev     = cmdline.int_val("-nev",1);
  bool add_dense_coverage = cmdline.present("-dense");

  bool show_cones = cmdline.present("-cones"); // only works for siscone

  // for cone algorithms
  // allow -f and -overlap
  double overlap_threshold = cmdline.double_val("-overlap",0.5);
  overlap_threshold = cmdline.double_val("-f",overlap_threshold); 
  double seed_threshold = cmdline.double_val("-seed",1.0);

  // for printing jets to a file for reading by root
  string rootfile = cmdline.value<string>("-root","");

  // The following option causes the Cambridge algo to be used.
  // Note that currently the only output that works sensibly here is
  // "-incl 0"
  fj::JetDefinition jet_def;
  if (cmdline.present("-cam")) {
    jet_def = fj::JetDefinition(fj::cambridge_algorithm, ktR, strategy);
  } else if (cmdline.present("-antikt")) {
    jet_def = fj::JetDefinition(fj::antikt_algorithm, ktR, strategy);
  } else if (cmdline.present("-midpoint")) {
#ifdef ENABLE_PLUGIN_CDFCONES
    typedef fj::CDFMidPointPlugin MPPlug; // for brevity
    double cone_area_fraction = 1.0;
    int    max_pair_size = 2;
    int    max_iterations = 100;
    MPPlug::SplitMergeScale sm_scale = MPPlug::SM_pt;
    if (cmdline.present("-sm-pttilde")) sm_scale = MPPlug::SM_pttilde;
    if (cmdline.present("-sm-pt")) sm_scale = MPPlug::SM_pt; // default
    if (cmdline.present("-sm-mt")) sm_scale = MPPlug::SM_mt;
    if (cmdline.present("-sm-Et")) sm_scale = MPPlug::SM_Et;
    jet_def = fj::JetDefinition( new fj::CDFMidPointPlugin (
                                      seed_threshold, ktR, 
                                      cone_area_fraction, max_pair_size,
                                      max_iterations, overlap_threshold,
                                      sm_scale));
#else  // ENABLE_PLUGIN_CDFCONES
    cerr << "midpoint requested, but not available for this compilation" << endl;
#endif // ENABLE_PLUGIN_CDFCONES
  } else if (cmdline.present("-pxcone")) {
#ifdef ENABLE_PLUGIN_PXCONE
    double min_jet_energy = 5.0;
    jet_def = fj::JetDefinition( new fj::PxConePlugin (
                                      ktR, min_jet_energy,
                                      overlap_threshold));
#else  // ENABLE_PLUGIN_PXCONE
    cerr << "pxcone requested, but not available for this compilation" << endl;
    exit(-1);
#endif // ENABLE_PLUGIN_PXCONE
  } else if (cmdline.present("-jetclu")) {
#ifdef ENABLE_PLUGIN_CDFCONES
    jet_def = fj::JetDefinition( new fj::CDFJetCluPlugin (
                                      ktR, overlap_threshold, seed_threshold));
#else  // ENABLE_PLUGIN_CDFCONES
    cerr << "jetclu requested, but not available for this compilation" << endl;
#endif // ENABLE_PLUGIN_CDFCONES
  } else if (cmdline.present("-siscone")) {
#ifdef ENABLE_PLUGIN_SISCONE
    typedef fj::SISConePlugin SISPlug; // for brevity
    int npass = cmdline.value("-npass",0);
    double sisptmin = cmdline.value("-sisptmin",0.0);
    SISPlug * plugin = new SISPlug (ktR, overlap_threshold,npass,sisptmin);
    if (cmdline.present("-sm-pt")) plugin->set_split_merge_scale(SISPlug::SM_pt);
    if (cmdline.present("-sm-mt")) plugin->set_split_merge_scale(SISPlug::SM_mt);
    if (cmdline.present("-sm-Et")) plugin->set_split_merge_scale(SISPlug::SM_Et);
    if (cmdline.present("-sm-pttilde")) plugin->set_split_merge_scale(SISPlug::SM_pttilde);
    jet_def = fj::JetDefinition(plugin);
#else  // ENABLE_PLUGIN_SISCONE
    cerr << "jetclu requested, but not available for this compilation" << endl;
#endif // ENABLE_PLUGIN_SISCONE
  } else {
    jet_def = fj::JetDefinition(fj::kt_algorithm, ktR, strategy);
  }



  if (!cmdline.all_options_used()) {cerr << 
      "Error: some options were not recognized"<<endl; 
    exit(-1);}


  for (int iev = 0; iev < nev; iev++) {
  vector<fj::PseudoJet> jets;
  string line;
  int  ndone = 0;
  while (getline(cin, line)) {
      //cout << line<<endl;
    istringstream linestream(line);
    if (line == "#END") {
      ndone += 1;
      if (ndone == combine) {break;}
    }
    if (line.substr(0,1) == "#") {continue;}
    valarray<double> fourvec(4);
    if (hydjet) {
      // special reading from hydjet.txt event record (though actually
      // this is supposed to be a standard pythia event record, so
      // being able to read from it is perhaps not so bad an idea...)
      int ii, istat,id,m1,m2,d1,d2;
      double mass;
      linestream >> ii>> istat >> id >> m1 >> m2 >> d1 >> d2
                 >> fourvec[0] >> fourvec[1] >> fourvec[2] >> mass;
      // current file contains mass of particle as 4th entry
      if (istat == 1) {
        fourvec[3] = sqrt(+pow2(fourvec[0])+pow2(fourvec[1])
                          +pow2(fourvec[2])+pow2(mass));
      }
    } else {
      if (massless) {
        linestream >> fourvec[0] >> fourvec[1] >> fourvec[2];
        fourvec[3] = sqrt(pow2(fourvec[0])+pow2(fourvec[1])+pow2(fourvec[2]));}
      else {
        linestream >> fourvec[0] >> fourvec[1] >> fourvec[2] >> fourvec[3];
      }
    }
    fj::PseudoJet psjet(fourvec);
    if (abs(psjet.rap() < etamax)) {jets.push_back(psjet);}
  }

  // add a fake underlying event which is very soft, uniformly distributed
  // in eta,phi so as to allow one to reconstruct the area that is associated
  // with each jet.
  if (add_dense_coverage) {
    srand(2);
    int nphi = 60;
    int neta = 100;
    double kt = 1e-1;
    for (int iphi = 0; iphi<nphi; iphi++) {
      for (int ieta = -neta; ieta<neta+1; ieta++) {
        double phi = (iphi+0.5) * (fj::twopi/nphi) + rand()*0.001/RAND_MAX;
        double eta = ieta * (10.0/neta)  + rand()*0.001/RAND_MAX;
        kt = 0.0000001*(1+rand()*0.1/RAND_MAX);
        double pminus = kt*exp(-eta);
        double pplus  = kt*exp(+eta);
        double px = kt*sin(phi);
        double py = kt*cos(phi);
        //cout << kt<<" "<<eta<<" "<<phi<<"\n";
        fj::PseudoJet mom(px,py,0.5*(pplus-pminus),0.5*(pplus+pminus));
        jets.push_back(mom);
      }
    }
  }
  
  for (int irepeat = 0; irepeat < repeat ; irepeat++) {
    fj::ClusterSequence clust_seq(jets,jet_def,write);
    if (irepeat != 0) {continue;}
    cout << "iev "<<iev<< ": number of particles = "<< jets.size() << endl;
    cout << "strategy used =  "<< clust_seq.strategy_string()<< endl;
    cout << "Algorithm: " << jet_def.description() << " (" << fj::fastjet_version_string() << ")" << endl;

    // now provide some nice output...
    if (inclkt >= 0.0) {
      vector<fj::PseudoJet> jets = sorted_by_pt(clust_seq.inclusive_jets(inclkt));
      for (size_t j = 0; j < jets.size(); j++) {
        //printf("%5u %15.8f %15.8f %15.8e\n",j,jets[j].rap(),jets[j].phi(),sqrt(jets[j].kt2()));
        printf("%5u %15.8f %15.8f %15.8f\n",j,jets[j].rap(),jets[j].phi(),sqrt(jets[j].kt2()));
        if (show_constituents) {
          vector<fj::PseudoJet> const_jets = clust_seq.constituents(jets[j]);
          for (size_t k = 0; k < const_jets.size(); k++) {
            printf("        jet%03u %15.8f %15.8f %15.8f\n",j,const_jets[k].rap(),
                   const_jets[k].phi(),sqrt(const_jets[k].kt2()));
          }
          cout << "\n\n";
        }
        // family tests
        //fj::PseudoJet parent1, parent2;
        //bool has_parents = clust_seq.has_parents(jets[j],parent1,parent2);
        //if (has_parents) {
        //  cout << "parent pt's: " << parent1.perp() << " " << parent2.perp() <<endl;
        //  fj::PseudoJet child_from1, child_from2;
        //  clust_seq.has_child(parent1, child_from1);
        //  clust_seq.has_child(parent2, child_from2);
        //  cout << "parents' children pt: " << child_from1.perp() << " " << child_from2.perp() << endl;
        //  fj::PseudoJet partner_from1, partner_from2;
        //  clust_seq.has_partner(parent1, partner_from1);
        //  clust_seq.has_partner(parent2, partner_from2);
        //  cout << "parents' partners' pt: " << partner_from1.perp() << " " << partner_from2.perp() << endl;
        //} else {
        //  cout << "has no parents" << endl;
        //}
      }
      if (rootfile != "") {
        ofstream ostr(rootfile.c_str());
        clust_seq.print_jets_for_root(jets,ostr);
      }

    }

    if (excln > 0) {
      vector<fj::PseudoJet> jets = sorted_by_E(clust_seq.exclusive_jets(excln));
 
      cout << "Printing "<<excln<<" exclusive jets\n";
      for (size_t j = 0; j < jets.size(); j++) {
        printf("%5u %15.8f %15.8f %15.8f\n",
               //j,jets[j].rap(),jets[j].phi(),sqrt(jets[j].kt2()));
               j,jets[j].rap(),jets[j].phi(),jets[j].kt2());
      }
    }

    if (excld > 0.0) {
      vector<fj::PseudoJet> jets = sorted_by_pt(clust_seq.exclusive_jets(excld));
      cout << "Printing exclusive jets for d = "<<excld<<"\n";
      for (size_t j = 0; j < jets.size(); j++) {
        printf("%5u %15.8f %15.8f %15.8f\n",
               j,jets[j].rap(),jets[j].phi(),sqrt(jets[j].kt2()));
      }
    }

    
    // useful for testing that recombination sequences are unique
    if (unique_write) {
      vector<int> unique_history = clust_seq.unique_history_order();
      // construct the inverse of the above mapping
      vector<int> inv_unique_history(clust_seq.history().size());
      for (unsigned int i = 0; i < unique_history.size(); i++) {
        inv_unique_history[unique_history[i]] = i;}

      for (unsigned int i = 0; i < unique_history.size(); i++) {
        fj::ClusterSequence::history_element el = 
          clust_seq.history()[unique_history[i]];
        int uhp1 = el.parent1>=0 ? inv_unique_history[el.parent1] : el.parent1;
        int uhp2 = el.parent2>=0 ? inv_unique_history[el.parent2] : el.parent2;
        printf("%7d u %15.8e %7d u %7d u\n",i,el.dij,uhp1, uhp2);
      }
    }


    // provide some complementary information for SISCone 
    if (show_cones) {
      const fj::SISConeExtras * extras = 
        dynamic_cast<const fj::SISConeExtras *>(clust_seq.extras());
      cout << "most ambiguous split (difference in squared dist) = "
           << extras->most_ambiguous_split() << endl;
      vector<fastjet::PseudoJet> stable_cones(extras->stable_cones()); 
      stable_cones = sorted_by_rapidity(stable_cones);
      for (unsigned int i = 0; i < stable_cones.size(); i++) {
      //if (stable_cones[i].phi() < 5.0 && stable_cones[i].phi() > 4.0) {
        printf("%5u %15.8f %15.8f %15.8f\n",
               i,stable_cones[i].rap(),stable_cones[i].phi(),
               stable_cones[i].perp() );
      //}
      }
    }
  } // irepeat

  } // iev
}

---