Selector.hh

#ifndef __SELECTOR_HH__
#define __SELECTOR_HH__

//STARTHEADER
// $Id: Selector.hh 1867 2011-01-26 17:53:32Z salam $
//
// Copyright (c) 2009-2010, Matteo Cacciari, Gavin Salam and Gregory Soyez
//
//----------------------------------------------------------------------
// This file is part of FastJet.
//
//  FastJet 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.
//
//  The algorithms that underlie FastJet have required considerable
//  development and are described in hep-ph/0512210. If you use
//  FastJet as part of work towards a scientific publication, please
//  include a citation to the FastJet paper.
//
//  FastJet 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 FastJet; if not, write to the Free Software
//  Foundation, Inc.:
//      59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//----------------------------------------------------------------------
//ENDHEADER

#include "fastjet/PseudoJet.hh"
#include "fastjet/GhostedAreaSpec.hh"  // for area support
#include <limits>
#include <cmath>

FASTJET_BEGIN_NAMESPACE      // defined in fastjet/internal/base.hh

//----------------------------------------------------------------------
class Selector;
//----------------------------------------------------------------------

class SelectorWorker {
public:
  //----------------------------------------------------------
  // fundamental info
  //----------------------------------------------------------
  virtual ~SelectorWorker() {}

  //----------------------------------------------------------
  // basic operations for checking what gets selected
  //----------------------------------------------------------

  virtual bool pass(const PseudoJet & jet) const = 0;

  virtual void terminator(std::vector<const PseudoJet *> & jets) const {
    for (unsigned i = 0; i < jets.size(); i++) {
      if (jets[i] && !pass(*jets[i])) jets[i] = NULL;
    }
  }

  virtual bool applies_jet_by_jet() const {return true;}

  virtual std::string description() const {return "missing description";}

  //----------------------------------------------------------
  // operations for relocation
  //----------------------------------------------------------

  virtual bool is_relocatable() const { return false;}

  virtual void relocate(const PseudoJet &centre){
    throw Error("relocate undefined for a non-relocatable selector worker");
  }

  virtual SelectorWorker* copy(){ 
    throw Error("this SelectorWorker has nothing to copy");
  }

  //----------------------------------------------------------
  // operations for area and extent
  //----------------------------------------------------------

  virtual void get_rapidity_extent(double & rapmin, double & rapmax) const {
    rapmax = std::numeric_limits<double>::max();
    rapmin = -rapmax; 
  }

  virtual bool has_area() const { return false;}

  virtual bool has_known_area() const { return false;}

  virtual double known_area() const{
    throw Error("this selector has no computable area");
  }



};

//----------------------------------------------------------------------
// class Selector
//
// Class that encodes information about cuts that 
class Selector{
public:
  Selector() {}

  Selector(SelectorWorker * worker) {_worker.reset(worker);}

  virtual ~Selector(){}

  bool pass(const PseudoJet & jet) const {
    if (!validated_worker()->applies_jet_by_jet()) {
      throw Error("Cannot apply this selector to an individual jet");
    }
    return _worker->pass(jet);
  }

  bool operator()(const PseudoJet & jet) const {
    return pass(jet);
  }

  bool applies_jet_by_jet() const {
    return validated_worker()->applies_jet_by_jet();
  }

  std::vector<PseudoJet> operator()(const std::vector<PseudoJet> & jets) const;

  void get_rapidity_extent(double &rapmin, double &rapmax) const {
    return validated_worker()->get_rapidity_extent(rapmin, rapmax);
  }

  std::string description() const {
    return validated_worker()->description();
  }

  bool has_area() const{
    return validated_worker()->has_area();
  }

  double area(double cell_area=gas::def_ghost_area) const;

  const SharedPtr<SelectorWorker> & worker() const {return _worker;}

  const SelectorWorker* validated_worker() const {
    const SelectorWorker* worker_ptr = _worker.get();
    if (worker_ptr == 0) throw InvalidWorker();
    return worker_ptr;
  }

  class InvalidWorker : public Error {
  public:
    InvalidWorker() : Error("Attempt to use Selector with no valid underlying worker") {}
  };

  class InvalidArea : public Error {
  public:
    InvalidArea() : Error("Attempt to obtain area from Selector for which this is not meaningful") {}
  };

  //----------------------------------------------------
  // non-const operations
  //----------------------------------------------------

protected:
  void _copy_worker_if_needed(){
    // do nothing if there's a sinlge user of the worker
    if (_worker.unique()) return;

    // call the worker's copy
    //std::cout << "will make a copy of " << description() << std::endl;
    _worker.reset(_worker->copy());
  }
public:

  bool is_relocatable() const {
    return validated_worker()->is_relocatable();
  }

  const Selector & relocate(const PseudoJet &centre){

    // if the worker is not relocatable, do nothing 
    if (! validated_worker()->is_relocatable()){
      return *this;
    }
    
    // since this is a non-const operation, make sure we have a
    // correct behaviour with respect to shared workers
    _copy_worker_if_needed();

    _worker->relocate(centre);
    return *this;
  }

private:
  SharedPtr<SelectorWorker> _worker; 
};


//----------------------------------------------------------------------
// a list of specific selectors
//----------------------------------------------------------------------


// logical operations
//----------------------------------------------------------------------

Selector operator!(const Selector & s);

Selector operator ||(const Selector & s1, const Selector & s2);


Selector operator&&(const Selector & s1, const Selector & s2);

Selector operator*(const Selector & s1, const Selector & s2);


// selection with kinematic cuts
//----------------------------------------------------------------------
Selector SelectorPtMin(double ptmin);                    
Selector SelectorPtMax(double ptmax);                    
Selector SelectorPtRange(double ptmin, double ptmax);    

Selector SelectorEtMin(double Etmin);                    
Selector SelectorEtMax(double Etmax);                    
Selector SelectorEtRange(double Etmin, double Etmax);    

Selector SelectorEMin(double Emin);                      
Selector SelectorEMax(double Emax);                      
Selector SelectorERange(double Emin, double Emax);       

Selector SelectorMMin(double Mmin);                      
Selector SelectorMMax(double Mmax);                      
Selector SelectorMRange(double Mmin, double Mmax);       

Selector SelectorRapMin(double rapmin);                  
Selector SelectorRapMax(double rapmax);                  
Selector SelectorRapRange(double rapmin, double rapmax); 

Selector SelectorAbsRapMin(double absrapmin);                     
Selector SelectorAbsRapMax(double absrapmax);                     
Selector SelectorAbsRapRange(double absrapmin, double absrapmax); 

Selector SelectorEtaMin(double etamin);                  
Selector SelectorEtaMax(double etamax);                  
Selector SelectorEtaRange(double etamin, double etamax); 

Selector SelectorAbsEtaMin(double absetamin);                     
Selector SelectorAbsEtaMax(double absetamax);                     
Selector SelectorAbsEtaRange(double absetamin, double absetamax); 

Selector SelectorPhiRange(double phimin, double phimax); 

Selector SelectorRapPhiRange(double rapmin, double rapmax, double phimin, double phimax);

Selector SelectorNHardest(unsigned int n); 


// selection with geometric objects
//----------------------------------------------------------------------

Selector SelectorCircle(const double & radius); 

Selector SelectorDoughnut(const double & radius_in, const double & radius_out); 

Selector SelectorStrip(const double & half_width);

Selector SelectorRectangle(const double & half_rap_width, const double & half_phi_width);


FASTJET_END_NAMESPACE      // defined in fastjet/internal/base.hh

#endif // __SELECTOR_HH__