FastJetInterfaceTool.h

Go to the documentation of this file.

// -*- c++ -*-
 
/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef JETREC_FASTJETINTERFACETOOL_H
#define JETREC_FASTJETINTERFACETOOL_H
 
//#include "AthenaBaseComps/AthAlgTool.h"
#include "AsgTools/AsgTool.h"
 
 
#include "fastjet/ClusterSequence.hh"
#include "fastjet/JetDefinition.hh"
#include "fastjet/AreaDefinition.hh"
 
#include "JetInterface/IFastJetInterfaceTool.h"
 
#include <map>
#include <string>
#include <vector>
#include <stdint.h>
 
#ifndef XAOD_STANDALONE
// support contribs only in athena for now
#include "fastjet/SISConePlugin.hh"
#include "fastjet/CMSIterativeConePlugin.hh"
#endif 
 
// #include <iostream>
 
namespace FastJetInterface
{
  typedef std::map<std::string,fastjet::JetAlgorithm>          algomap_t;
  typedef std::map<std::string,fastjet::Strategy>          strategymap_t;
  typedef std::map<std::string,fastjet::RecombinationScheme> schememap_t;
#ifndef XAOD_STANDALONE
  typedef std::map<std::string,fastjet::SISConePlugin::SplitMergeScale> splitMergeScaleMap_t;
#else
  typedef std::map<std::string,int> splitMergeScaleMap_t;
#endif
 
  typedef std::map<std::string,fastjet::AreaType>              areamap_t;
 
  typedef fastjet::PseudoJet   fjet_t;
  typedef std::vector<fjet_t>  fjetlist_t;  
 
  // static const algomap_t&      getKnownAlgorithms();
  // static const strategymap_t&  getKnownStrategies();
  // static const schememap_t&    getKnownRecombinationSchemes();
  // static const areamap_t&      getKnownAreas();
 
  template<class D,class M>
  static bool chkConfig(const std::string& key,D& tag,const M& map)
  {
    //    std::cout << "Looking for key <" << key << "> in " << map.size() << " entries." << std::endl;
    typename M::const_iterator fMap(map.find(key));
    if ( fMap != map.end() ) { tag = (*fMap).second; return true; }
    else { return false; } 
  }
 
  template<class D,class M>
  const std::string& cfgName(D tag,const M& map,const std::string& invalidKey)
  {
    typename M::const_iterator fMap(map.begin());
    typename M::const_iterator lMap(map.end());
    while ( fMap != lMap && (*fMap).second != tag ) { ++fMap; }
    return fMap != lMap ? (*fMap).first : invalidKey; 
  }
}
 
class FastJetInterfaceTool : public asg::AsgTool, 
                             virtual public IFastJetInterfaceTool {
  
public:
 
  ASG_TOOL_CLASS(FastJetInterfaceTool, IFastJetInterfaceTool)
 
  
  FastJetInterfaceTool(const std::string& n);
  virtual ~FastJetInterfaceTool();
 
  virtual StatusCode initialize();
 
  virtual StatusCode execute(const fjetlist_t& inJets,fjetlist_t& outJets);
  
  virtual fastjet::ClusterSequence* clusterSequence();
  
  virtual const fastjet::ClusterSequence* clusterSequence() const;
 
  template<class S>
  S* specificClusterSequence() 
  { return dynamic_cast<S*>(this->clusterSequence()); }
 
 
  template<class S>
  const S* specificClusterSequence() const
  { return dynamic_cast<const S*>(this->clusterSequence()); }
 
  const fastjet::JetDefinition* getJetDefinition() const;
  
  const fastjet::AreaDefinition* getAreaDefinition() const;
  
  const std::string getAreaDefinitionType() const;
 
  const FastJetInterface::algomap_t&     getKnownAlgorithms();
  const FastJetInterface::strategymap_t& getKnownStrategies();
  const FastJetInterface::schememap_t&   getKnownRecombinationSchemes();
  const FastJetInterface::splitMergeScaleMap_t& getKnownSplitMergeScales();
  const FastJetInterface::areamap_t&     getKnownAreas();
 
protected:
 
  std::string m_clusterSequenceType;
  std::string m_jetAlgorithmType;
  std::string m_clusterStrategyType;
  std::string m_recombinationSchemeType;
  
  double m_CMS_seedThreshold;
  double m_SIS_overlapThreshold;
  int m_SIS_nPass;
  double m_SIS_protojetPtMin;
  bool m_SIS_doCaching;
  std::string m_SIS_splitMergeScale_STRING;
  double m_SIS_splitMergeStopScale;  
 
  double m_radius;
  bool m_inclusive;
  double m_exclusiveDcut;
  int m_exclusiveNjets;
  double m_pTmin;
 
  bool m_doJetArea;
  std::string m_jetAreaDefinitionType;
  double m_voronoiEffectiveRfact;
  double m_ghostedMaxRap;
  double m_ghostedMinRap;
  int m_ghostedRepeat;
  double m_ghostedArea;
  double m_ghostedGridScatter;
  double m_ghostedKtScatter;
  double m_ghostedMeanKt;
  
  bool checkConfig(const std::string& key,fastjet::JetAlgorithm& fjalg);
 
  bool checkConfig(const std::string& key,fastjet::Strategy& fjstr);
 
  bool checkConfig(const std::string& key,fastjet::RecombinationScheme& fjrs);
 
#ifndef XAOD_STANDALONE
  bool checkConfig(const std::string& key,fastjet::SISConePlugin::SplitMergeScale& fjsms);
#endif
 
  bool checkConfig(const std::string& tag,fastjet::AreaType& fjart);
 
  const std::string& configName(fastjet::JetAlgorithm        fjalg);
 
  const std::string& configName(fastjet::Strategy            fjstr);
 
  const std::string& configName(fastjet::RecombinationScheme fjrs);
  
#ifndef XAOD_STANDALONE
  const std::string& configName(fastjet::SISConePlugin::SplitMergeScale fjsms);
#endif
 
  const std::string& configName(fastjet::AreaType            fjart);
 
 
private:
 
  static const std::string m_invalidKeyReference;
 
  unsigned int m_failedExecCtr;
  static const unsigned int m_failedExecCtrMax;
 
  
 
 
protected:
  
  fastjet::JetAlgorithm        m_jetAlgorithm;
  fastjet::Strategy            m_strategy;
  fastjet::AreaType            m_areaType;
  fastjet::RecombinationScheme m_recombinationScheme;
#ifndef XAOD_STANDALONE
  fastjet::SISConePlugin::SplitMergeScale m_SIS_splitMergeScale;
#endif
 
  fastjet::JetDefinition*   m_jetDefinition;
  fastjet::ClusterSequence* m_clusterSequence;
  fastjet::AreaDefinition*  m_areaDefinition;
 
  uint64_t m_baseRNDSeed;
  uint64_t m_userRNDSeed;
 
 
  typedef StatusCode 
  (FastJetInterfaceTool::*PROCESSOR)(const FastJetInterface::fjetlist_t& inJets,
                     FastJetInterface::fjetlist_t& outJets);
  typedef StatusCode 
  (FastJetInterfaceTool::*EXTRACTOR)(FastJetInterface::fjetlist_t& outJets);
 
  PROCESSOR m_processor;
  EXTRACTOR m_extractor;
 
  StatusCode f_processWithoutArea(const FastJetInterface::fjetlist_t& inJets,
                  FastJetInterface::fjetlist_t& outJets);
 
  StatusCode f_processWithArea(const FastJetInterface::fjetlist_t& inJets,
                   FastJetInterface::fjetlist_t& outJets);
 
  StatusCode configJetAreas();
  StatusCode f_extractInclusive(FastJetInterface::fjetlist_t& outJets);
  StatusCode f_extractExclDcut(FastJetInterface::fjetlist_t& outJets);
  StatusCode f_extractExclNjets(FastJetInterface::fjetlist_t& outJets);
 
 
 
  virtual void updateRandomSeeds();
 
 
};
 
// inline 
// const FastJetInterface::algomap_t& FastJetInterface::getKnownAlgorithms()
// { return FastJetInterfaceTool::getKnownAlgorithms(); }
 
// inline 
// const FastJetInterface::strategymap_t& FastJetInterface::getKnownStrategies()
// { return FastJetInteraceTool::getKnownStrategies(); }
 
// inline
// const FastJetInterface::schememap_t& 
// FastJetInterface::getKnownRecombinationSchemes()
// { return FastJetInterfaceTool::getKnownRecombinationSchemes(); }
 
// inline 
// const FastJetInterface::areamap_t& FastJetInterface::getKnownAreas()
// { return FastJetInterfaceTool::getKnownAreas(); }
 
#endif