#include <JetTagCalibCondAlg.h>

Inheritance diagram for Analysis::JetTagCalibCondAlg:

Collaboration diagram for Analysis::JetTagCalibCondAlg:

Public Member Functions
	JetTagCalibCondAlg (const std::string &name, ISvcLocator *pSvcLocator)
	@ class JetTagCalibCondAlg More...

	~JetTagCalibCondAlg ()

virtual StatusCode	initialize () override

virtual StatusCode	execute () override

virtual StatusCode	finalize () override

virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...

virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)

void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	registerHistogram (const std::string &tagger, const std::string &histoname)

void	registerHistogram (const std::string &tagger, const std::string &directory, const std::string &histoname)

StatusCode	createHistoMap (TFile file, JetTagCalibCondData histos)

StatusCode	objectTDirExists (const std::string &histname, TFile *file) const

std::vector< std::string >	tokenize (const std::string &str, const std::string &delim)

void	smoothAndNormalizeHistogram (TH1 *h, const std::string &hname)

void	smoothASH2D (TH2 *input2D, int m1, int m2)

void	initializeIPTag ()

void	initializeIP2D ()

void	initializeIP3D ()

void	initializeSVEff (const std::string &)

void	initializeSV1 ()

void	initializeSV2 ()

void	initializeJetFitterNN ()

void	initializeSoftMu ()

void	initializeMV2 (const std::string &)

void	initializeRNNIP ()

void	initializeMultiSV (const std::string &)

void	initializeDL1 (const std::string &)

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
SG::ReadCondHandleKey< CondAttrListCollection >	m_readKey {this, "ReadKeyCalibPath", "/GLOBAL/BTagCalib/RUN12", "Key of input (raw) conditions folder of bration path"}

SG::WriteCondHandleKey< JetTagCalibCondData >	m_writeKey {this, "HistosKey", "JetTagCalibHistosKey", "Key of output (derived) JetTag calibration data"}

IPoolSvc *	m_poolsvc

std::vector< std::string >	m_taggers

std::unordered_map< std::string, std::string >	m_directoryMap

std::vector< std::vector< std::string > >	m_taggersHists

std::vector< std::string >	m_mappedAlias

std::vector< std::string >	m_originalChannels

StringArrayProperty	m_channelAliases

std::map< std::string, std::vector< std::string > >	m_channelAliasesMultiMap

bool	m_IPTag_useCHypo

std::vector< std::string >	m_IPTag_hypotheses

std::vector< std::string >	m_IP2D_trackGradePartitions

bool	m_useDRJPVSV

bool	m_usePtSV2

int	m_Likelihood_smoothNTimes

std::vector< std::string >	m_Likelihood_vetoSmoothingOf

std::string	m_JetFitterNN_calibrationDirectory

std::string	m_JetFitterNN_calibrationSubDirectory

bool	m_JetFitterNN_useCombinedIPNN

int	m_JetFitterNN_maximumRegisteredLayers

std::string	m_DL1_file_name

std::map< std::string, std::string >	m_RNNIP_network_cfg

DataObjIDColl	m_extendedExtraObjects

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Detailed Description

@ class JetTagCalibCondAlg

This class retrieves calibration histograms from COOL for the taggers. A single COOL folder is defined for all the taggers. Each tagger is subdivided in channels, each channel being associated to a jet type (Cone4Topo, Kt6, etc).

Any further substructure (track categories, signal/background) is hidden to COOL and is defined by the actual name of the histogram.

This class holds the collection of maps between the histogram name and the pointer to the histogram, the latter being kept up-to-date with the condition algorithm mecanism. All the taggers histograms are registered in initialize() method with the registerHistogram() method.

The geometry tag corresponding to the calibrations, the type of physics events used, the tracking algorithm, etc, are all defined by a DB tag.

Author: emman.nosp@m.uel..nosp@m.le.gu.nosp@m.irri.nosp@m.ec@ce.nosp@m.rn.c.nosp@m.h

Definition at line 49 of file JetTagCalibCondAlg.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ JetTagCalibCondAlg()

Analysis::JetTagCalibCondAlg::JetTagCalibCondAlg	(	const std::string &	name,
		ISvcLocator *	pSvcLocator
	)

@ class JetTagCalibCondAlg

Author: emman.nosp@m.uel..nosp@m.le.gu.nosp@m.irri.nosp@m.ec@ce.nosp@m.rn.c.nosp@m.h

Definition at line 28 of file JetTagCalibCondAlg.cxx.

     : ::AthAlgorithm( name, pSvcLocator ),
     m_Likelihood_smoothNTimes(1),
     m_JetFitterNN_calibrationDirectory("JetFitter"),
     m_JetFitterNN_calibrationSubDirectory("NeuralNetwork"),
     m_JetFitterNN_useCombinedIPNN(false),
     m_JetFitterNN_maximumRegisteredLayers(4)
     {
       declareProperty("taggers", m_taggers);
       declareProperty("channels", m_originalChannels);
       declareProperty("channelAliases", m_channelAliases);
       declareProperty("IPTag_UseCHypo"            , m_IPTag_useCHypo = true);
       declareProperty("IP2D_TrackGradePartitions", m_IP2D_trackGradePartitions);
       declareProperty("SV_useDRJPV", m_useDRJPVSV=true);
       declareProperty("SV2_usePt", m_usePtSV2=false);
       declareProperty("Likelihood_smoothNTimes",m_Likelihood_smoothNTimes);
       declareProperty("Likelihood_vetoSmoothingOf",  m_Likelihood_vetoSmoothingOf);
       declareProperty("JetFitterNN_CalibrationDirectory",m_JetFitterNN_calibrationDirectory);
       declareProperty("JetFitterNN_CalibrationSubDirectory",m_JetFitterNN_calibrationSubDirectory);
       declareProperty("JetFitterNN_useCombinedIPNN",m_JetFitterNN_useCombinedIPNN);
       declareProperty("JetFitterNN_maximumRegisteredLayers",m_JetFitterNN_maximumRegisteredLayers);
       declareProperty("RNNIP_NetworkConfig", m_RNNIP_network_cfg);
       m_Likelihood_vetoSmoothingOf.push_back("/N2T");
       m_Likelihood_vetoSmoothingOf.push_back("/N2TEffSV2");
       m_Likelihood_vetoSmoothingOf.push_back("/Sip3D");
     }

◆ ~JetTagCalibCondAlg()

Analysis::JetTagCalibCondAlg::~JetTagCalibCondAlg ( )

Definition at line 55 of file JetTagCalibCondAlg.cxx.

56 {

57 }

Member Function Documentation

◆ createHistoMap()

StatusCode Analysis::JetTagCalibCondAlg::createHistoMap	(	TFile *	file,
		JetTagCalibCondData *	histos
	)

private

get all aliases

now see if the jet collection exists in db

check alias for the first tagger. same jet collections for all taggers for now

Definition at line 583 of file JetTagCalibCondAlg.cxx.

                                                                                             {
  
     ATH_MSG_DEBUG("#BTAG# in createHistoMap" );
     std::vector< std::string > channels;
  
     for(unsigned int j=0; j<m_originalChannels.size(); ++j){
       channels.push_back(m_originalChannels[j]);
     }
  
     std::string folder(m_readKey.key());
     
  
     for(uint i=0;i<m_taggers.size();++i) {
       std::string tagger = m_taggers[i];
  
       for(unsigned int j=0; j<m_originalChannels.size(); ++j){
         std::map<std::string, std::vector<std::string> >::iterator ialiaslist 
           = m_channelAliasesMultiMap.find(m_originalChannels[j]);
     if(ialiaslist == m_channelAliasesMultiMap.end()){
       ATH_MSG_DEBUG( "#BTAG#  no alias for original channel" << m_originalChannels[j] );
       if(!objectTDirExists(tagger+"/"+m_originalChannels[j], pfile)){
         ATH_MSG_WARNING( "#BTAG# no calibration for jet collection " << m_originalChannels[j]
                << " consider using aliases " );
       }
       continue;
     }
     std::vector<std::string> aliaslist = ialiaslist->second;
     if(aliaslist.size() == 1){
       if("none" == aliaslist[0]){
         ATH_MSG_DEBUG("#BTAG#  no alias for original channel" << m_originalChannels[j]);
                 
             if(objectTDirExists(tagger+"/"+m_originalChannels[j], pfile)){
           ATH_MSG_WARNING( "#BTAG# no calibration for jet collection " << m_originalChannels[j]
                      << " consider using aliases " );
             }
             continue;
       }
     }
  
     bool foundalias=false;
  
     for(unsigned int k=0; k<aliaslist.size(); ++k){
       std::string aliasentry = aliaslist[k];
       if("none" == aliasentry){
         ATH_MSG_DEBUG("#BTAG# first alias entry is none - replace with original channel" 
                 << m_originalChannels[j] );
             aliasentry= m_originalChannels[j];
       }
       std::string hFullName(tagger); 
       hFullName+="/"; hFullName+=aliasentry; 
           // Check if jet collection already in channel alias map
           if (std::count(m_mappedAlias.begin(), m_mappedAlias.end(), aliasentry) > 0) {
         ATH_MSG_DEBUG( "#BTAG# found alias entry in Map " << aliasentry );
             histosCdo->addChannelAlias(m_originalChannels[j],aliasentry);
             foundalias=true;
             break;
           }
           else {
             if (objectTDirExists(hFullName, pfile)) {
           ATH_MSG_DEBUG( "#BTAG# found alias entry in DB " << aliasentry );
               if("none"!=aliaslist[k]){
         std::vector<std::string>::const_iterator pos = find(channels.begin(), 
                                 channels.end(), aliasentry);
         if(pos==channels.end()) {
           ATH_MSG_DEBUG("#BTAG# Alias is pointing to undefined channel: " <<  aliasentry
                     << ". Adding it to channel list.");
           channels.push_back(aliasentry);
             }
                 histosCdo->addChannelAlias(m_originalChannels[j],aliasentry);
                 m_mappedAlias.push_back(aliasentry);
           }
           foundalias=true;
           break;
         }
         else{
           ATH_MSG_DEBUG( "#BTAG# no alias entry " << aliasentry 
                << " trying next alias ");
         }
       }
     }
     if(!foundalias){
       ATH_MSG_WARNING( "#BTAG# none of the aliases exist for jet collection " 
              << m_originalChannels[j]);
     }
  
       }
       break ; 
  
     }
  
     ATH_MSG_DEBUG( "#BTAG# final registered channels " );
     for(uint i=0;i<channels.size();++i) {
       ATH_MSG_DEBUG( "#BTAG# Channel " << channels[i] );
     }
  
     //print alias map
     histosCdo->printAliasesStatus();
  
     return StatusCode::SUCCESS;
  
   }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleKeyArrayType &
	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
  
   }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleKeyType &
	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
  
   }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleType &
	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
   }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	t,
		const SG::NotHandleType &
	)

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                  {
     typedef typename SG::HandleClassifier<T>::type htype;
     return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
   }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( ) const

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode Analysis::JetTagCalibCondAlg::execute ( )

overridevirtual

Definition at line 419 of file JetTagCalibCondAlg.cxx.

                                          {
     ATH_MSG_DEBUG("execute " << name());
  
     // Write Cond Handle
     SG::WriteCondHandle<JetTagCalibCondData > histoWriteHandle{m_writeKey};
     //For serial Athena. Execute() should not be called in AthenaMT
     if (histoWriteHandle.isValid()) {
       ATH_MSG_DEBUG("#BTAG# Write CondHandle "<< histoWriteHandle.fullKey() << " is already valid");
       return StatusCode::SUCCESS;
     }
  
     m_mappedAlias.clear();
  
     // Read Cond Handle - GUID
     SG::ReadCondHandle<CondAttrListCollection> readHandle{m_readKey};
     const CondAttrListCollection* atrcol{*readHandle};
     if(atrcol==nullptr) {
       ATH_MSG_ERROR("#BTAG# Cannot retrieve CondAttrListCollection for " << m_readKey.key());
       return StatusCode::FAILURE;
     }
  
  
     // Construct the output Cond Object and fill it in
     std::unique_ptr<JetTagCalibCondData> writeCdo{std::make_unique<JetTagCalibCondData>()};
     writeCdo->resize(m_taggers);
  
     // Define validity of the output cond object and record it
     EventIDRange rangeW;
     if(!readHandle.range(rangeW)) {
       ATH_MSG_ERROR("#BTAG# Failed to retrieve validity range for " << readHandle.key());
       return StatusCode::FAILURE;
     }
  
  
     unsigned int channel=1; //Always 1 in old version with CoolHistSvc
     CondAttrListCollection::const_iterator citr = atrcol->chanAttrListPair(channel);
     if (citr==atrcol->end()) {
       ATH_MSG_WARNING("#BTAG# Cannot find valid reference for " << readHandle.key() << " channel " << channel);
       return StatusCode::FAILURE;
     }
  
     const std::string coolguid=citr->second["fileGUID"].data<std::string>();
     ATH_MSG_DEBUG("#BTAG# Folder key "+ readHandle.key()+" has current file GUID "+coolguid);
  
     // Open the file
     std::string pfname, tech;
     m_poolsvc->catalog()->getFirstPFN(coolguid, pfname, tech );
     std::unique_ptr< TFile > pfile(TFile::Open(pfname.c_str(),"READ"));
     if (pfile.get()==nullptr || !pfile.get()->IsOpen()) {
       ATH_MSG_WARNING("Problems opening input file " << pfname 
                       << " [GUID " << coolguid << "]");
       return StatusCode::FAILURE;
     }
  
     StatusCode sc = createHistoMap(pfile.get(), writeCdo.get());
     if(sc != StatusCode::SUCCESS){
     // do nothing for the moment
     }
  
     for(uint i=0;i<m_taggers.size();i++) {
       std::string tagger = m_taggers[i];
  
       ATH_MSG_DEBUG( "#BTAG# registrating tagger "<< m_taggers[i]);
       std::vector<std::string> histnames = m_taggersHists[i];
       for(unsigned int h=0; h<histnames.size(); ++h){
     std::string hname = histnames[h];
     for(uint j=0;j<m_mappedAlias.size();j++) {
           std::string fname = writeCdo->fullHistoName(m_mappedAlias[j],hname);
           ATH_MSG_DEBUG( "#BTAG# Retrieving " << tagger <<":"<< fname );
           std::string channel = writeCdo->channelName(fname);
           std::string hname = writeCdo->histoName(fname);
           std::string hFullName(m_directoryMap[tagger]);
           hFullName+="/"; hFullName+=channel; 
           hFullName+="/"; hFullName+=hname;
           ATH_MSG_DEBUG( "#BTAG#     histo name in physical file= " << hFullName );
           std::unique_ptr< TObject > hPointer(pfile->Get(hFullName.c_str()));
           if(hPointer) {
             ATH_MSG_DEBUG( "#BTAG# Cached pointer to TObject: " << hPointer.get());
             if (tagger.find("DL1")!=std::string::npos ) {
               ATH_MSG_DEBUG("#BTAG# Build DL1 NN config for tagger " << tagger << " and jet collection " << channel << " and write it in condition data");
               TObjString* cal_string = dynamic_cast<TObjString*>(hPointer.get());
               std::istringstream nn_config_sstream(cal_string->GetString().Data());
               lwt::JSONConfig nn_config = lwt::parse_json(nn_config_sstream);
               ATH_MSG_DEBUG("#BTAG# Layers size << " << nn_config.layers.size());
  
               writeCdo->addDL1NN(tagger, channel, nn_config);
             } else if ((tagger.find("MV2")!=std::string::npos ) or (tagger.find("SoftMu")!=std::string::npos ) or (tagger.find("MultiSV") !=std::string::npos)) {
                 ATH_MSG_DEBUG("#BTAG# Build BDT for tagger " << tagger << " and jet collection " << channel << " and write it in condition data");
                 TTree *tree = dynamic_cast<TTree*>(hPointer.get());
                 if (tree) {
                   ATH_MSG_DEBUG("#BTAG# The TTree to build the BDT for " << tagger<< " is valid");
                   auto bdt = std::make_unique<MVAUtils::BDT>(tree);
                   writeCdo->addBdt(tagger,channel,std::move(bdt));
                 }
                 TObjArray * toa = dynamic_cast<TObjArray*>(hPointer.get());
                 if (toa) {
                   ATH_MSG_DEBUG("#BTAG# The TObjArray to build the input variables of BDT for " << tagger<< " is valid");
                   toa->SetOwner (true);
                   std::vector<std::string> inputVars; inputVars.clear();
                   std::string commaSepVars="";
                   if (toa->GetEntries()>0) {
                     auto tos = dynamic_cast<TObjString*> (toa->At(0));
                     if (tos) {
                       commaSepVars=tos->GetString().Data();
                     }
                   }
                   while (commaSepVars.find(',')!=std::string::npos) {
                     inputVars.push_back(commaSepVars.substr(0,commaSepVars.find(',')));
                     commaSepVars.erase(0,commaSepVars.find(',')+1);
                   }
                   inputVars.push_back(commaSepVars);
                   ATH_MSG_DEBUG("#BTAG# inputVars.size()= "<< inputVars.size() <<" toa->GetEntries()= "<< toa->GetEntries() <<"commaSepVars= "<< commaSepVars);
                   for (unsigned int asv=0; asv<inputVars.size(); asv++) ATH_MSG_DEBUG("#BTAG# inputVar= "<< inputVars.at(asv));
                   writeCdo->addInputVars(tagger,fname,inputVars);
                 }
               } else if (tagger.find("RNNIP")!=std::string::npos) {
                 ATH_MSG_DEBUG("#BTAG# Build RNN config for tagger " << tagger << " and jet collection " << channel << " and write it in condition data");
                 TObjString* cal_string = dynamic_cast<TObjString*>(hPointer.get());
                 std::string calstring;
                 if (cal_string == 0){  //catch if no string was found
                   ATH_MSG_WARNING("can't retrieve calibration: " + hFullName);
                   calstring = std::string();
                 }
                 else {
                   calstring = cal_string->GetString().Data();
                 }
                 writeCdo->addIPRNN(tagger,channel,calstring);
               } else {
                 //The other ones are histograms
                 TH1* h = dynamic_cast<TH1*>(hPointer.get());
                 if (!h) {
                   ATH_MSG_WARNING("#BTAG# This object is not an histogram: " << hFullName);
                   continue;
                 }
                 h->SetDirectory(nullptr);
                 (void)hPointer.release();
                 if (tagger == "IP2D" || tagger == "IP3D" || tagger == "SV1") {
                   ATH_MSG_VERBOSE("#BTAG# Smoothing histogram " << hname << " ...");
                   smoothAndNormalizeHistogram(h, hname);
                 }
                 writeCdo->addHisto(i,fname, std::unique_ptr<TH1>(h));
               }
           } else {
             ATH_MSG_WARNING("#BTAG# TObject can not be loaded. Error: histogram "<<hFullName
                           <<" does not exist - you are probably using an old database tag");
           }
         } //end loop mapped alias
       } //end loop histograms
     } //end loop tagger
  
     // close the file
     pfile->Close();
  
     if(histoWriteHandle.record(rangeW,std::move(writeCdo)).isFailure()) {
       ATH_MSG_ERROR("#BTAG# Could not record vector of histograms maps " << histoWriteHandle.key()
                   << " with EventRange " << rangeW
               << " into Conditions Store");
       return StatusCode::FAILURE;
     }
     ATH_MSG_INFO("recorded new CDO " << histoWriteHandle.key() << " with range " << rangeW << " into Conditions Store");
               
     return StatusCode::SUCCESS;
   }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

 {
   // If we didn't find any symlinks to add, just return the collection
   // from the base class.  Otherwise, return the extended collection.
   if (!m_extendedExtraObjects.empty()) {
     return m_extendedExtraObjects;
   }
   return Algorithm::extraOutputDeps();
 }

◆ finalize()

StatusCode Analysis::JetTagCalibCondAlg::finalize ( )

overridevirtual

Definition at line 706 of file JetTagCalibCondAlg.cxx.

                                           {
     ATH_MSG_DEBUG("finalize " << name());
     return StatusCode::SUCCESS;
   }

◆ initialize()

StatusCode Analysis::JetTagCalibCondAlg::initialize ( )

overridevirtual

Definition at line 59 of file JetTagCalibCondAlg.cxx.

                                             {
     ATH_MSG_DEBUG("initialize " << name());
  
     // PoolSvc
     ATH_CHECK(service("PoolSvc",m_poolsvc));
   
     // Condition Handles
     ATH_CHECK( m_readKey.initialize() );
     ATH_CHECK( m_writeKey.initialize() );
  
     // Prepare histo maps:
     if (m_taggers.size() > 0) {
       ATH_MSG_DEBUG( "#BTAG# List of calibrated taggers");
       for(uint i=0;i<m_taggers.size();i++) {
         ATH_MSG_DEBUG("#BTAG# Tagger " << m_taggers[i] );
         std::vector<std::string> hvect;
         m_taggersHists.push_back(hvect);
       }
     }
     else {
       ATH_MSG_ERROR( "#BTAG# No taggers defined");
     }
  
     // List of channels:
     ATH_MSG_DEBUG( "#BTAG# Original channels " );
     
     for(uint i=0;i<m_originalChannels.size();i++) {
       ATH_MSG_DEBUG("#BTAG# Channel " << m_originalChannels[i] );
     }
  
     // Decode channel aliases
     if (m_channelAliases.size() > 0) {
       for (const std::string& alias : m_channelAliases) {
         const std::string::size_type delim = alias.find("->");
         if(delim == std::string::npos) {
           ATH_MSG_ERROR( "#BTAG# Unexpected format in channelAliases: " << alias);
         } else {
           ATH_MSG_DEBUG( "#BTAG# Calibration channel alias: " << alias.substr(0, delim) << " -> "
                       << alias.substr(delim+2) );
           std::string jetc= alias.substr(0, delim);
           std::vector<std::string> jeta = tokenize(alias.substr(delim+2), ",");
           m_channelAliasesMultiMap.insert(std::make_pair(jetc, jeta) );
           // Add to list of channels to which aliases will be attached
           // (necessary because getJetAuthor used in taggers does not use
           //  jet collection name but standardised info)
           if (std::find(m_originalChannels.begin(), m_originalChannels.end(),jetc)
                        == m_originalChannels.end()) m_originalChannels.push_back(jetc);
         }
       }
     }
     else {
       ATH_MSG_ERROR( "#BTAG# No channel aliases defined");
     }
  
     m_directoryMap.clear();
  
     //IP taggers
     if (std::find(m_taggers.begin(), m_taggers.end(), "IP2D") != m_taggers.end() or
       std::find(m_taggers.begin(), m_taggers.end(), "IP3D") != m_taggers.end() or
       std::find(m_taggers.begin(), m_taggers.end(), "SV1") != m_taggers.end()) {
         initializeIPTag();
     }
  
     //IP2D tagger
     if (std::find(m_taggers.begin(), m_taggers.end(), "IP2D") != m_taggers.end()) {
       initializeIP2D();
     }
  
     //IP3D tagger
     if (std::find(m_taggers.begin(), m_taggers.end(), "IP3D") != m_taggers.end()) {
       initializeIP3D();
     }
  
     //SV1 tagger
     if (std::find(m_taggers.begin(), m_taggers.end(), "SV1") != m_taggers.end()) {
       initializeSV1();
     }
  
     //SV2 tagger
     if (std::find(m_taggers.begin(), m_taggers.end(), "SV2") != m_taggers.end()) {
       initializeSV2();
     }
  
     //JetFitterNN tagger
     if (std::find(m_taggers.begin(), m_taggers.end(), "JetFitterNN") != m_taggers.end()) {
       initializeJetFitterNN();
     }
  
  
     //SoftMu tagger
     if (std::find(m_taggers.begin(), m_taggers.end(), "SoftMu") != m_taggers.end()) {
       initializeSoftMu();
     }
  
     //MV2c10 tagger
     if (std::find(m_taggers.begin(), m_taggers.end(), "MV2c10") != m_taggers.end()) {
       initializeMV2("MV2c10");
     }
  
     //MV2cl100 tagger
     if (std::find(m_taggers.begin(), m_taggers.end(), "MV2cl100") != m_taggers.end()) {
       initializeMV2("MV2cl100");
     }
  
     //MV2c100 tagger
     if (std::find(m_taggers.begin(), m_taggers.end(), "MV2c100") != m_taggers.end()) {
       initializeMV2("MV2c100");
     }
  
     //MV2c10mu tagger
     if (std::find(m_taggers.begin(), m_taggers.end(), "MV2c10mu") != m_taggers.end()) {
       initializeMV2("MV2c10mu");
     }
  
     //MV2c10rnn tagger
     if (std::find(m_taggers.begin(), m_taggers.end(), "MV2c10rnn") != m_taggers.end()) {
       initializeMV2("MV2c10rnn");
     }
    
     //RNNIP tagger
     if (std::find(m_taggers.begin(), m_taggers.end(), "RNNIP") != m_taggers.end()) {
       initializeRNNIP();
     }
  
     //MultiSV tagger
     if (std::find(m_taggers.begin(), m_taggers.end(), "MultiSVbb1") != m_taggers.end()) {
       initializeMultiSV("MultiSVbb1");
     }
  
     //MultiSV tagger
     if (std::find(m_taggers.begin(), m_taggers.end(), "MultiSVbb2") != m_taggers.end()) {
       initializeMultiSV("MultiSVbb2");
     }
  
     //Dl1 taggers
     if (std::find(m_taggers.begin(), m_taggers.end(), "DL1") != m_taggers.end()) {
       initializeDL1("DL1");
     }
  
     if (std::find(m_taggers.begin(), m_taggers.end(), "DL1mu") != m_taggers.end()) {
       initializeDL1("DL1mu");
     }
  
     if (std::find(m_taggers.begin(), m_taggers.end(), "DL1rnn") != m_taggers.end()) {
       initializeDL1("DL1rnn");
     }
  
     return StatusCode::SUCCESS;
   }

◆ initializeDL1()

void Analysis::JetTagCalibCondAlg::initializeDL1 ( const std::string & taggerNameBase )

private

Definition at line 386 of file JetTagCalibCondAlg.cxx.

   {
     m_DL1_file_name = "net_configuration"; // directory of NN calibration (starting from specific jet collection directory) in COOL db
     this->registerHistogram(taggerNameBase, m_DL1_file_name);  //register the calibration file for later access
  
     ATH_MSG_DEBUG(" #BTAG# Registered NN histograms with directory: " << taggerNameBase);
   }

◆ initializeIP2D()

void Analysis::JetTagCalibCondAlg::initializeIP2D ( )

private

Definition at line 219 of file JetTagCalibCondAlg.cxx.

                                           {
     ATH_MSG_DEBUG("initialize IP2D paths of the calibration file");
  
     //check that hypotheses for likelihood tool are defined
     std::string hName;
     for(unsigned int i=0;i<m_IP2D_trackGradePartitions.size();i++) {
       for(unsigned int ih=0;ih<m_IPTag_hypotheses.size();ih++) {
         hName = m_IPTag_hypotheses[ih]+"/"+m_IP2D_trackGradePartitions[i]+"/SipA0";
         registerHistogram("IP2D", hName);          
       }
     }
   }

◆ initializeIP3D()

void Analysis::JetTagCalibCondAlg::initializeIP3D ( )

private

Definition at line 233 of file JetTagCalibCondAlg.cxx.

                                           {
     ATH_MSG_DEBUG("initialize IP3D paths of the calibration file");
  
     //check that hypotheses for likelihood tool are defined
     std::string hName;
     for(unsigned int i=0;i<m_IP2D_trackGradePartitions.size();i++) {
       for(unsigned int ih=0;ih<m_IPTag_hypotheses.size();ih++) {
         hName = m_IPTag_hypotheses[ih]+"/"+m_IP2D_trackGradePartitions[i]+"/Sip3D";
         registerHistogram("IP3D", hName);          
       }
     }
   }

◆ initializeIPTag()

void Analysis::JetTagCalibCondAlg::initializeIPTag ( )

private

Definition at line 210 of file JetTagCalibCondAlg.cxx.

                                            {
     ATH_MSG_DEBUG("initialize IPTag paths of the calibration file");
      m_IPTag_hypotheses.push_back("B");
      m_IPTag_hypotheses.push_back("U");
      if(m_IPTag_useCHypo){
        m_IPTag_hypotheses.push_back("C");
      }
   }

◆ initializeJetFitterNN()

void Analysis::JetTagCalibCondAlg::initializeJetFitterNN ( )

private

Definition at line 300 of file JetTagCalibCondAlg.cxx.

   {
     
     TString directory(m_JetFitterNN_calibrationSubDirectory);
     directory+="/";
     if (m_JetFitterNN_useCombinedIPNN)
     {
       directory+="comb";
     }
     else
     {
       directory+="standalone";
     }
     directory+="/";
     
     this->registerHistogram("JetFitterNN", m_JetFitterNN_calibrationDirectory,
                                          std::string((const char*)(directory+"LayersInfo")));
     
     Int_t nHidden=m_JetFitterNN_maximumRegisteredLayers-2;
     
     for (Int_t i=0;i<nHidden+1;++i)
     {
       
       TString weightName("Layer");
       weightName+=i;
       weightName+="_weights";
       
       TString thresholdName("Layer");
       thresholdName+=i;
       thresholdName+="_thresholds";
       
       this->registerHistogram("JetFitterNN", m_JetFitterNN_calibrationDirectory,
                                            std::string((const char*)(directory+weightName)));
       
       this->registerHistogram("JetFitterNN", m_JetFitterNN_calibrationDirectory,
                                            std::string((const char*)(directory+thresholdName)));
     }
     ATH_MSG_DEBUG(" Registered NN histograms with directory: " << m_JetFitterNN_calibrationDirectory << " and subdirectory " << directory);
  
   }

◆ initializeMultiSV()

void Analysis::JetTagCalibCondAlg::initializeMultiSV ( const std::string & taggerNameBase )

private

Definition at line 376 of file JetTagCalibCondAlg.cxx.

   {
     ATH_MSG_DEBUG("#BTAG# taggerNameBase " << taggerNameBase);
     std::string treeName = "BDT";
     std::string varStrName = "variables";
     this->registerHistogram(taggerNameBase, taggerNameBase+"Calib");
     this->registerHistogram(taggerNameBase, taggerNameBase+"Calib/"+treeName);
     this->registerHistogram(taggerNameBase, taggerNameBase+"Calib/"+varStrName);
   }

◆ initializeMV2()

void Analysis::JetTagCalibCondAlg::initializeMV2 ( const std::string & taggerNameBase )

private

Definition at line 353 of file JetTagCalibCondAlg.cxx.

   {
     std::string treeName("BDT");
     std::string varStrName("variables");
     ATH_MSG_DEBUG("#BTAG# Folder I look into: "<< taggerNameBase+"Calib/"+treeName);
  
     this->registerHistogram(taggerNameBase, taggerNameBase+"Calib");
     this->registerHistogram(taggerNameBase, taggerNameBase+"Calib/"+treeName);
     this->registerHistogram(taggerNameBase, taggerNameBase+"Calib/"+varStrName);
   }

◆ initializeRNNIP()

void Analysis::JetTagCalibCondAlg::initializeRNNIP ( )

private

Definition at line 364 of file JetTagCalibCondAlg.cxx.

   {
     for (const auto& rnn_name_pair: m_RNNIP_network_cfg) {
       if (rnn_name_pair.second.size() == 0) {
         ATH_MSG_VERBOSE("registering RNN " << rnn_name_pair.first);
         this->registerHistogram("RNNIP",rnn_name_pair.first);
         ATH_MSG_DEBUG(" #BTAG# Registered NN histograms with directory: " <<
           "RNNIP");
       }
     }
   }

◆ initializeSoftMu()

void Analysis::JetTagCalibCondAlg::initializeSoftMu ( )

private

Definition at line 342 of file JetTagCalibCondAlg.cxx.

   {
     std::string taggerNameBase("SMT");
     std::string treeName("BDT");
     std::string varStrName("variables");
     ATH_MSG_DEBUG("#BTAG# Folder I look into: "<< taggerNameBase+"Calib/"+treeName);
     this->registerHistogram("SoftMu", taggerNameBase, taggerNameBase+"Calib/"+treeName);
     this->registerHistogram("SoftMu", taggerNameBase, taggerNameBase+"Calib/"+varStrName);
   } 

◆ initializeSV1()

void Analysis::JetTagCalibCondAlg::initializeSV1 ( )

private

Definition at line 258 of file JetTagCalibCondAlg.cxx.

                                          {
     ATH_MSG_DEBUG("initialize SV1 paths of the calibration file");
  
     std::string hName;
     for(unsigned int ih=0;ih<m_IPTag_hypotheses.size();ih++) {
       hName = m_IPTag_hypotheses[ih]+"/N2T";
       registerHistogram("SV1", hName);
       hName = m_IPTag_hypotheses[ih]+"/BidimME";
       registerHistogram("SV1", hName);
         if(m_useDRJPVSV) {
           hName = m_IPTag_hypotheses[ih]+"/DRJPVSV";
           registerHistogram("SV1", hName);
       }
     }
  
     this->initializeSVEff("SV1");
   }

◆ initializeSV2()

void Analysis::JetTagCalibCondAlg::initializeSV2 ( )

private

Definition at line 276 of file JetTagCalibCondAlg.cxx.

                                          {
     ATH_MSG_DEBUG("initialize SV2 paths of the calibration file");
  
     this->initializeIPTag();
  
     std::string hName;
     if(m_usePtSV2){
       for(unsigned int ih=0;ih<m_IPTag_hypotheses.size();ih++) {
         hName = m_IPTag_hypotheses[ih]+"/TridimMENPt";
         registerHistogram("SV2", hName);
         hName = m_IPTag_hypotheses[ih]+"/N2TEffSV2";
         registerHistogram("SV2", hName);
        }
     }else{
       for(unsigned int ih=0;ih<m_IPTag_hypotheses.size();ih++) {
         hName = m_IPTag_hypotheses[ih]+"/TridimMEN2T";
         registerHistogram("SV2", hName);
       }
     }
  
     this->initializeSVEff("SV2");
   }

◆ initializeSVEff()

void Analysis::JetTagCalibCondAlg::initializeSVEff ( const std::string & SVmode )

private

Definition at line 246 of file JetTagCalibCondAlg.cxx.

                                                                   {
     // for SV efficiencies, add a few histograms:
     std::string hName;
     for(unsigned int ih=0;ih<m_IPTag_hypotheses.size();ih++) {
     hName = m_IPTag_hypotheses[ih]+"/N2TEff"+SVmode;
         registerHistogram(SVmode, hName);
     hName = m_IPTag_hypotheses[ih]+"/N2TNorm"+SVmode;
         registerHistogram(SVmode, hName);
     }
   }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ msg() [1/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                                {
     return this->msgLevel(lvl);
   }

◆ objectTDirExists()

StatusCode Analysis::JetTagCalibCondAlg::objectTDirExists	(	const std::string &	histname,
		TFile *	file
	)		const

private

Definition at line 711 of file JetTagCalibCondAlg.cxx.

                                                                                                 {
     
     ATH_MSG_DEBUG("#BTAG# in objectTDirExists" );
  
      // now read the histogram into memory
      ATH_MSG_DEBUG("Getting object "+histname+" from file");
      TObject* hist = nullptr;
      pfile->GetObject(histname.c_str(),hist);
      if (hist==nullptr) {
        ATH_MSG_DEBUG("#BTAG# Could not load TObject " << histname);
        return StatusCode::FAILURE;
      }
  
      return StatusCode::SUCCESS;
   }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ registerHistogram() [1/2]

void Analysis::JetTagCalibCondAlg::registerHistogram	(	const std::string &	tagger,
		const std::string &	directory,
		const std::string &	histoname
	)

private

Definition at line 399 of file JetTagCalibCondAlg.cxx.

                                                                                                                         {
     ATH_MSG_DEBUG(  "#BTAG# registering histogram " << hname << " in tagger " << tagger );
     m_directoryMap[tagger] = directory;
     bool registered = false;
     for(uint i=0;i<m_taggers.size();i++) {
       if(tagger==m_taggers[i]) {
         ATH_MSG_DEBUG( "#BTAG# tagger " << tagger << " found in pos " << i
                        << " , registrating " << hname );
  
         m_taggersHists[i].push_back(hname);
         registered = true;
       }
     }
     if(!registered) {
       ATH_MSG_DEBUG( "#BTAG# tagger " << tagger << " not found."
                      << " Registrating of " << hname << " not possible.");
     }
   }

◆ registerHistogram() [2/2]

void Analysis::JetTagCalibCondAlg::registerHistogram	(	const std::string &	tagger,
		const std::string &	histoname
	)

private

Definition at line 394 of file JetTagCalibCondAlg.cxx.

                                                                                             {
     std::string dir(tagger);
     this->registerHistogram(tagger,dir,hname);
   }

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

   {
     h.renounce();
     PBASE::renounce (h);
   }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                           {
     handlesArray.renounce();
   }

◆ smoothAndNormalizeHistogram()

void Analysis::JetTagCalibCondAlg::smoothAndNormalizeHistogram	(	TH1 *	h,
		const std::string &	hname
	)

private

Definition at line 727 of file JetTagCalibCondAlg.cxx.

                                                                                      {
     //Select small part of NewLikelihoodTool to reproduce CalibrationBroker behaviour (smooth and normalize histogram)
     if(h) {
       double norm = h->Integral();
       if(norm) {
         // check if smoothing of histogram is not vetoed:
         bool veto = false;
         for(unsigned int iv=0; iv<m_Likelihood_vetoSmoothingOf.size(); iv++) {
           if(hname.find(m_Likelihood_vetoSmoothingOf[iv])!=std::string::npos) {
             veto = true;
             ATH_MSG_VERBOSE("#BTAG# Smoothing of " << hname << " is vetoed !");
             break;
           }
         }
         if(1==h->GetDimension() && m_Likelihood_smoothNTimes) {
           if(!veto) {
             if(norm>10000)h->Smooth(m_Likelihood_smoothNTimes);
             else h->Smooth((int)(m_Likelihood_smoothNTimes*100./sqrt(norm)));
           }
         }
         if(2==h->GetDimension()) {
           int m2d=3;
           if(!veto) {
         TH2 * dc_tmp = dynamic_cast<TH2*>(h);
         if (dc_tmp) {
               this->smoothASH2D(dc_tmp, m2d, m2d);
             }
           }
         }
         if(3==h->GetDimension()) {
           ATH_MSG_WARNING("#BTAG# Code needs to be migrated from NewLikelihoodTool");
         }
         // normalize:
         norm = h->Integral();
         h->Scale(1./norm);
       } else {
         ATH_MSG_DEBUG("#BTAG# Histo "<<h<<" is empty!");
       }
     }
   }

◆ smoothASH2D()

void Analysis::JetTagCalibCondAlg::smoothASH2D	(	TH2 *	input2D,
		int	m1,
		int	m2
	)

private

Definition at line 768 of file JetTagCalibCondAlg.cxx.

                                                                  {
  
   ATH_MSG_DEBUG("Smoothing a two dimensional histogram "<< input2D->GetName()
               << " " << m1 << " " << m2);
   ATH_MSG_DEBUG("First (1-3, 1-3) 3x3 bins before smoothing: ");
   for(int i=1;i<4;i++) {
     for(int j=1;j<4;j++) {
       ATH_MSG_DEBUG(i<<" "<<j<<" : "<<input2D->GetBinContent(i,j)<< " / ");
     }
   }
   int ioffset = input2D->GetNbinsX() / 2 ;
   int joffset = input2D->GetNbinsY() / 2 ;
   ATH_MSG_DEBUG("Middle (" << ioffset+1 << "-" << ioffset+4 << ", ("
               << joffset+1 << "-" << joffset+4 << ") 3x3 bins before smoothing: ");
   for(int i=1;i<4;i++) {
     for(int j=1;j<4;j++) {
       ATH_MSG_DEBUG(i<<" "<<j<<" : "<<input2D->GetBinContent(i+ioffset,j+joffset)<< " / ");
     }
   }
  
   //
   const int lsup = 20;
   if (m1 > lsup || m2 > lsup) {
     ATH_MSG_DEBUG("HistoHelperRoot::smoothASH2D: m1 or m2 too big !");
     return;
   } else {
     int nx = input2D->GetNbinsX()+1;
     int ny = input2D->GetNbinsY()+1;
     float **h, **res;
     h   = new float*[nx-1];
     res = new float*[nx-1];
     for (int i = 0;i < nx-1;i++) {
       h[i]   = new float[ny-1];
       res[i] = new float[ny-1];
     }
     for (int iy = 1;iy<ny;iy++) {
       for (int ix = 1;ix<nx;ix++) {
         h[ix-1][iy-1] = (float) input2D->GetBinContent(ix,iy);
       }
     }
     //
     int i,j,k,l;
     float wk1[41],wk2[41],wgt[100][100];
     double wk[41][41],wks = 0.;
     float ai,am1 = float(m1), am2 = float(m2);
     const float am12 = am1*am1, am22 = am2*am2;
     const float inv_am1_am2 = 1. / (am1 * am2);
     const float inv_am12 = 1. / am12;
     const float inv_am22 = 1. / am22;
     // Initialisation
     for (k = 0;k<nx-1;k++) {
       for (l = 0;l<ny-1;l++) {
         res[k][l] = 0.; wgt[k][l] = 0.;
       }
     }
     // Weights
     for (i = lsup+1-m1;i<lsup+m1;i++) {
       ai = float(i-lsup)*float(i-lsup);
       wk1[i] = 15./16.*(1.-ai*inv_am12)*(1.-ai*inv_am12);
       wks = wks + wk1[i];
     }
     const double fac1 = am1 / wks;
     for (i = lsup+1-m1;i<lsup+m1;i++) {
       wk1[i] =  wk1[i]*fac1;
     }
     wks = 0.;
     for (i = lsup+1-m2;i<lsup+m2;i++) {
       ai = float(i-lsup)*float(i-lsup);
       wk2[i] = 15./16.*(1.-ai*inv_am22)*(1.-ai*inv_am22);
       wks = wks + wk2[i];
     }
     const double fac2 = am2 / wks;
     for (i = lsup+1-m2;i<lsup+m2;i++) {
       wk2[i] =  wk2[i]*fac2;
     }
     for (i = lsup+1-m1;i<lsup+m1;i++) {
       for (j = lsup+1-m2;j<lsup+m2;j++) {
         wk[i][j] = wk1[i]*wk2[j];
       }
     }
     //
     for (k = 0;k<nx-1;k++) {
       for (l = 0;l<ny-1;l++) {
         for (i = std::max(0,k-m1+1);i<std::min(nx-1,k+m1);i++) {
           for (j = std::max(0,l-m2+1);j<std::min(ny-1,l+m2);j++) {
             res[i][j] = res[i][j] + wk[lsup+i-k][lsup+j-l]*h[k][l];
             wgt[i][j] = wgt[i][j] + wk[lsup+i-k][lsup+j-l];
           }
         }
       }
     }
     for (k = 0;k<nx-1;k++) {
       for (l = 0;l<ny-1;l++) {
         res[k][l] = res[k][l]*inv_am1_am2;
         if (wgt[k][l] != 0.) {res[k][l] = res[k][l]/wgt[k][l];}
       }
     }
     // replace the histo content with the result of smoothing:
     input2D->Reset();
     for (int iy = 1;iy<ny;iy++) {
       for (int ix = 1;ix<nx;ix++) {
         input2D->SetBinContent(ix,iy,res[ix-1][iy-1]);
       }
     }
     for (i = 0; i < nx-1; i++){
       delete[] h[i];
       delete[] res[i];
     }
     delete[] h;
     delete[] res;
   }
   ATH_MSG_DEBUG("First (1-3, 1-3) 3x3 bins after smoothing: ");
   for(int i=1;i<4;i++) {
     for(int j=1;j<4;j++) {
       ATH_MSG_DEBUG(i<<" "<<j<<" : "<<input2D->GetBinContent(i,j)<< " / ");
     }
   }
   ioffset = input2D->GetNbinsX() / 2 ;
   joffset = input2D->GetNbinsY() / 2 ;
   ATH_MSG_DEBUG("Middle (" << ioffset+1 << "-" << ioffset+4 << ", ("
               << joffset+1 << "-" << joffset+4 << ") 3x3 bins after smoothing: ");
   for(int i=1;i<4;i++) {
     for(int j=1;j<4;j++) {
       ATH_MSG_DEBUG(i<<" "<<j<<" : "<<input2D->GetBinContent(i+ioffset,j+joffset)<< " / ");
     }
   }
 }

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, PyAthena::Alg, and AthHistogramAlgorithm.

Definition at line 66 of file AthAlgorithm.cxx.

                                        {
   StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
  
   if (sc.isFailure()) {
     return sc;
   }
   ServiceHandle<ICondSvc> cs("CondSvc",name());
   for (auto h : outputHandles()) {
     if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
       // do this inside the loop so we don't create the CondSvc until needed
       if ( cs.retrieve().isFailure() ) {
         ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
         return StatusCode::SUCCESS;
       }
       if (cs->regHandle(this,*h).isFailure()) {
         sc = StatusCode::FAILURE;
         ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                       << " with CondSvc");
       }
     }
   }
   return sc;
 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ tokenize()

std::vector< std::string > Analysis::JetTagCalibCondAlg::tokenize	(	const std::string &	str,
		const std::string &	delim
	)

private

Definition at line 689 of file JetTagCalibCondAlg.cxx.

                                                                                                {
     std::vector<std::string> tokens;
     std::string::size_type sPos, sEnd, sLen;
     // if str starts with a character in delim, do you want an empty string in tokens?
     // sPos = 0; // if answer is yes
     sPos = str.find_first_not_of(delim);  // if answer is no
     while(sPos != std::string::npos){
       sEnd = str.find_first_of(delim, sPos);
       if(sEnd == std::string::npos) sEnd = str.length();
       sLen = sEnd - sPos;
       std::string token = str.substr(sPos, sLen);
       tokens.push_back(token);
       sPos = str.find_first_not_of(delim, sEnd);
     }
     return tokens;
   }

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                                {
     // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
     //         << "  size: " << m_vhka.size() << endmsg;
     for (auto &a : m_vhka) {
       std::vector<SG::VarHandleKey*> keys = a->keys();
       for (auto k : keys) {
         k->setOwner(this);
       }
     }
   }

Member Data Documentation

◆ m_channelAliases

StringArrayProperty Analysis::JetTagCalibCondAlg::m_channelAliases

private

Definition at line 95 of file JetTagCalibCondAlg.h.

◆ m_channelAliasesMultiMap

std::map< std::string, std::vector<std::string> > Analysis::JetTagCalibCondAlg::m_channelAliasesMultiMap

private

Definition at line 96 of file JetTagCalibCondAlg.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_directoryMap

std::unordered_map<std::string,std::string> Analysis::JetTagCalibCondAlg::m_directoryMap

private

Definition at line 88 of file JetTagCalibCondAlg.h.

◆ m_DL1_file_name

std::string Analysis::JetTagCalibCondAlg::m_DL1_file_name

private

Definition at line 122 of file JetTagCalibCondAlg.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_IP2D_trackGradePartitions

std::vector< std::string > Analysis::JetTagCalibCondAlg::m_IP2D_trackGradePartitions

private

Definition at line 103 of file JetTagCalibCondAlg.h.

◆ m_IPTag_hypotheses

std::vector<std::string> Analysis::JetTagCalibCondAlg::m_IPTag_hypotheses

private

Definition at line 100 of file JetTagCalibCondAlg.h.

◆ m_IPTag_useCHypo

bool Analysis::JetTagCalibCondAlg::m_IPTag_useCHypo

private

Definition at line 99 of file JetTagCalibCondAlg.h.

◆ m_JetFitterNN_calibrationDirectory

std::string Analysis::JetTagCalibCondAlg::m_JetFitterNN_calibrationDirectory

private

Definition at line 116 of file JetTagCalibCondAlg.h.

◆ m_JetFitterNN_calibrationSubDirectory

std::string Analysis::JetTagCalibCondAlg::m_JetFitterNN_calibrationSubDirectory

private

Definition at line 117 of file JetTagCalibCondAlg.h.

◆ m_JetFitterNN_maximumRegisteredLayers

int Analysis::JetTagCalibCondAlg::m_JetFitterNN_maximumRegisteredLayers

private

Definition at line 119 of file JetTagCalibCondAlg.h.

◆ m_JetFitterNN_useCombinedIPNN

bool Analysis::JetTagCalibCondAlg::m_JetFitterNN_useCombinedIPNN

private

Definition at line 118 of file JetTagCalibCondAlg.h.

◆ m_Likelihood_smoothNTimes

int Analysis::JetTagCalibCondAlg::m_Likelihood_smoothNTimes

private

Definition at line 112 of file JetTagCalibCondAlg.h.

◆ m_Likelihood_vetoSmoothingOf

std::vector<std::string> Analysis::JetTagCalibCondAlg::m_Likelihood_vetoSmoothingOf

private

Definition at line 113 of file JetTagCalibCondAlg.h.

◆ m_mappedAlias

std::vector< std::string > Analysis::JetTagCalibCondAlg::m_mappedAlias

private

Definition at line 90 of file JetTagCalibCondAlg.h.

◆ m_originalChannels

std::vector< std::string > Analysis::JetTagCalibCondAlg::m_originalChannels

private

Definition at line 91 of file JetTagCalibCondAlg.h.

◆ m_poolsvc

IPoolSvc* Analysis::JetTagCalibCondAlg::m_poolsvc

private

Definition at line 84 of file JetTagCalibCondAlg.h.

◆ m_readKey

SG::ReadCondHandleKey<CondAttrListCollection> Analysis::JetTagCalibCondAlg::m_readKey {this, "ReadKeyCalibPath", "/GLOBAL/BTagCalib/RUN12", "Key of input (raw) conditions folder of bration path"}

private

Definition at line 81 of file JetTagCalibCondAlg.h.

◆ m_RNNIP_network_cfg

std::map<std::string, std::string > Analysis::JetTagCalibCondAlg::m_RNNIP_network_cfg

private

Definition at line 129 of file JetTagCalibCondAlg.h.

◆ m_taggers

std::vector< std::string > Analysis::JetTagCalibCondAlg::m_taggers

private

Definition at line 87 of file JetTagCalibCondAlg.h.

◆ m_taggersHists

std::vector<std::vector<std::string> > Analysis::JetTagCalibCondAlg::m_taggersHists

private

Definition at line 89 of file JetTagCalibCondAlg.h.

◆ m_useDRJPVSV

bool Analysis::JetTagCalibCondAlg::m_useDRJPVSV

private

Definition at line 106 of file JetTagCalibCondAlg.h.

◆ m_usePtSV2

bool Analysis::JetTagCalibCondAlg::m_usePtSV2

private

Definition at line 109 of file JetTagCalibCondAlg.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_writeKey

SG::WriteCondHandleKey<JetTagCalibCondData> Analysis::JetTagCalibCondAlg::m_writeKey {this, "HistosKey", "JetTagCalibHistosKey", "Key of output (derived) JetTag calibration data"}

private

Definition at line 82 of file JetTagCalibCondAlg.h.

The documentation for this class was generated from the following files:

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ JetTagCalibCondAlg()

◆ ~JetTagCalibCondAlg()

Member Function Documentation

◆ createHistoMap()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ finalize()

◆ initialize()

◆ initializeDL1()

◆ initializeIP2D()

◆ initializeIP3D()

◆ initializeIPTag()

◆ initializeJetFitterNN()

◆ initializeMultiSV()

◆ initializeMV2()

◆ initializeRNNIP()

◆ initializeSoftMu()

◆ initializeSV1()

◆ initializeSV2()

◆ initializeSVEff()

◆ inputHandles()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ objectTDirExists()

◆ outputHandles()

◆ registerHistogram() [1/2]

◆ registerHistogram() [2/2]

◆ renounce()

◆ renounceArray()

◆ smoothAndNormalizeHistogram()

◆ smoothASH2D()

◆ sysInitialize()

◆ sysStart()

◆ tokenize()

◆ updateVHKA()

Member Data Documentation

◆ m_channelAliases

◆ m_channelAliasesMultiMap

◆ m_detStore

◆ m_directoryMap

◆ m_DL1_file_name

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_IP2D_trackGradePartitions

◆ m_IPTag_hypotheses

◆ m_IPTag_useCHypo

◆ m_JetFitterNN_calibrationDirectory

◆ m_JetFitterNN_calibrationSubDirectory

◆ m_JetFitterNN_maximumRegisteredLayers

◆ m_JetFitterNN_useCombinedIPNN

◆ m_Likelihood_smoothNTimes

◆ m_Likelihood_vetoSmoothingOf

◆ m_mappedAlias

◆ m_originalChannels

◆ m_poolsvc

◆ m_readKey