siscone/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:: 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{
 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();


  // 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 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
  std::auto_ptr<std::multiset<Cjet,Csplit_merge_ptcomparison> > candidates;

  double pt_min2;

  bool use_pt_weighted_splitting;

#ifdef ALLOW_MERGE_IDENTICAL_PROTOCONES

  std::set<Creference> cand_refs;
#endif
};

}


#endif