InDetTrackSystematicsTool.h

Go to the documentation of this file.

// -*- c++ -*-
/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef INDETTRACKSYSTEMATICSTOOLS_INDETTRACKSYSTEMATICSTOOL_H
#define INDETTRACKSYSTEMATICSTOOLS_INDETTRACKSYSTEMATICSTOOL_H
 
#include <cstdint>
#include <string>
#include <map>
#include <memory>
 
#include "InDetTrackSystematicsTools/InDetTrackSystematics.h"
#include "AsgTools/AsgTool.h"
#include "PATInterfaces/ISystematicsTool.h"
#include "PATInterfaces/SystematicSet.h"
 
#include <TFile.h>
#include <TH2.h>
 
namespace InDet {
 
  class InDetTrackSystematicsTool : public virtual CP::ISystematicsTool, public asg::AsgTool {
 
    ASG_TOOL_CLASS2( InDetTrackSystematicsTool,
                     CP::ISystematicsTool, CP::IReentrantSystematicsTool )
  public:
    InDetTrackSystematicsTool( const std::string& );
    virtual ~InDetTrackSystematicsTool() = default;
 
    virtual StatusCode initialize() override;

    virtual bool isAffectedBySystematic( const CP::SystematicVariation& ) const override;
    virtual CP::SystematicSet affectingSystematics() const override = 0;
    virtual CP::SystematicSet recommendedSystematics() const override;
    virtual StatusCode applySystematicVariation( const CP::SystematicSet& ) override;
 
 
  protected:
    std::unique_ptr<TFile> getFile( const std::string& ) const;

    template <class T> StatusCode initObject(std::unique_ptr<T>& obj, const std::string& rootFileName, const std::string& objName) const;
 
    // a map from a general set to a set that is filtered for the ones we use
    // note that SystematicSet caches its hashes so this is probably not as slow as it might seem
    std::unordered_map< CP::SystematicSet, CP::SystematicSet > m_sysFilterMap;
 
    const CP::SystematicSet* m_activeSysts = nullptr;
 
    bool isActive( TrackSystematic ) const;

    const CP::SystematicSet* getFilteredSysts(
        const CP::SystematicSet& syst) const;

    bool isActive(TrackSystematic syst,
                  const CP::SystematicSet& filtered) const;

    static uint64_t variationMask(const CP::SystematicSet& filtered);
    uint64_t activeVariationMask() const;
 
  };
 
}
 
// must define template function in header
template <class T>
StatusCode InDet::InDetTrackSystematicsTool::initObject(std::unique_ptr<T>& obj, const std::string& rootFileName, const std::string& objName) const
{
  if (obj != nullptr) ATH_MSG_WARNING( obj->GetName() << " is not null, yet we are now attempting to initialize from " << rootFileName );
  std::unique_ptr<TFile> F = getFile(rootFileName);
  if(!F || F->IsZombie()) {
    ATH_MSG_ERROR( "Could not open file " << rootFileName );
    return StatusCode::FAILURE;
  }
  T* tempObj = nullptr;
  F->GetObject(objName.data(), tempObj);
  if(tempObj==nullptr) {
    ATH_MSG_ERROR( "Could not retrieve " << objName << " from file " << rootFileName );
    return StatusCode::FAILURE;
  }
  obj = std::unique_ptr<T>(static_cast<T*>(tempObj->Clone()));
  obj->SetDirectory(0);
  F->Clear();
  F->Close();
  return StatusCode::SUCCESS;
}
 
#endif