MuonCalibIntHighpTSmearTool.cxx File Reference

#include "AsgDataHandles/ReadHandle.h"
#include "PathResolver/PathResolver.h"
#include <cmath>
#include "TRandom3.h"
#include "MuonMomentumCorrections/MuonCalibIntHighpTSmearTool.h"
#include "MuonMomentumCorrections/EnumDef.h"
#include <MuonMomentumCorrections/CalibInitializer.h>
#include "MuonAnalysisInterfaces/IMuonSelectionTool.h"

Include dependency graph for MuonCalibIntHighpTSmearTool.cxx:

Go to the source code of this file.

Functions
namespace	ADD_CMODE (CP)

Function Documentation

ADD_CMODE()

namespace ADD_CMODE

(

CP

)

Definition at line 1 of file MuonCalibIntHighpTSmearTool.cxx.

{
 
    MuonCalibIntHighpTSmearTool::MuonCalibIntHighpTSmearTool(const std::string &name) : asg::AsgTool(name)
    {
    }
 
    StatusCode MuonCalibIntHighpTSmearTool::initialize()
    {
        // Greet the user:
        ATH_MSG_INFO("Initializing MuonCalibIntHighpTSmearTool");
 
        // Get the m_eventinfo container
        ATH_CHECK(m_eventInfo.initialize());
 
        
        // Load the constants
        for(const auto& year: MCP::dataYearList)
        {
            m_MS_Misaligned_p1[year]          = MCP::CalibInitializer::createHighpTCorrMap(year, "Misaligned", m_release, "p1");
            m_MS_Misaligned_p2[year]          = MCP::CalibInitializer::createHighpTCorrMap(year, "Misaligned", m_release, "p2");
            m_MS_AlignedAndCorrected_p1[year] = MCP::CalibInitializer::createHighpTCorrMap(year, "AlignedAndCorrected", m_release, "p1");
            m_MS_AlignedAndCorrected_p2[year] = MCP::CalibInitializer::createHighpTCorrMap(year, "AlignedAndCorrected", m_release, "p2");
 
        }
 
 
        if (!applySystematicVariation(CP::SystematicSet()))
        {
            ATH_MSG_ERROR("Unable to run with no systematic");
            return StatusCode::FAILURE;
        }
        CP::SystematicRegistry &registry = CP::SystematicRegistry::getInstance();
        if (registry.registerSystematics(*this) != StatusCode::SUCCESS)
        {
            ATH_MSG_ERROR("Unkown systematic list");
            return StatusCode::FAILURE;
        }
        // Return gracefully:
        return StatusCode::SUCCESS;
    }
 
    CP::CorrectionCode MuonCalibIntHighpTSmearTool::applyCorrection(MCP::MuonObj& mu) const
    {
        // Do nothing, if it is data
        if(mu.CB.isData) return CP::CorrectionCode::Ok;
 
        auto cat = ConvertToMacroCategory(mu.raw_mst_category.value());
 
        ATH_MSG_VERBOSE("Doing high pT smearing: "<<int(cat)<<" for year: "<<int(mu.CB.year)<<" raw: "<<mu.raw_mst_category.value());
 
        // If undefined, don't perform any smearing
        if(cat == MCP::MST_Categories::Undefined)
        {
            return CP::CorrectionCode::Ok; 
        }
 
 
        double MS_Misaligned_p1 = m_MS_Misaligned_p1.at(mu.CB.year).at(cat)->getCalibConstant(mu.CB);
        double MS_Misaligned_p2 = m_MS_Misaligned_p2.at(mu.CB.year).at(cat)->getCalibConstant(mu.CB);
        double reso_Misaligned = std::hypot(MS_Misaligned_p1, MS_Misaligned_p2 * mu.CB.calib_pt);
 
        double MS_AlignedAndCorrected_p1 = m_MS_AlignedAndCorrected_p1.at(mu.CB.year).at(cat)->getCalibConstant(mu.CB);
        double MS_AlignedAndCorrected_p2 = m_MS_AlignedAndCorrected_p2.at(mu.CB.year).at(cat)->getCalibConstant(mu.CB);
 
        double reso_AlignedAndCorrected = std::sqrt(std::pow(MS_AlignedAndCorrected_p1, 2) + std::pow(MS_AlignedAndCorrected_p2 * mu.CB.calib_pt, 2));
 
        double smearDeltaCBOnly = 0;
        if (reso_Misaligned > reso_AlignedAndCorrected) smearDeltaCBOnly = std::sqrt(std::pow(reso_Misaligned, 2) - std::pow(reso_AlignedAndCorrected, 2));
        
        
        double smeared_combined_pt = mu.CB.calib_pt * (1. + mu.rnd_g_highPt * smearDeltaCBOnly);
 
        mu.CB.calib_pt = smeared_combined_pt;
 
        // Return gracefully:
        return CP::CorrectionCode::Ok;
    }
 
    bool MuonCalibIntHighpTSmearTool::isAffectedBySystematic(const CP::SystematicVariation &systematic) const
    {
        CP::SystematicSet sys = affectingSystematics();
        return sys.find(systematic) != sys.end();
    }
 
    CP::SystematicSet MuonCalibIntHighpTSmearTool::affectingSystematics() const
    {
        CP::SystematicSet result;
        // No systematics for now
        return result;
    }
 
    CP::SystematicSet MuonCalibIntHighpTSmearTool::recommendedSystematics() const { return affectingSystematics(); }
 
    StatusCode MuonCalibIntHighpTSmearTool::applySystematicVariation(const CP::SystematicSet&)
    {
        // No systematics current supported for this tool
        return StatusCode::SUCCESS;
    }
 
    MCP::MST_Categories MuonCalibIntHighpTSmearTool::ConvertToMacroCategory(const int raw_mst_category) const {
        if (raw_mst_category < 0) {
            return MCP::MST_Categories::Undefined;
        } else if (raw_mst_category & CP::IMuonSelectionTool::CategoryZero)
            return MCP::MST_Categories::Zero;
        else if (raw_mst_category & CP::IMuonSelectionTool::CategoryOne)
            return MCP::MST_Categories::One;
        else if (raw_mst_category & CP::IMuonSelectionTool::CategoryTwo)
            return MCP::MST_Categories::Two;
        else if (raw_mst_category & CP::IMuonSelectionTool::CategoryThree)
            return MCP::MST_Categories::Three;
        else if (raw_mst_category & CP::IMuonSelectionTool::CategoryFour)
            return MCP::MST_Categories::Four;
        else
            return MCP::MST_Categories::Undefined;
    }
 
 
 
} // namespace ADD_CMODE(CP)