/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/JetRec/JetRec/FastJetInterfaceTool.h

// -*- c++ -*-
#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>

#ifdef ASGTOOL_ATHENA
// 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;
#ifdef ASGTOOL_ATHENA
  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 : virtual 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);

#ifdef ASGTOOL_ATHENA
  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);
  
#ifdef ASGTOOL_ATHENA
  const std::string& configName(fastjet::SISConePlugin::SplitMergeScale fjsms);
#endif

  const std::string& configName(fastjet::AreaType            fjart);


private:

  static std::string m_invalidKeyReference;

  static FastJetInterface::algomap_t     s_knownAlgorithms;
  static FastJetInterface::strategymap_t s_knownStrategies;
  static FastJetInterface::schememap_t   s_knownRecombinationSchemes;
  static FastJetInterface::splitMergeScaleMap_t s_knownSplitMergeScales;
  static FastJetInterface::areamap_t     s_knownAreas;

  unsigned int m_failedExecCtr;
  static unsigned int m_failedExecCtrMax;

  


protected:
  
  fastjet::JetAlgorithm        m_jetAlgorithm;
  fastjet::Strategy            m_strategy;
  fastjet::AreaType            m_areaType;
  fastjet::RecombinationScheme m_recombinationScheme;
#ifdef ASGTOOL_ATHENA
  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

---