protocones.h

// -*- C++ -*-
// File: protocones.h                                                        //
// Description: header file for stable cones determination (Cstable_cones)   //
// 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_PROTOCONES_H__
#define __SPH_PROTOCONES_H__
 
#include "momentum.h"
#include "vicinity.h"
#include <stdio.h>
#include <vector>
#include <list>
#include "hash.h"
 
#include <siscone/defines.h>
 
namespace siscone_spherical{
 
class CSphborder_store{
public:
  CSphborder_store(CSphmomentum * momentum, CSph3vector &centre, CSph3vector &angl_dir1, CSph3vector &angl_dir2) : 
    mom(momentum),  is_in(false) {
    CSph3vector diff = (*momentum) - centre;
    angle = atan2(dot_product3(diff, angl_dir2), dot_product3(diff, angl_dir1));
#ifdef DEBUG_STABLE_CONES
    std::cout << "  adding point " << momentum->_theta << ", " << momentum->_phi
              << " at an angle of " << angle << std::endl;
#endif
  }
 
  CSphmomentum * mom;  
  double angle;     
  bool   is_in;     
};
 
 
inline bool operator<(const CSphborder_store & a, const CSphborder_store & b) {
  return a.angle < b.angle;
}
 
 
class CSphstable_cones : public CSphvicinity{
 public:
  CSphstable_cones();
 
  CSphstable_cones(std::vector<CSphmomentum> &_particle_list);
 
  ~CSphstable_cones();
 
  void init(std::vector<CSphmomentum> &_particle_list);
 
  int get_stable_cones(double _radius);
 
  std::vector<CSphmomentum> protocones;
 
  sph_hash_cones *hc;
 
  int nb_tot;
#ifdef DEBUG_STABLE_CONES
  int nb_hash_cones, nb_hash_occupied;
#endif
 
 protected:
  double R;
 
  double R2;
 
  double tan2R;
 
 private:
  CSphmomentum cone;
 
  CSphmomentum *child;
 
  CSphvicinity_elm *centre;
 
  unsigned int centre_idx;
 
  unsigned int first_cone;
 
  int init_cone();
 
  int test_cone();
 
  int update_cone();
 
  /*
   * run through the vicinity of the current parent and for each child
   * indicate which members are cocircular...
   */
  void prepare_cocircular_lists();
 
  bool cocircular_check();
 
  void test_cone_cocircular(CSphmomentum & borderless_cone, 
                            std::list<CSphmomentum *> & border_list);
 
  void test_stability(CSphmomentum & candidate, 
                      const std::vector<CSphborder_store> & border_vect);
 
  void compute_cone_contents();
 
  void recompute_cone_contents();
 
  /*
   * if we have gone beyond the acceptable threshold of change, compute
   * the cone momentum from particle list.  in this version, we use the
   * 'pincluded' information from the CSphvicinity class, but we don't
   * change the member cone, only the locally supplied one
   */
  void recompute_cone_contents_if_needed(CSphmomentum & this_cone, double & this_dpt);
 
  int proceed_with_stability();
 
  /*
   * circle intersection.
   * computes the intersection with a circle of given centre and radius.
   * The output takes the form of a checkxor of the intersection's particles
   *  - cx    circle centre x coordinate
   *  - cy    circle centre y coordinate
   * return the checkxor for the intersection
   ******************************************************************/
  siscone::Creference circle_intersect(CSph3vector &cone_centre);
 
  CSphmomentum cone_candidate;
 
  std::vector<CSphmomentum*> child_list;
 
  std::vector< std::pair<siscone::Creference,siscone::Creference> > multiple_centre_done;
 
  // information for updating cone contents to avoid rounding errors
  double dpt;          
};
 
}
#endif