---

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 "AtlfastEvent/CellCollection.h"
#include "AtlfastEvent/ClusterCollection.h"

#include "AtlfastUtils/KinematicHelper.h"

class ISvcLocator;
class MsgStream;

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

namespace Atlfast {
  class Cell;
  class Cluster;
  class IClusterStrategy;
  class TesIO;

  using std::string;
  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 ; 
    
    //-------------------------------
    // Private methods
    //-------------------------------
    
    //    void makeClusters( MsgStream& log, 
    //         localCellCollection, ClusterCollection* ) ;
    void makeClusters( MsgStream& log,
                       std::vector<Cell*>,  
                       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 {
      //      using ClusterMaker::localCellIterator;
      
    private:
      
      double m_eT_total ;
      double m_eta_weighted ;
      HepLorentzVector m_momentum_sum ;
    public:
      
      // Construct
      //      PreCluster( localCellIterator start, localCellIterator end )  ;
      PreCluster( std::vector<Cell*>::iterator start, 
                  std::vector<Cell*>::iterator end
                  ); 
      
      double eT()  ;
      double eta() ;
      double phi() ;
      
      operator HepLorentzVector () ;
    };
    
    Cluster * lnkCluster;
  };
  
} // end of namespace bracket

#endif

---