#ifndef USERANALYSISUTILS_USERMUONTOOL_H 
 #define USERANALYSISUTILS_USERMUONTOOL_H 
 
 /*****************************************************************************
 Name    : UserMuonTool.h
 Package : offline/PhysicsAnalysis/AnalysisCommon/UserAnalysisUtils
 Author  : Ketevi A. Assamagan
 Created : September 2007
 Purpose : User tools for muon analyis on ESD/AOD/DPD in Athena
           - redo vertexing, isolation, refitting, recombination on the fly
             assuming different aligment and calibration constants
 *****************************************************************************/
 
 #include "GaudiKernel/AlgTool.h"
 #include "GaudiKernel/MsgStream.h"
 #include "StoreGate/StoreGateSvc.h"
 
 #include "VxVertex/VxContainer.h"
 #include "Particle/TrackParticleContainer.h"
 #include "CaloEvent/CaloClusterContainer.h"
 #include "TrkSegment/SegmentCollection.h"
 
 #include "muonEvent/MuonContainer.h"
 
 #include <string>
 #include <map>
 #include <vector>
 
 /** Interface ID for User Muon making */  
 static const InterfaceID IID_UserMuonTool("UserMuonTool", 1, 0);
 
 class UserMuonTool : public AlgTool {
 
 public:
 
   /** Standard Constructor */
   UserMuonTool(const std::string& type, const std::string& name,
                    const IInterface* parent);
 
   /** AlgTool and IAlgTool interface methods */
   static const InterfaceID& interfaceID( ) { return IID_UserMuonTool; };
 
   /** Overriding initialize and finalize */
   virtual StatusCode initialize();
 
   /** refit one Muon
       - pass the the muon to be refitted
       - get back a new refitted muon with all its associated new tracks, trackParticles, segments and CaloClusters
       - the isolation is also redone automatically
       - the energies in the calorimeter layers are recalculated */
   virtual StatusCode refit (const Analysis::Muon* oldMuon, Analysis::Muon* newMuon, 
                             std::vector<const Rec::TrackParticle*>& newTrackParticles,
                             std::vector<const Trk::Track*>& newTracks,
                             std::vector<const Trk::Segment>& newSegments,
                             CaloCluster * newCluster);
 
   /** refit a collection of muons
       - it will call the refit for each muon in the collection
       - you will pass the container of the muons
       - you will also pass a vector<std::string> it should contains the StoreGates of the new TrackParticleContainer,
         TrackCollection, SegmentCollection and CaloClusterContainer and MuonContainer respectively and in that order. 
         Thus, the size of the vector must be 5
       - The new collections are written to StoreGate: new MuonContainer of refitted Muons, and new Containers of the
         associated TrackParticles, Tracks, Segments and CaloClusters */
   virtual StatusCode refit (const Analysis::MuonContainer * oldMuonContainer, std::vector<std::string>& newKeys);
 
   /** redo calo isolation either on a refitted muon track or with different parameters 
       if you pass a list of deltaR, you get a list of results back */
   virtual StatusCode redoCaloIsolation(const Analysis::Muon*, const float deltaR, const bool onlyEM, float& value);
   virtual StatusCode redoCaloIsolation(const Analysis::Muon*, const std::vector<float>& deltaR, const bool onlyEM, 
                                        std::vector<double>& values);
 
   /** redo track isolation either on a refitted muon track or with different parameters 
       if you pass a list of deltaR you will get back a list of values */
   virtual StatusCode redoTrackIsolation(const Analysis::Muon*, const float deltaR, float& value);
   virtual StatusCode redoTrackIsolation(const Analysis::Muon*, const std::vector<float>& deltaR, 
                                         std::vector<double>& values);
 
   /** redo combinations -> MuonSpectrometer/Inner Detector after refitting for example
       - you pass an std::vector<std::string>: it should contain the StoreGate keys of:
          # the Inner Detector TrackParticles,
          # the key for the Muon TrackParticles extrapolated to the vertex, 
       - on output, you get a new muon collection - the list of StorGate keys of the associated containers:
          # Inner Detector - same as on input
          # Muon Spectrometer to vertex - same as on input
          # CaloClusterContainer keys
          # and the new MuonCollection keys 
       - the new Muon are completely dressed with energy/isolation/calo information */
   virtual StatusCode recombine(const std::vector<std::string>& oldKeys, std::vector<std::string>& newKeys);
 
   /** refit the common vertex to the list of Muons 
        need to think about this in more details */
   virtual StatusCode refitVertex( const std::vector<const Analysis::Muon*> );
 
   /** finalization */
   virtual StatusCode finalize();
 
 protected:
 
    /** Standard destructor */
    virtual ~UserMuonTool( );
 
   /** a handle on Store Gate for access to the Event Store */
   StoreGateSvc* m_storeGate;
 
   /** should contain the StoreGate keys to be passed in job options */ 
   std::vector<std::string> m_keys;
 
 };
 
 #endif // USERANALYSISUTILS_USERMUONTOOL_H 
 
 
 
 

Due to the LXR bug, the updates fail sometimes to remove references to deleted files. The Saturday's full rebuilds fix these problems
This page was automatically generated by the LXR engine.