split_merge.h

// -*- 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::                                                              $//
// $Date::                                                                  $//
 
#ifndef __SPLIT_MERGE_H__
#define __SPLIT_MERGE_H__
 
#include <siscone/config.h>
#include "defines.h"
#include "geom_2d.h"
#include "momentum.h"
#include <stdio.h>
#include <vector>
#include <set>
#include <memory>
#include <string>
 
namespace siscone{
 
const int CJET_INEXISTENT_PASS = -2;
 
class Cjet{
 public:
  Cjet();
 
  ~Cjet();
 
  Cmomentum v;               
  double pt_tilde;           
  int n;                     
  std::vector<int> contents; 
 
  double sm_var2;
 
  Ceta_phi_range range;
 
  int pass;
};
 
bool jets_pt_less(const Cjet &j1, const Cjet &j2);
  
 
enum Esplit_merge_scale {
           SM_pt,     
           SM_Et,     
           SM_mt,     
           SM_pttilde 
};
 
std::string split_merge_scale_name(Esplit_merge_scale sms);
 
class Csplit_merge_ptcomparison{
public:
  Csplit_merge_ptcomparison() : 
    particles(0), split_merge_scale(SM_pttilde){};
 
  std::string SM_scale_name() const {
    return split_merge_scale_name(split_merge_scale);}
 
  std::vector<Cmomentum> * particles; 
  std::vector<double> * pt;           
 
  bool operator()(const Cjet &jet1, const Cjet &jet2) const;
 
  void get_difference(const Cjet &j1, const Cjet &j2, Cmomentum *v, double *pt_tilde) const;
 
  Esplit_merge_scale split_merge_scale;
};
 
 
// iterator types
typedef std::multiset<siscone::Cjet,Csplit_merge_ptcomparison>::iterator cjet_iterator;
 
typedef std::vector<siscone::Cjet>::iterator jet_iterator;
 
 
 
class Csplit_merge{
 public:
  Csplit_merge();
 
  ~Csplit_merge();
 
 
  // initialisation functions //
 
  int init(std::vector<Cmomentum> &_particles, std::vector<Cmomentum> *protocones, double R2, double ptmin=0.0);
 
  int init_particles(std::vector<Cmomentum> &_particles);
 
  int init_pleft();
 
  inline int set_pt_weighted_splitting(bool _use_pt_weighted_splitting){
    use_pt_weighted_splitting = _use_pt_weighted_splitting;
    return 0;
  }
 
  // cleaning functions //
 
  int partial_clear();
 
  int full_clear();
 
  // user-defined stable-cone ordering //
 
  class Cuser_scale_base{
  public:
    virtual ~Cuser_scale_base(){}
 
    virtual double operator()(const Cjet & jet) const = 0;
 
    virtual bool is_larger(const Cjet & a, const Cjet & b) const{
      return (a.sm_var2 > b.sm_var2);
    }
  };
 
  void set_user_scale(const Cuser_scale_base * user_scale_in){
    _user_scale = user_scale_in;
  }
 
  const Cuser_scale_base * user_scale() const { return _user_scale; }
 
 
  // main parts of the algorithm //
 
  int merge_collinear_and_remove_soft();
 
  int add_protocones(std::vector<Cmomentum> *protocones, double R2, double ptmin=0.0);
 
  int add_hardest_protocone_to_jets(std::vector<Cmomentum> *protocones, double R2, double ptmin=0.0);
 
  int perform(double overlap_tshold, double ptmin=0.0);
 
 
  // save and debug functions //
 
  int save_contents(FILE *flux);
 
  int show();
 
  // particle information
  int n;                               
  std::vector<Cmomentum> particles;    
  std::vector<double> pt;              
  int n_left;                          
  std::vector<Cmomentum> p_remain;     
  std::vector<Cmomentum> p_uncol_hard; 
  int n_pass;                          
 
  double most_ambiguous_split; 
 
  // jets information
  std::vector<Cjet> jets;            
 
  // working entries
  int *indices;                      
  int idx_size;                      
 
  bool merge_identical_protocones;
 
  Csplit_merge_ptcomparison ptcomparison;
 
  double SM_var2_hardest_cut_off;
 
  double stable_cone_soft_pt2_cutoff;
 
 private:
  bool get_overlap(const Cjet &j1, const Cjet &j2, double *v);
 
 
  bool split(cjet_iterator &it_j1, cjet_iterator &it_j2);
 
  bool merge(cjet_iterator &it_j1, cjet_iterator &it_j2);
 
  bool insert(Cjet &jet);
 
  double get_sm_var2(Cmomentum &v, double &pt_tilde);
 
  // jet information
#ifdef SISCONE_USES_UNIQUE_PTR_AS_AUTO_PTR
  std::unique_ptr<std::multiset<Cjet,Csplit_merge_ptcomparison> > candidates;
#else
  std::auto_ptr<std::multiset<Cjet,Csplit_merge_ptcomparison> > candidates;
#endif
  
  double pt_min2;
 
  bool use_pt_weighted_splitting;
 
  const Cuser_scale_base *_user_scale;
 
#ifdef ALLOW_MERGE_IDENTICAL_PROTOCONES
  std::set<Creference> cand_refs;
#endif
};
 
}
 
 
#endif