TrackCaloClusterRecValidationTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
#ifndef TRACKCALOCLUSTERREC_TRACKCALOCLUSTERRECVALIDATION_TRACKCALOCLUSTERRECVALIDATIONTOOL_H
#define TRACKCALOCLUSTERREC_TRACKCALOCLUSTERRECVALIDATION_TRACKCALOCLUSTERRECVALIDATIONTOOL_H
 
#include "AthenaMonitoring/ManagedMonitorToolBase.h"
 
//#gaudi includes
#include "GaudiKernel/ToolHandle.h"
//EDM includes
#include "xAODTruth/TruthParticleContainer.h"
//Athena
 
//STL includes
#include <string>
#include <vector>
 
#include "xAODJet/JetContainer.h"
#include "StoreGate/ReadHandleKey.h"
#include "xAODEventInfo/EventInfo.h"
#include "JetCalibTools/IJetCalibrationTool.h"
 
class TCCPlots;
class IJetCalibrationTool;
 
class TrackCaloClusterRecValidationTool: public ManagedMonitorToolBase {
public:
    TrackCaloClusterRecValidationTool(const std::string & type, const std::string & name, const IInterface* parent);
    virtual ~TrackCaloClusterRecValidationTool();
    virtual StatusCode initialize();
    virtual StatusCode bookHistograms();
    virtual StatusCode fillHistograms();
    virtual StatusCode procHistograms();
private:
    TrackCaloClusterRecValidationTool();
    
    ToolHandleArray<IJetCalibrationTool>  m_jetCalibrationTools;
    std::vector< std::string >            m_jetCalibrationCollections;
    bool                                  m_applyCalibration;
    
    const xAOD::JetContainer* calibrateAndRecordShallowCopyJetCollection(const xAOD::JetContainer * jetContainer, const std::string& name);
    
    const xAOD::Jet* ClusterMatched(const xAOD::Jet* jet, const xAOD::JetContainer* jets);
    const xAOD::Jet* ClusterMatched(const xAOD::Jet* jet, const std::vector<const xAOD::Jet*>& jets) const;
    
    // Get a data container; implementation at end of this header file
    template<class T> const T* getContainer( const std::string & containerName);
        
    bool m_saveJetInfo;
    std::string m_truthJetContainerName;
    std::string m_truthTrimmedJetContainerName;
    
    std::vector<std::string> m_jetContainerNames;
    
    std::string m_vertexContainerName;
    
    std::string m_topoJetReferenceName;
    std::string m_topoTrimmedJetReferenceName;
 
    std::string m_dirName;
    float m_maxJetDR;
    float m_maxEta;
    float m_minPt;
    float m_minMass;
    float m_maxMass;
    
    std::string m_folder;
    
    std::string m_trackParticleCollectionName;
   
    bool  m_saveTrackInfo;
    bool  m_saveMatchingInfo;
    float m_trackPtMin;
    
    std::vector<float> m_jetPtBins           ;
    std::vector<float> m_jetMassOverPtBins   ;
    std::vector<float> m_trackPtBins         ;
    std::vector<float> m_trackProdRadiusBins ;
    
    bool m_saveClusterInfo;
    std::string m_caloClusterCollectionName;
    float m_caloClusterEtaMax;
    
    bool m_saveTCCInfo;
    std::vector<std::string> m_TCCCombinedCollectionNames;
    float m_tccPtMin;
    float m_tccEtaMax;
    
    //histograms
    std::map<std::string, TCCPlots*>    m_tccPlots;
 
    // EventInfo
    SG::ReadHandleKey<xAOD::EventInfo>    m_evt  {this, "EvtInfo", "EventInfo", "EventInfo name"};
};
 
template<class T>
inline const T* TrackCaloClusterRecValidationTool::getContainer(const std::string & containerName){
  const T * ptr = evtStore()->retrieve< const T >( containerName );
  if (!ptr) {
    ATH_MSG_WARNING("Container '"<<containerName<<"' could not be retrieved");
  }
  return ptr;
}
 
#endif //TRACKCALOCLUSTERREC_TRACKCALOCLUSTERRECVALIDATION_TRACKCALOCLUSTERRECVALIDATIONTOOL_H