---

JetMaker.h

Go to the documentation of this file.

// ================================================
// JetMaker class description
// ================================================
//
// THIS TEXT TO BE REPLACED BY ATLAS STANDARD FORMAT
//
//
// This version....
//
//
// Namespace Atlfast::
//
// class: JetMaker
//
// Description: 
//
//  Algorithm which knows how to make Jets
//
//  The resulting Jets are added to the Event
//
// ................................................................
//

#ifndef ATLFAST_JETMAKER_H
#define ATLFAST_JETMAKER_H

// STL
#ifndef STD_VECTOR_H
#include <vector>
#define STD_VECTOR_H
#endif

#ifndef STD_STRING_H
#include <string>
#define STD_STRING_H
#endif

// Gaudi 
#ifndef GAUDIKERNEL_ALGORITHM_H
#include "GaudiKernel/Algorithm.h"
#define GAUDIKERNEL_ALGORITHM_H
#endif

// Other
#ifndef CLHEP_LORENTZVECTOR_H
#include "CLHEP/Vector/LorentzVector.h"
#define CLHEP_LORENTZVECTOR_H
#endif

// Atlfast
#ifndef ATLFAST_KINEMATICHELPER_H
#include "AtlfastUtils/KinematicHelper.h"
#endif

#ifndef ATLFAST_MCPARTICLECOLLECTION_H
#include "AtlfastEvent/MCparticleCollection.h"
#endif
//***************************************************************
// JetMaker class declaration
//
// A "Gaudi algorithm" is something which gets scheduled and controlled
// by the framework. In its simplest definition it is something which
//  - gets clled for each event 
//  - can get anything it wants out of the Transient Event Store"
//  - can put anything it makes into the store.

//
//****************************************************************
class MsgStream;
class ISvcLocator;

namespace PartitionCondition{
  class BelowThresholdDeltaR;
}

namespace Atlfast {
  using std::string;
  using std::vector;
  class TesIO;
  class Cluster;
  class TesIO;
  class ISmearer;
  class ReconstructedParticle;
  class Jet;
  
  class JetMaker : public Algorithm{

  private:
    //------------------------------------
    // Types used internally by this class
    // for local collections 
    //------------------------------------
    
    typedef std::vector<Cluster*>                       localClusterCollection;
    typedef std::vector<Cluster*>::iterator               localClusterIterator;
    typedef std::vector<ReconstructedParticle*>           MuonCollection;
    typedef std::vector<ReconstructedParticle*>::iterator MuonIterator;
    
    //--------------------------------
    // Parameters of this algorithm
    // (descriptions above)
    //--------------------------------
    
     
    double        m_minPT;     
    double        m_maxEta;       
    bool          m_doSmearing;
    
    double        m_barrelForwardEta;
    double        m_rconeb;
    double        m_rconef;
    
    double m_bPtMin;
    double m_bMaxDeltaR;
    double m_cPtMin;
    double m_cMaxDeltaR;
    double m_tauPtMin;
    double m_tauMaxDeltaR;
    double m_etaTagMax;
    double m_tauJetPtRatio;
    
    //--------------------------------------------
    // Smearer helper class
    // which knows all about how to do smearing
    // for my particles
    //---------------------------------------------
    
    ISmearer* m_smearer;
    ISmearer* m_cellSmearer;
    
    
    TesIO* m_tesIO;
    
    //--------------------------------------------------
    // Paths in the Transient Event store to get/put things
    // These are currently set in member variables so that
    // they can be overwritten by the job options service
    //--------------------------------------------------
    
    std::string m_inputLocation ;
    std::string m_outputLocation ;
    std::string m_muonLocation;
    std::string m_mcTruthLocation;
    std::string m_unusedCellLocation;
    std::string m_missingMomentumLocation;

    //-------------------------------
    // helper
    //-------------------------------
    
    KinematicHelper m_kinehelp ;
    
    int getJetTags(MCparticleCollection&  mcParticles,
                   const PartitionCondition::BelowThresholdDeltaR& tagSelector
                   )const;
    int getTauTags(MCparticleCollection&  mcParticles,
                   const PartitionCondition::BelowThresholdDeltaR& tagSelector,
                   double jetPt )const;
    void tag(Jet* jet, 
             MCparticleCollection&  mcParticles_b, 
             MCparticleCollection&  mcParticles_c, 
             MCparticleCollection&  mcParticles_tau) const;
    
    HepLorentzVector addUnusedCells(MsgStream&) const;
    
    //-------------------------------
    // Protected methods
    //-------------------------------
  public:
    
    //-------------------------
    // Constructors/Destructors
    //
    // Gaudi requires that the constructor takes certain arguments
    // (and passes them directly to the constructor of the base class)
    //-------------------------
    
    JetMaker( const std::string& name, ISvcLocator* pSvcLocator ) ; 
    virtual ~JetMaker();
    
    
    //------------------------------------------------------
    // Methods used by Gaudi to run the algorithm
    //------------------------------------------------------
    
    StatusCode initialize() ;
    StatusCode execute() ;
    StatusCode finalize() ;
    
    //------------------------------------------------------
    // Methods of IReconstructedParticleMaker which we are
    // implementing
    //------------------------------------------------------
    
    Jet* create( Cluster* );
    bool isAcceptable( Jet* );
    void addMuons(Jet*, MuonCollection& );
    MsgStream& dumpParameters(MsgStream& ) const; 
};
  
  
}  //end of namespace bracket

#endif

---