JetCaloCalculations.h

Go to the documentation of this file.

// emacs, this file is -*- c++ -*-
 
/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef JETUTILS_JETCALOHELPER_H
#define JETUTILS_JETCALOHELPER_H
 
#include "xAODJet/JetConstituentVector.h"
 
#include <vector>
 
#include "xAODJet/Jet.h"
 
#include "xAODCaloEvent/CaloCluster.h"
 
namespace CaloConstitHelpers {

  struct CaloConstitExtractor {
    virtual ~CaloConstitExtractor(){}
    virtual bool valid(xAOD::JetConstituentVector::iterator &) const {return false;}
    virtual double moment( xAOD::JetConstituentVector::iterator & , xAOD::CaloCluster::MomentType ) const {return 0;};
    virtual double time(xAOD::JetConstituentVector::iterator & ) const {return 0.;}
    virtual double energyHEC(xAOD::JetConstituentVector::iterator & ) const {return 0.;}
  };  
}
 
namespace jet {
  class JetCaloCalculator {
  public:
    //typedef typename Jet::navigable_type::paramter_type cellweight_t;
    typedef  double weight_t;
 
    JetCaloCalculator() : m_name("JetCaloCalculator"){}
    JetCaloCalculator(xAOD::JetAttribute::AttributeID id) ;
 
    virtual ~JetCaloCalculator(){}
 
    virtual bool setupEvent() {return true; };
    virtual bool setupJet(const xAOD::Jet* /*jet*/) = 0;
 

    virtual bool processConstituent(xAOD::JetConstituentVector::iterator& /*it*/) {return true;}; 
 

    virtual double jetCalculation() const {return 0;};

    virtual double operator()(const xAOD::Jet* jet, xAOD::JetConstitScale s=xAOD::UncalibratedJetConstituent);
 
    virtual std::string name() const {return m_name;}
  
    void setName(const std::string& n){m_name = n;}
 
 
    void setExtractor(const CaloConstitHelpers::CaloConstitExtractor* ex){m_constitExtractor = ex;}

    virtual JetCaloCalculator* clone() const =0;
 
  protected:
    std::string m_name;
    xAOD::JetAttribute::AttributeID m_id{}; // unused for now.
    const CaloConstitHelpers::CaloConstitExtractor *m_constitExtractor{}; // used to retrieve the cluster moment from the constituent (which can be a PFO object or a cluster)
  };
 

#define JETCALCFUNCDECL( cname, id,  others)                            \
  public:                                                               \
  virtual bool setupJet(const xAOD::Jet* jet);                                  \
  virtual bool processConstituent(xAOD::JetConstituentVector::iterator& iter);  \
  double jetCalculation() const ;                                             \
  cname(xAOD::JetAttribute::AttributeID i=id) : JetCaloCalculator( i ) { others } \
  virtual JetCaloCalculator* clone() const {return new cname(*this); }
 

  class JetCaloCalculations {
  public:
 
    JetCaloCalculations(bool ownCalc=true) : m_owncalculators(ownCalc) {}
 
    virtual ~JetCaloCalculations(){clear();}
    void addCalculator(JetCaloCalculator* c);
  
    bool setupEvent();
  
    virtual std::vector<double> process(const xAOD::Jet* jet) const ;
 
    void clear();
 
 
    size_t numCalculators() const {return m_calculators.size();}
    const JetCaloCalculator* at(size_t i) const {return m_calculators[i];}
 
 
 
  protected:
    std::vector<JetCaloCalculator*>  m_calculators;
    bool m_owncalculators;
  };
 
}
#endif