#include <LikelihoodMultiDTool.h>

Inheritance diagram for Analysis::LikelihoodMultiDTool:

Collaboration diagram for Analysis::LikelihoodMultiDTool:

Public Member Functions
	LikelihoodMultiDTool (const std::string &, const std::string &, const IInterface *)
virtual	~LikelihoodMultiDTool ()
StatusCode	initialize ()
	AlgTool initailize method.
StatusCode	finalize ()
	AlgTool finalize method.
void	prepareHistosFromFile (const std::string &refFileName)
TH1 *	retrieveHistoFromFile (const std::string &refFileName, const std::string &histoName, const std::string &jetPrefix)
void	setLhVariableValue (std::vector< Slice > &value)
void	setLhVariableValue (Slice &value)
std::vector< double >	calculateLikelihood ()
const std::vector< double > &	tagLikelihood ()
void	printStatus ()
double	getEff (const std::string &, const std::string &, const std::string &)
void	addLhVariableToUse (const std::string &)
void	resetLhVariableToUse ()
void	setInterpolFlag (bool f)
void	defineNbHypotheses (int n)
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
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.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ITHistSvc *	m_histoSvc
std::vector< std::string >	m_useTheseLhVariables
	names of lh variables which one wants to use (subset of m_allLhVariables)
std::vector< std::map< std::string, TH1 * > * >	m_mapOfAllHistos
	For every histogram input file this vector contains a map with the names of the histograms as a key and the pointer to the histograms.
std::map< std::string, HistoLimits >	m_histoLimitsMap1D
	To hold the histo limits.
std::map< std::string, HistoLimits >	m_histoLimitsMap2D
std::map< std::string, HistoLimits >	m_histoLimitsMap3D
std::vector< Slice >	m_lhVariableValues
	Contains the value of the likelihood variable with the key std::string.
std::vector< double >	m_likelihoodVector
	Contains the combined likelihood for each input file category.
int	m_nhis1D
	for debugging:
int	m_nhis2D
int	m_nhis3D
bool	m_DoInterpol
bool	m_WriteSmoothedHistos
unsigned int	m_nbHypotheses
int	m_nSmooth1D
bool	m_normProb
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 30 of file LikelihoodMultiDTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ LikelihoodMultiDTool()

Analysis::LikelihoodMultiDTool::LikelihoodMultiDTool	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p )

Definition at line 25 of file LikelihoodMultiDTool.cxx.

                                                                                                        :
    AthAlgTool(t,n,p),
    m_histoSvc(0),
    //m_allLhVariables(std::vector<std::string>()),
    m_useTheseLhVariables(std::vector<std::string>()),
    m_mapOfAllHistos(std::vector<std::map<std::string, TH1*>* >()),
    m_histoLimitsMap1D(std::map< std::string, HistoLimits>() ),
    m_histoLimitsMap2D(std::map< std::string, HistoLimits>() ),
    m_histoLimitsMap3D(std::map< std::string, HistoLimits>() ),
    m_lhVariableValues(std::vector<Slice> ()),
    m_likelihoodVector(std::vector<double>()),
    m_nhis1D(0),
    m_nhis2D(0),
    m_nhis3D(0),
    m_DoInterpol(false),
    m_WriteSmoothedHistos(false),
    m_nbHypotheses(2),
    m_nSmooth1D(1),
    m_normProb(true)
  {
    declareInterface<LikelihoodMultiDTool>(this);
    declareProperty("WriteSmoothedHistos", m_WriteSmoothedHistos);
    declareProperty("NSmooth1D",           m_nSmooth1D);
    declareProperty("NormalizeProb",       m_normProb);
  }

◆ ~LikelihoodMultiDTool()

Analysis::LikelihoodMultiDTool::~LikelihoodMultiDTool ( )

virtual

Definition at line 51 of file LikelihoodMultiDTool.cxx.

  {
    for (std::vector< std::map<std::string, TH1*>* >::iterator itr = m_mapOfAllHistos.begin();
     itr != m_mapOfAllHistos.end(); ++itr)   delete (*itr);
  }

Member Function Documentation

◆ addLhVariableToUse()

void Analysis::LikelihoodMultiDTool::addLhVariableToUse ( const std::string & var )

Definition at line 466 of file LikelihoodMultiDTool.cxx.

                                                                    {
    m_useTheseLhVariables.push_back(var);
  }

◆ calculateLikelihood()

std::vector< double > Analysis::LikelihoodMultiDTool::calculateLikelihood ( )

Definition at line 263 of file LikelihoodMultiDTool.cxx.

                                                              {
    m_likelihoodVector.clear();
    std::vector<double> probDensityPerEventClassAllVariables;
    ATH_MSG_VERBOSE("The sizes of the maps "<<m_mapOfAllHistos.size()<<" "<<m_nbHypotheses);
    probDensityPerEventClassAllVariables.resize(m_nbHypotheses);
    for (unsigned int i = 0 ; i < m_nbHypotheses; ++i) {
      probDensityPerEventClassAllVariables[i]=1.;
    }
 
    // Loop on Tracks in the Jet (IP) / Vertices in the Jet (SV)
    for (unsigned int iel = 0; iel<m_lhVariableValues.size(); iel++) {
      int ncompo = m_lhVariableValues[iel].composites.size();
      ATH_MSG_VERBOSE("-- element "<<iel<<" "<<m_lhVariableValues[iel].name<<" has "<<ncompo<<" composites.");
      // Loop on variables that make up the Tag, e.g. 
      // one 1D for IP2D, one 2D for IP3D, one 1D and one 2D for SV1, one 3D for SV2
      for (int icompo = 0;icompo<ncompo;icompo++) {
    double sum(0.);
    std::vector<double> tmpVector; 
    std::string histName = m_lhVariableValues[iel].composites[icompo].name;
    int idim = m_lhVariableValues[iel].composites[icompo].atoms.size();
    ATH_MSG_VERBOSE("  -- composite "<<icompo<<" histo= "<<histName<<" dim= "<<idim);
    if (idim == 1) {
      const HistoLimits& histoLimits = (*(m_histoLimitsMap1D.find(histName))).second;
      // Loop on Hypotheses : b or light for the time being... 
      for (std::vector< std::map<std::string, TH1*>* >::iterator
         itr2 = m_mapOfAllHistos.begin() ;
           itr2 != m_mapOfAllHistos.end() ; ++itr2 ) {
        if( (*itr2)->find(histName) != (*itr2)->end() ) {
          TH1* tmpHisto = (*((*itr2)->find(histName))).second;
          double value = m_lhVariableValues[iel].composites[icompo].atoms[0].value;
          int bin((tmpHisto->GetXaxis())->FindBin(value));
          double tmp(0);
          if(!m_DoInterpol) {
        if(value>= histoLimits.xmax) bin = histoLimits.bins;
        if(value<= histoLimits.xmin) bin = 1;
        tmp = tmpHisto->GetBinContent(bin);
          }
          else {
        tmp = HistoHelperRoot::Interpol1d(value,dynamic_cast<TH1*>(tmpHisto));
          }
          ATH_MSG_VERBOSE("    (1D) value= "<<value<<" bin= "<<bin<< " f = "<<tmp);
          if (!m_normProb) {
        double binw = tmpHisto->GetBinWidth(bin);
        if(binw != 0.)tmp /= binw;
        else ATH_MSG_ERROR("Bin width is 0.");
        ATH_MSG_VERBOSE("    (1D) value= "<<value<<" bin= "<<bin<<" binw= "<<binw<< " f = "<<tmp);
          }
          tmpVector.push_back(tmp);
          sum += tmp;
        }
      }
    } else if (idim == 2) {
      const HistoLimits& histoLimits = (*(m_histoLimitsMap2D.find(histName))).second;
      for (std::vector< std::map<std::string, TH1*>* >::iterator
         itr2 = m_mapOfAllHistos.begin() ;
           itr2 != m_mapOfAllHistos.end() ; ++itr2 ) {
        if( (*itr2)->find(histName) != (*itr2)->end() ) {
          TH1* tmpHisto = (*((*itr2)->find(histName))).second;
          ATH_MSG_VERBOSE("tmpHisto="<<tmpHisto);
          double valuex = m_lhVariableValues[iel].composites[icompo].atoms[0].value; 
          double valuey = m_lhVariableValues[iel].composites[icompo].atoms[1].value; 
          int binx((tmpHisto->GetXaxis())->FindBin(valuex));
          int biny((tmpHisto->GetYaxis())->FindBin(valuey));
          if(valuex>= histoLimits.xmax) binx = histoLimits.bins;
          if(valuex<= histoLimits.xmin) binx = 1;
          if(valuey>= histoLimits.ymax) biny = histoLimits.binsy;
          if(valuey<= histoLimits.ymin) biny = 1;
          double tmp(tmpHisto->GetBinContent(binx,biny));
          ATH_MSG_VERBOSE("    (2D) value= "<<valuex<<" "<<valuey<<" bin= "<<binx<<" "<<biny<< " f = "<<tmp);
          if (!m_normProb) {
        double binw  = tmpHisto->GetXaxis()->GetBinWidth(binx) * tmpHisto->GetYaxis()->GetBinWidth(biny);
        if(binw != 0.)tmp /= binw;
        else ATH_MSG_ERROR("Bin area is 0.");
        ATH_MSG_VERBOSE("    (2D) value= "<<valuex<<" "<<valuey<<" bin= "<<binx<<" "<<biny<<" binw= "<<binw<< " f = "<<tmp);
          }
          tmpVector.push_back(tmp);
          sum += tmp;
        }
      }
    } else if (idim == 3) {
      const HistoLimits& histoLimits = (*(m_histoLimitsMap3D.find(histName))).second;
      for (std::vector< std::map<std::string, TH1*>* >::iterator
         itr2 = m_mapOfAllHistos.begin() ;
           itr2 != m_mapOfAllHistos.end() ; ++itr2 ) {
        if( (*itr2)->find(histName) != (*itr2)->end() ) {
          TH1* tmpHisto = (*((*itr2)->find(histName))).second;
          double valuex = m_lhVariableValues[iel].composites[icompo].atoms[0].value; 
          double valuey = m_lhVariableValues[iel].composites[icompo].atoms[1].value; 
          double valuez = m_lhVariableValues[iel].composites[icompo].atoms[2].value; 
          int binx((tmpHisto->GetXaxis())->FindBin(valuex));
          int biny((tmpHisto->GetYaxis())->FindBin(valuey));
          int binz((tmpHisto->GetZaxis())->FindBin(valuez));
          if(valuex>= histoLimits.xmax) binx = histoLimits.bins;
          if(valuex<= histoLimits.xmin) binx = 1;
          if(valuey>= histoLimits.ymax) biny = histoLimits.binsy;
          if(valuey<= histoLimits.ymin) biny = 1;
          if(valuez>= histoLimits.zmax) binz = histoLimits.binsz;
          if(valuez<= histoLimits.zmin) binz = 1;
          double tmpNoInt(tmpHisto->GetBinContent(binx,biny,binz));
          double tmp(HistoHelperRoot::Interpol3d(valuex,valuey,valuez,dynamic_cast<TH3*>(tmpHisto)));
          ATH_MSG_VERBOSE("    (3D) value= "<<valuex<<" "<<valuey<<" "<<valuez <<" bin= "<<binx<<" "<<biny<<" "<<binz<<" binContent = "<<tmp<< " binContentNoInt = "<< tmpNoInt);
          if (!m_normProb) {
        double binw  = 
          tmpHisto->GetXaxis()->GetBinWidth(binx) * 
          tmpHisto->GetYaxis()->GetBinWidth(biny) * 
          tmpHisto->GetZaxis()->GetBinWidth(binz);
        if(binw != 0.) {
          tmpNoInt /= binw;
          tmp /= binw;
        }
        else ATH_MSG_ERROR("Bin volume is 0.");    
        ATH_MSG_VERBOSE("    (3D) value= "<<valuex<<" "<<valuey<<" "<<valuez <<" bin= "<<binx<<" "<<biny<<" "<<binz<<" binw= "<<binw<<" binContent = "<<tmp<< " binContentNoInt = "<< tmpNoInt);
          }
          if (m_DoInterpol) {
            tmpVector.push_back(tmp);
            sum += tmp;
          }  else {
            tmpVector.push_back(tmpNoInt);
            sum += tmpNoInt;  
          }
        }
      }
    } else {
      ATH_MSG_WARNING("No more that 3D pdf for the time being !");
    }
    unsigned int classCount(0);
    for (std::vector<double>::iterator itr3 = tmpVector.begin();  itr3 != tmpVector.end(); ++itr3) {
      if (sum != 0.) {
        ATH_MSG_VERBOSE("pb + pu = "<<sum);
        double p = (*itr3);
        if (m_normProb) p /= sum;
        probDensityPerEventClassAllVariables[classCount] *= p;
      } else {
        ATH_MSG_WARNING("Empty bins for all hypothesis... The discriminating variables are not taken into account in this jet");
        ATH_MSG_WARNING("Check your inputs");
      }
      ATH_MSG_VERBOSE("  probDensity= "<<probDensityPerEventClassAllVariables[classCount]<<" ic= "<<classCount);
      classCount++;
    }
    ATH_MSG_VERBOSE(" Final probDensity= "<<probDensityPerEventClassAllVariables);
      }
    }
    ATH_MSG_VERBOSE(" Ending ...");
    m_likelihoodVector=probDensityPerEventClassAllVariables;
    return m_likelihoodVector;
  }

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T, V, H > &	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());
 
  }

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

◆ defineNbHypotheses()

void Analysis::LikelihoodMultiDTool::defineNbHypotheses ( int n )

inline

Definition at line 57 of file LikelihoodMultiDTool.h.

57{ m_nbHypotheses = n; }

beamspotman.n

n

Definition beamspotman.py:727

◆ detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::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; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::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; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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

◆ finalize()

StatusCode Analysis::LikelihoodMultiDTool::finalize ( )

AlgTool finalize method.

Definition at line 70 of file LikelihoodMultiDTool.cxx.

  {
    return StatusCode::SUCCESS;
  }

◆ getEff()

double Analysis::LikelihoodMultiDTool::getEff	(	const std::string &	refFileName,
		const std::string &	histoName,
		const std::string &	mode )

Definition at line 421 of file LikelihoodMultiDTool.cxx.

  {
    //
    StatusCode scs = SUCCESS, scg = SUCCESS;
    std::string fullPathSel(refFileName+histoName+"Eff"+mode);
    std::string fullPathGen(refFileName+histoName+"Norm"+mode);
    ATH_MSG_VERBOSE("Retrieving histo for efficiency computation: " << fullPathSel);
    ATH_MSG_VERBOSE("Retrieving histo for efficiency computation: " << fullPathGen);
    TH1 *sel(0), *gen(0);
    scs = m_histoSvc->regHist(fullPathSel);
    scg = m_histoSvc->regHist(fullPathGen);
    if (scs.isSuccess() && scg.isSuccess()) { 
      scs = m_histoSvc->getHist(fullPathSel,sel);
      scg = m_histoSvc->getHist(fullPathGen,gen);
      if (sel && gen && scs.isSuccess() && scg.isSuccess()) {
    double nsel = sel->GetEntries(); // I need also the over/under flow for the efficiency !!!
    double ngen = gen->GetEntries();
    if (ngen != 0) {
      ATH_MSG_VERBOSE("N RecSvx = " << nsel << " in a total of "<< ngen << " jets.");
      return nsel/ngen;
    } else {
      ATH_MSG_ERROR("Pb in computing Svx efficiency " << nsel << " "<< ngen);
      return 0.;
    }
      }
    } else {
      // already there...
      scs = m_histoSvc->getHist(fullPathSel,sel);
      scg = m_histoSvc->getHist(fullPathGen,gen);
      if (sel && gen && scs.isSuccess() && scg.isSuccess()) {
    double nsel = sel->GetEntries();
    double ngen = gen->GetEntries();
    if (ngen != 0) {
      ATH_MSG_VERBOSE("N RecSvx = " << nsel << " in a total of "<< ngen << " jets.");
      return nsel/ngen;
    } else {
      ATH_MSG_ERROR("Pb in computing Svx efficiency " << nsel << " "<< ngen);
      return 0.;
    }
      }
    }
    ATH_MSG_ERROR("Pb in computing Svx efficiency ");
    return 0.;
  }

◆ initialize()

StatusCode Analysis::LikelihoodMultiDTool::initialize ( )

AlgTool initailize method.

Definition at line 57 of file LikelihoodMultiDTool.cxx.

  {
 
    StatusCode sc = service("THistSvc", m_histoSvc);
    if (sc.isFailure())
      {
    ATH_MSG_FATAL("THistSvc not found!");
    return StatusCode::FAILURE;
      }
    //
    return StatusCode::SUCCESS;
  }

◆ inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

◆ interfaceID()

const InterfaceID & Analysis::LikelihoodMultiDTool::interfaceID ( )

inlinestatic

Definition at line 43 of file LikelihoodMultiDTool.h.

43{ return IID_LikelihoodMultiDTool; };

Analysis::IID_LikelihoodMultiDTool

static const InterfaceID IID_LikelihoodMultiDTool("Analysis::LikelihoodMultiDTool", 1, 0)

◆ msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

◆ msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

◆ outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

◆ prepareHistosFromFile()

void Analysis::LikelihoodMultiDTool::prepareHistosFromFile ( const std::string & refFileName )

Definition at line 75 of file LikelihoodMultiDTool.cxx.

                                                                               {
    MsgStream mlog(msgSvc(),name()); 
    ATH_MSG_DEBUG("refFileName = "<<refFileName);
    // the tmpHistoMap belongs to m_mapOfAllHistos and is deleted at the end in the destructor of LikelihoodMultiDTool()
    std::map<std::string, TH1*>* tmpHistoMap = new std::map<std::string, TH1*>();
    // loop on requested histos:
    for (std::vector<std::string>::iterator itr = m_useTheseLhVariables.begin() ;
     itr != m_useTheseLhVariables.end()  ; ++itr ) {
      std::string histoName = *itr;
      std::vector<std::string> grades;
      // parse histo name to extract words separated by _ sign:
      // first word is the histo base name, following ones are the grades
      // first word is jet category, 2nd is the histo base name, following ones are the grades
      std::vector<std::string> words;
 
      ATH_MSG_DEBUG("decoding histoName = "<<histoName);
 
      const std::string delim("_");
      std::string::size_type sPos, sEnd, sLen;
      sPos = histoName.find_first_not_of(delim);
      while ( sPos != std::string::npos ) {
    sEnd = histoName.find_first_of(delim, sPos);
    if(sEnd==std::string::npos) sEnd = histoName.length();
    sLen = sEnd - sPos;
    std::string word = histoName.substr(sPos,sLen);
 
    ATH_MSG_DEBUG(" -> word = "<<word);
 
    words.push_back(word);
    sPos = histoName.find_first_not_of(delim, sEnd);
      }
      // first treat cases with a single or no grade:
      int nGrade = words.size() - 2;
      TH1* histoSum(0);
      if(nGrade==0) {
    ATH_MSG_DEBUG("Histo "<<histoName<<" has "<<nGrade<<" grade: direct retrieval");
    histoSum = this->retrieveHistoFromFile(refFileName, words[1], words[0]);
      } else if(nGrade==1) {
    ATH_MSG_DEBUG("Histo "<<histoName<<" has "<<nGrade<<" grade: direct retrieval");
    histoSum = this->retrieveHistoFromFile(refFileName, words[1]+"_"+words[2], words[0]);
      } else {
    // for many grades, get individual histos and sum them up:
    ATH_MSG_DEBUG("Histo "<<histoName<<" has "<<nGrade<<" grades:");
    for(int i=1;i<=nGrade;i++) {
      ATH_MSG_DEBUG("  -> retrieving histo for grade "<<i<<" : "<<words[1]<<" "<<words[i+1]);
      TH1* histo = this->retrieveHistoFromFile(refFileName, words[1]+"_"+words[i+1], words[0]);
      ATH_MSG_DEBUG("   #entries= "<<histo->GetEntries());
      if(1==i) {
        histoSum = histo;
      } else {
        histoSum->Add(histo,1.);
      }
      ATH_MSG_DEBUG("   #entries for Sum= "<<histoSum->GetEntries());
    }
      }
      if(histoSum) {
    // smooth and normalize:
    double norm = histoSum->Integral();
    if(norm) {
      if(1==histoSum->GetDimension() && m_nSmooth1D) {
        if(histoName.find("N2T")==std::string::npos){ // do not smooth N2T
          if(norm>10000)histoSum->Smooth(m_nSmooth1D);
          else histoSum->Smooth((int)(m_nSmooth1D*100./sqrt(norm)));
        }
      }
      if(2==histoSum->GetDimension()) {
        int m2d=3;
        if(refFileName.find("Bkg/")!=std::string::npos) m2d=5;
        bool debug = mlog.level()<=MSG::DEBUG ? true : false;
        // do not smooth Sip3D for the time being
        if(histoName.find("Sip3D")==std::string::npos) HistoHelperRoot::smoothASH2D(dynamic_cast<TH2*>(histoSum), m2d, m2d, debug);
      }
      if(3==histoSum->GetDimension()) {
        int m3d1=3;
        int m3d3=2;
        bool debug = mlog.level()<=MSG::DEBUG ? true : false;
        HistoHelperRoot::smoothASH3D(dynamic_cast<TH3*>(histoSum), m3d1, m3d1, m3d3, debug);
      }
      norm = histoSum->Integral();
      histoSum->Scale(1./norm);
    } else {
      ATH_MSG_WARNING("Histo "<<histoName<<" is empty!");
    }
    // store: if >= 2 grades in one histo, the histoName is the name of the first Grade
    // Change LV 2005/10/09: if >=2 grades, insert a copy for each grade:
    std::string namemap = histoName;
    if (nGrade == 0) { 
      namemap = words[0]+"_"+words[1];
      ATH_MSG_VERBOSE("Inserting as " << namemap);
      tmpHistoMap->insert(std::pair<std::string, TH1*>(namemap, histoSum));
    }
    for(int i=1;i<=nGrade;i++) {
      namemap = words[0] + "_" + words[1] + "_" + words[i+1];
      ATH_MSG_VERBOSE("Inserting as " << namemap);
      tmpHistoMap->insert(std::pair<std::string, TH1*>(namemap, histoSum));
    }
    // Also for control, store the smoothed histograms in a file
    if (m_WriteSmoothedHistos) {
      std::string namedir = refFileName; namedir = namedir.substr((namedir.erase(namedir.size()-1,1)).rfind('/')+1)+"/";
      std::string namehis = histoSum->GetName();
      ATH_MSG_VERBOSE("Registering smoothed histogram in " << namedir);
      TH1* histoSumClone = (TH1*)histoSum->Clone();
      StatusCode sc = m_histoSvc->regHist("/ControlFile/"+namedir+namehis, histoSumClone);
      if (sc.isFailure()) {
        ATH_MSG_ERROR("Cannot store the smoothed histogram in the control file !");
      }
    }
      }
    }
    ATH_MSG_DEBUG("I found "<<m_nhis1D<<" 1D histos, "<<m_nhis2D<<" 2D histos and "<<m_nhis3D<<" 3D histos");
    if (m_nhis1D+m_nhis2D+m_nhis3D) m_mapOfAllHistos.push_back(tmpHistoMap);
  }

◆ printStatus()

void Analysis::LikelihoodMultiDTool::printStatus ( )

Definition at line 415 of file LikelihoodMultiDTool.cxx.

  {
    unsigned int num = m_mapOfAllHistos.size();
    ATH_MSG_INFO("Currently I hold histos of " << num << " input files");
  }

◆ 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< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

◆ resetLhVariableToUse()

void Analysis::LikelihoodMultiDTool::resetLhVariableToUse ( )

inline

Definition at line 55 of file LikelihoodMultiDTool.h.

55{ m_useTheseLhVariables.clear(); }

◆ retrieveHistoFromFile()

TH1 * Analysis::LikelihoodMultiDTool::retrieveHistoFromFile	(	const std::string &	refFileName,
		const std::string &	histoName,
		const std::string &	jetPrefix )

Retrieve and set histo limits for this histogram

Definition at line 188 of file LikelihoodMultiDTool.cxx.

                                                       {
    std::string fullPath(refFileName+histoName);
    ATH_MSG_VERBOSE("Retrieving histo: " << fullPath);
    bool is1D = false, is2D = false, is3D = false;
    TH1* tmphisto(0);
    StatusCode sc = m_histoSvc->regHist(fullPath);
    if(sc.isFailure()) {};
    sc = m_histoSvc->getHist(fullPath,tmphisto);
    int dim = 0; 
    if (sc.isSuccess()) {
      dim = tmphisto->GetDimension();
      if (dim == 1) {
    is1D = true;
    m_nhis1D++;
      } else if (dim == 2) {
    is2D = true;
    m_nhis2D++;
      } else if (dim == 3) {
    is3D = true;
    m_nhis3D++;
      } else {
    ATH_MSG_DEBUG("cannot retrieve histo " << fullPath << " Unexpected dimension "<< dim);
    return tmphisto;
      }
    } else {
      ATH_MSG_DEBUG("I COULD NOT RETRIEVE HISTO: " << fullPath);
      return tmphisto;
    }
    unsigned int bins  = (tmphisto->GetXaxis())->GetNbins();
    double minx        = (tmphisto->GetXaxis())->GetXmin();
    double maxx        = (tmphisto->GetXaxis())->GetXmax();
    if (is1D) {
      m_histoLimitsMap1D[jetPrefix+"_"+histoName] = HistoLimits(bins, minx, maxx);
      ATH_MSG_DEBUG("Histo "<< jetPrefix+"_"+histoName << " properties: ");
      ATH_MSG_DEBUG(bins  <<" bins X between " << minx <<" and " << maxx);
    } else if (is2D) {
      unsigned int binsy = (tmphisto->GetYaxis())->GetNbins();
      double miny        = (tmphisto->GetYaxis())->GetXmin();
      double maxy        = (tmphisto->GetYaxis())->GetXmax();
      m_histoLimitsMap2D[jetPrefix+"_"+histoName] = HistoLimits(bins, minx, maxx, binsy, miny, maxy);
      ATH_MSG_DEBUG("Histo "<< jetPrefix+"_"+histoName << " properties: ");
      ATH_MSG_DEBUG(bins  <<" bins X between " << minx <<" and " << maxx );
      ATH_MSG_DEBUG(binsy <<" bins Y between " << miny <<" and " << maxy);
    } else if (is3D) {
      unsigned int binsy = (tmphisto->GetYaxis())->GetNbins();
      double miny        = (tmphisto->GetYaxis())->GetXmin();
      double maxy        = (tmphisto->GetYaxis())->GetXmax();
      unsigned int binsz = (tmphisto->GetZaxis())->GetNbins();
      double minz        = (tmphisto->GetZaxis())->GetXmin();
      double maxz        = (tmphisto->GetZaxis())->GetXmax();
      m_histoLimitsMap3D[jetPrefix+"_"+histoName] = HistoLimits(bins, minx, maxx, binsy, miny, maxy, binsz, minz, maxz);
 
      ATH_MSG_DEBUG("Histo "<< jetPrefix+"_"+histoName << " properties: ");
      ATH_MSG_DEBUG(bins  <<" bins X between " << minx <<" and " << maxx);
      ATH_MSG_DEBUG(binsy <<" bins Y between " << miny <<" and " << maxy);
      ATH_MSG_DEBUG(binsz <<" bins Z between " << minz <<" and " << maxz);
    }
    return tmphisto;
  }

◆ setInterpolFlag()

void Analysis::LikelihoodMultiDTool::setInterpolFlag ( bool f )

inline

Definition at line 56 of file LikelihoodMultiDTool.h.

56{m_DoInterpol = f;}

hist_file_dump.f

f

Definition hist_file_dump.py:140

◆ setLhVariableValue() [1/2]

void Analysis::LikelihoodMultiDTool::setLhVariableValue ( Slice & value )

Definition at line 255 of file LikelihoodMultiDTool.cxx.

  {
    std::vector<Slice> tmpVector;
    tmpVector.push_back(value);
    setLhVariableValue(tmpVector);
  }

◆ setLhVariableValue() [2/2]

void Analysis::LikelihoodMultiDTool::setLhVariableValue ( std::vector< Slice > & value )

Definition at line 251 of file LikelihoodMultiDTool.cxx.

  {
    m_lhVariableValues=value;
  }

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

◆ tagLikelihood()

const std::vector< double > & Analysis::LikelihoodMultiDTool::tagLikelihood ( )

Definition at line 410 of file LikelihoodMultiDTool.cxx.

  {
    return m_likelihoodVector;
  }

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_DoInterpol

bool Analysis::LikelihoodMultiDTool::m_DoInterpol

private

Definition at line 98 of file LikelihoodMultiDTool.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_histoLimitsMap1D

std::map<std::string, HistoLimits> Analysis::LikelihoodMultiDTool::m_histoLimitsMap1D

private

To hold the histo limits.

If a lh variable is out of range it should use the entries in the first or the last bin.

Definition at line 76 of file LikelihoodMultiDTool.h.

◆ m_histoLimitsMap2D

std::map<std::string, HistoLimits> Analysis::LikelihoodMultiDTool::m_histoLimitsMap2D

private

Definition at line 77 of file LikelihoodMultiDTool.h.

◆ m_histoLimitsMap3D

std::map<std::string, HistoLimits> Analysis::LikelihoodMultiDTool::m_histoLimitsMap3D

private

Definition at line 78 of file LikelihoodMultiDTool.h.

◆ m_histoSvc

ITHistSvc* Analysis::LikelihoodMultiDTool::m_histoSvc

private

Definition at line 61 of file LikelihoodMultiDTool.h.

◆ m_lhVariableValues

std::vector<Slice> Analysis::LikelihoodMultiDTool::m_lhVariableValues

private

Contains the value of the likelihood variable with the key std::string.

It is necessary that the value of a likelihood variable is stored with a key to the histogram it should be compared to. Otherwise the likelihood class never knows which lh valuable it handles when only a subset of variables is used. It has a vector of double because some LH variabels are there more than once per jet/event (e.g. tracksignificance of LifetimeTag).

Definition at line 86 of file LikelihoodMultiDTool.h.

◆ m_likelihoodVector

std::vector<double> Analysis::LikelihoodMultiDTool::m_likelihoodVector

private

Contains the combined likelihood for each input file category.

Usually input 1 are the signal distributions - so the first entry is the sigLh of the event.

Definition at line 90 of file LikelihoodMultiDTool.h.

◆ m_mapOfAllHistos

std::vector< std::map<std::string, TH1*>* > Analysis::LikelihoodMultiDTool::m_mapOfAllHistos

private

For every histogram input file this vector contains a map with the names of the histograms as a key and the pointer to the histograms.

It is a vector because there can be 2+ (sig, bkg1, bkg2, ...) histogram input files.

Definition at line 71 of file LikelihoodMultiDTool.h.

◆ m_nbHypotheses

unsigned int Analysis::LikelihoodMultiDTool::m_nbHypotheses

private

Definition at line 101 of file LikelihoodMultiDTool.h.

◆ m_nhis1D

int Analysis::LikelihoodMultiDTool::m_nhis1D

private

for debugging:

Definition at line 93 of file LikelihoodMultiDTool.h.

◆ m_nhis2D

int Analysis::LikelihoodMultiDTool::m_nhis2D

private

Definition at line 94 of file LikelihoodMultiDTool.h.

◆ m_nhis3D

int Analysis::LikelihoodMultiDTool::m_nhis3D

private

Definition at line 95 of file LikelihoodMultiDTool.h.

◆ m_normProb

bool Analysis::LikelihoodMultiDTool::m_normProb

private

Definition at line 105 of file LikelihoodMultiDTool.h.

◆ m_nSmooth1D

int Analysis::LikelihoodMultiDTool::m_nSmooth1D

private

Definition at line 104 of file LikelihoodMultiDTool.h.

◆ m_useTheseLhVariables

std::vector<std::string> Analysis::LikelihoodMultiDTool::m_useTheseLhVariables

private

names of lh variables which one wants to use (subset of m_allLhVariables)

Definition at line 65 of file LikelihoodMultiDTool.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_WriteSmoothedHistos

bool Analysis::LikelihoodMultiDTool::m_WriteSmoothedHistos

private

Definition at line 99 of file LikelihoodMultiDTool.h.

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ LikelihoodMultiDTool()

◆ ~LikelihoodMultiDTool()

Member Function Documentation

◆ addLhVariableToUse()

◆ calculateLikelihood()

◆ declareGaudiProperty()

◆ declareProperty()

◆ defineNbHypotheses()

◆ detStore()

◆ evtStore()

◆ extraDeps_update_handler()

◆ finalize()

◆ getEff()

◆ initialize()

◆ inputHandles()

◆ interfaceID()

◆ msg()

◆ msgLvl()

◆ outputHandles()

◆ prepareHistosFromFile()

◆ printStatus()

◆ renounce()

◆ renounceArray()

◆ resetLhVariableToUse()

◆ retrieveHistoFromFile()

◆ setInterpolFlag()

◆ setLhVariableValue() [1/2]

◆ setLhVariableValue() [2/2]

◆ sysInitialize()

◆ sysStart()

◆ tagLikelihood()

◆ updateVHKA()

Member Data Documentation

◆ m_detStore

◆ m_DoInterpol

◆ m_evtStore

◆ m_histoLimitsMap1D

◆ m_histoLimitsMap2D

◆ m_histoLimitsMap3D

◆ m_histoSvc

◆ m_lhVariableValues

◆ m_likelihoodVector

◆ m_mapOfAllHistos

◆ m_nbHypotheses

◆ m_nhis1D

◆ m_nhis2D

◆ m_nhis3D

◆ m_normProb

◆ m_nSmooth1D

◆ m_useTheseLhVariables

◆ m_varHandleArraysDeclared

◆ m_vhka

◆ m_WriteSmoothedHistos