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.                                 //
// 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::                                                              $//
// $Date::                                                                  $//
 
#ifndef __SPH_SPLIT_MERGE_H__
#define __SPH_SPLIT_MERGE_H__
 
#include <siscone/defines.h>
#include <siscone/config.h>
#include "geom_2d.h"
#include "momentum.h"
#include <stdio.h>
#include <vector>
#include <set>
#include <memory>
#include <string>
 
namespace siscone_spherical{
 
const int CJET_INEXISTENT_PASS = -2;
 
class CSphjet{
 public:
  CSphjet();
 
  ~CSphjet();
 
  CSphmomentum v;            
  double E_tilde;            
  int n;                     
  std::vector<int> contents; 
 
  double sm_var2;
 
  CSphtheta_phi_range range;
 
  int pass;
};
 
  
bool jets_E_less(const CSphjet &j1, const CSphjet &j2);
  
 
enum Esplit_merge_scale {
  SM_E,        
  SM_Etilde    
};
 
std::string split_merge_scale_name(Esplit_merge_scale sms);
 
class CSphsplit_merge_ptcomparison{
public:
  CSphsplit_merge_ptcomparison() : 
    particles(0), split_merge_scale(SM_Etilde){};
 
  std::string SM_scale_name() const {
    return split_merge_scale_name(split_merge_scale);}
 
  std::vector<CSphmomentum> * particles;  
  std::vector<double> * particles_norm2;  
 
  bool operator()(const CSphjet &jet1, const CSphjet &jet2) const;
 
  void get_difference(const CSphjet &j1, const CSphjet &j2, CSphmomentum *v, double *E_tilde) const;
 
  Esplit_merge_scale split_merge_scale;
};
 
 
// iterator types
typedef std::multiset<siscone_spherical::CSphjet,CSphsplit_merge_ptcomparison>::iterator cjet_iterator;
 
typedef std::vector<siscone_spherical::CSphjet>::iterator jet_iterator;
 
 
 
class CSphsplit_merge{
 public:
  CSphsplit_merge();
 
  ~CSphsplit_merge();
 
 
  // initialisation functions //
 
  int init(std::vector<CSphmomentum> &_particles, std::vector<CSphmomentum> *protocones, double R2, double Emin=0.0);
 
  int init_particles(std::vector<CSphmomentum> &_particles);
 
  int init_pleft();
 
  inline int set_E_weighted_splitting(bool _use_E_weighted_splitting){
    use_E_weighted_splitting = _use_E_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 CSphjet & jet) const = 0;
 
    virtual bool is_larger(const CSphjet & a, const CSphjet & 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<CSphmomentum> *protocones, double R2, double Emin=0.0);
 
  int add_hardest_protocone_to_jets(std::vector<CSphmomentum> *protocones, double R2, double Emin=0.0);
 
  int perform(double overlap_tshold, double Emin=0.0);
 
 
  // save and debug functions //
 
  int save_contents(FILE *flux);
 
  int show();
 
  // particle information
  int n;                                  
  std::vector<CSphmomentum> particles;    
  std::vector<double> particles_norm2;    
  int n_left;                             
  std::vector<CSphmomentum> p_remain;     
  std::vector<CSphmomentum> p_uncol_hard; 
  int n_pass;                             
 
  double most_ambiguous_split; 
 
  // jets information
  std::vector<CSphjet> jets;            
 
  // working entries
  int *indices;                      
  int idx_size;                      
 
  bool merge_identical_protocones;
 
  CSphsplit_merge_ptcomparison ptcomparison;
 
  double SM_var2_hardest_cut_off;
 
  double stable_cone_soft_E2_cutoff;
 
 private:
  bool get_overlap(const CSphjet &j1, const CSphjet &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(CSphjet &jet);
 
  double get_sm_var2(CSphmomentum &v, double &E_tilde);
 
  void compute_Etilde(CSphjet &j);
 
  // jet information
#ifdef SISCONE_USES_UNIQUE_PTR_AS_AUTO_PTR
  std::unique_ptr<std::multiset<CSphjet,CSphsplit_merge_ptcomparison> > candidates;
#else
  std::auto_ptr<std::multiset<CSphjet,CSphsplit_merge_ptcomparison> > candidates;
#endif
 
  double E_min;
 
  bool use_E_weighted_splitting;
 
  const Cuser_scale_base *_user_scale;
 
#ifdef ALLOW_MERGE_IDENTICAL_PROTOCONES
  std::set<siscone::Creference> cand_refs;
#endif
};
 
}
 
 
#endif