---

ClusterMaker.h

Go to the documentation of this file.

// ================================================
// ClusterMaker class description
// ================================================
//
// THIS TEXT TO BE REPLACED BY ATLAS STANDARD FORMAT
//
//
// Namespace Atlfast::
//
// class: ClusterMaker
//
// Authors: P.Clarke, H.Phillips, E.Richter-Was, P.Sherwood, R.Steward
//          (P.Clarke was principle author of this class)
//
// Description: 
//
//  Algorithm which makes Clusters from Cells
//
//  Note that the definition of cluster inherited from ATLFAST++
//  is really jet finding, in that it summs up enery in Cells
//  in a cone of a given radius.
//
//
// This version of ClusterMaker implements the following strategy:
//
// This is meant to be the NON ENERGY SHARING strategy coded in ATLFAST++
// If this is wrong it is due to mis-interpretaion of ATLFAST++ code by 
// the Author.
//
//  1. Read in all calorimeter Cells (pointers) from the TES
//
//  =============>
//  2. Start iteration over available cells
//
//    2.1 Take the (next) highest eT() Cell as initiator
//
//    2.2 If ( initiator.eT() < threshold ) strategy terminates immediately
//
//    2.3 If ( initiator.eT() > threshold )
//
//        2.3.1 Add up initiator and all cells within a given cone (eg 0.4) 
//              of initiator ( an eT() weighted eta() and phi() are formed )
//
//        2.3.2 If( (sum of cells).eT() > threshold )
//
//            2.3.2.1  Make a new Cluster 
//
//            2.3.2.2  Remove all cells used (including initiator)
//                     from the list of available cells
//
//  <============ continue iteration
//
//        2.3.3 If ( (sum of cells).eT() < threshold )
//
//            2.3.3.1 Mark initiator so that it is not considered again
//                    as an initiator (but it may still be included in a 
//                    cone sum)
//
//                    Return all cells in cone to the available cells.
//
//  <============ continue iteration
//           
//
//
// ................................................................
//


#ifndef ATLFAST_CLUSTERMAKER_H
#define ATLFAST_CLUSTERMAKER_H

// STL
#include <string>
#include <vector>

// Gaudi 
#include "GaudiKernel/Algorithm.h"

// Other
#include "CLHEP/Vector/LorentzVector.h"

// Atlfast
#include "AtlfastCode/CellCollection.h"
#include "AtlfastCode/ClusterCollection.h"

#include "AtlfastCode/KinematicHelper.h"

class ISvcLocator;
class MsgStream;

//*************************************
//Default parameters for this algorithm
// (descriptions in class declaration)
//*************************************
#define DEFAULT_minInitiatorET  1.5   
//Cones set to 0.401 to avoid calorimeter grid problems
#define DEFAULT_rConeBarrel     0.401   
#define DEFAULT_rConeForward    0.401  
#define DEFAULT_minClusterET    5. 
#define DEFAULT_inputLocation        "/Event/AtlfastCells" 
#define DEFAULT_outputLocation       "/Event/AtlfastClusters" 
#define DEFAULT_unusedCellLocation   "/Event/AtlfastUnusedCells" 
#define DEFAULT_Strategy             "Cone" 
#define DEFAULT_masslessJets         true





//***************************************************************
//                 ClusterMaker class declaration
//
//****************************************************************

namespace Atlfast {
  class Cell;
  class Cluster;
  class IClusterStrategy;
  class TesIO;
class ClusterMaker : public Algorithm
{

 public:

  //-------------------------
  // Constructors/Destructors
  //-------------------------
  ClusterMaker( const std::string& name, ISvcLocator* pSvcLocator ) ; 
  virtual ~ClusterMaker();


  //------------------------------------------------------
  // Methods used by Athena to run the algorithm
  //------------------------------------------------------
  StatusCode initialize() ;
  StatusCode execute() ;
  StatusCode finalize() ;



 private:


  //------------------------------------
  // Types used internally by this class
  //------------------------------------

  // For local mutable copies of collections needed for algorithm operation
  typedef std::vector<Cell*>                   localCellCollection ;
  typedef localCellCollection::iterator        localCellIterator ;



  //---------------------------------------------------
  // Parameters of this algorithm 
  //---------------------------------------------------

  double        m_rConeBarrel;   
  double        m_rConeForward;   

  double        m_minInitiatorET ;

  double        m_minClusterET;     

  bool m_masslessJets;

  std::string   m_strategy;
  IClusterStrategy* m_clusterStrategy;
  std::string   m_inputLocation ;
  std::string   m_outputLocation ;
  std::string   m_unusedCellLocation ;



  //-------------------------------
  // Objects used by this class to do its job
  //-------------------------------

  KinematicHelper m_kinehelp ; 

  /*#  Cell lnkCell; */
  //-------------------------------
  // Private methods
  //-------------------------------

  void makeClusters( MsgStream& log, localCellCollection, ClusterCollection* ) ;

  // looks up R-cone size according to position of initiator
  //  double rCone( Cell* ) ;
  //Cell* version commented out for now: arg is not used+ gives
  //a compiler warning
  double rCone() ;

  TesIO* m_tesIO;
  //-------------------------------
  // Private helper class
  // For accumulating weighted kinematic quantities
  //-------------------------------

  class PreCluster {

    private:

     double m_eT_total ;
     double m_eta_weighted ;
     HepLorentzVector m_momentum_sum ;
    public:

     // Construct
     PreCluster( localCellIterator start, localCellIterator end )  ;

     double eT()  ;
     double eta() ;
     double phi() ;
     
     operator HepLorentzVector () ;
  };


    Cluster * lnkCluster;
};

} // end of namespace bracket


#endif

---