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

#include "AtlfastEvent/CollectionDefs.h"

#include "AtlfastUtils/HepMC_helper/NCutter.h"
#include "AtlfastUtils/HepMC_helper/IsFromHardScatter.h"
#include "AtlfastUtils/HepMC_helper/SelectJetTag.h"
#include "AtlfastUtils/HepMC_helper/SelectTauTag.h"

//***************************************************************
// 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 ICluster;
  class ISmearer;
  class ReconstructedParticle;
  class Jet;
  
  class JetMaker : public Algorithm{

  private:
    //------------------------------------
    // Types used internally by this class
    // for local collections 
    //------------------------------------
    
    typedef std::vector<ICluster*>                        localClusterCollection;
    typedef localClusterCollection::iterator              localClusterIterator;
    typedef std::vector<ReconstructedParticle*>           MuonCollection;
    typedef MuonCollection::iterator                      MuonIterator;
    
    //--------------------------------
    // Selectors used
    //--------------------------------
    
    HepMC_helper::IMCselector* m_bSelector;
    HepMC_helper::IMCselector* m_cSelector;
    HepMC_helper::IMCselector* m_tauSelector;      
    
    //--------------------------------
    // 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;

    bool   m_adjustMissETForIsolation;
    
    // Cumulative sum of missing ET
    double m_sumET;

   //--------------------------------------------
    // Smearer helper class
    // which knows all about how to do smearing
    // for my particles
    //---------------------------------------------
    
    ISmearer* m_smearer;
    ISmearer* m_cellSmearer;
    
    
    TesIO* m_tesIO;
    //holds the Storegate MC location
    std::string m_mcLocation;
    
    //--------------------------------------------------
    // 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_unusedCellLocation;
    std::string m_missingMomentumLocation;
    std::string m_isolatedElectronLocation;
    std::string m_isolatedPhotonLocation;

    //-------------------------------
    // helper
    //-------------------------------
    
    KinematicHelper m_kinehelp ;
    
    int getJetLabel(MCparticleCollection&  mcParticles,
                    Jet* jet,
                    double maxDeltaR,
                    double &deltaR)const;
    int getTauLabel(MCparticleCollection&  mcParticles,
                    Jet* jet,
                    double maxDeltaR,
                    double &deltaR)const;
    void label(Jet* jet, 
               MCparticleCollection&  mcParticles_b, 
               MCparticleCollection&  mcParticles_c, 
               MCparticleCollection&  mcParticles_tau) const;
    
    HepLorentzVector addCells(MsgStream&);
    void getUnusedCells(std::vector<const ITwoCptCell*>&, MsgStream&);
    void getIsolationCorrectionCells(std::vector<const ITwoCptCell*>&, 
                                     std::vector<const ITwoCptCell*>&, 
                                     std::string, MsgStream&);
    
    //-------------------------------
    // 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() ;
    
    Jet* create( ICluster* );
    bool isAcceptable( Jet* );
    void addMuons(Jet*, MuonCollection& );

    MsgStream& dumpParameters(MsgStream& ) const; 
};
  
  
}  //end of namespace bracket

#endif

---