siscone/spherical/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:: 309                                                          $//
// $Date:: 2011-08-09 12:33:15 +0200 (Tue, 09 Aug 2011)                     $//

#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{
 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();


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

  double E_min;

  bool use_E_weighted_splitting;

#ifdef ALLOW_MERGE_IDENTICAL_PROTOCONES

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

}


#endif