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/CollectionDefs.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;
    bool m_processTracks;
    bool m_processCells;        
    std::string   m_inputCellLocation ;
    std::string   m_inputTrackLocation ;
    std::string   m_outputLocation ;
    std::string   m_unusedCellLocation ;
    std::string   m_unusedTrackLocation ;
    
    double m_ktRParameter;
    std::string m_ktAngle;
    std::string m_ktRecomScheme;
    int m_ktYCut;
    
    //-------------------------------
    // 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;

    //holds the Stotegate MC location
    std::string m_mcLocation;

    //-------------------------------
    // 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
    //            ); 
    //      
    //      /** kinematic query */
    //      double eT()  ;
    //      /** kinematic query */
    //      double eta() ;
    //      /** kinematic query */
    //      double phi() ;
    //      
    //      /** Conversion to HepLorentzVector */
    //      operator HepLorentzVector () ;
    //    };
    
    //    Cluster * lnkCluster;
  };
} // end of namespace bracket

#endif

---