/afs/hep.man.ac.uk/u/markowen/ATLAS/SFrameProof/2011EPS/topUtils/topUtils/TopObjectSel.h

#ifndef TOPUTILS_TOPOBJECT_SEL_H__
#define TOPUTILS_TOPOBJECT_SEL_H__

// stl includes
#include <vector>

// sframe includes
#include "core/include/SError.h"
#include "plug-ins/include/SToolBase.h"

// use the tool holding the ntuple objects
#include "manTreeSFrameBase/include/MEventTool.h"

// manTree includes
#include "manTree/MElectron.h"
#include "manTree/MMuon.h"
#include "manTree/MJet.h"

// root includes
#include "TRandom3.h"

// fwd declarations
class MultijetJESUncertaintyProvider;
class EnergyRescaler;
class SmearingClass;
class JERProvider;
namespace Analysis {
  class CalibrationDataInterfaceROOT;
}

namespace Root{
  class TPileupReweighting;
}
class BTagRandomiser;
class JetEfficiencyEstimator;
class egammaOQ;
class MET_Cleaning_Utils;

class TopObjectSel : public SToolBase {

 public:

  TopObjectSel(SCycleBase* parent, const std::string datapileupfile="PileupMu/ilumicalc_histograms_None_178044-183347.root");

  virtual ~TopObjectSel();

  bool doMuonElectronJetObjectSelection(MEventTool* event);

  void SetMuonSmear(int flag);

  void SetMuonScale(const int flag);

  void UseJESUncertainties(const int flag);

  void SetSumJets(unsigned int flag);

  void UseJERSmearing(const int flag);
  
  bool hasElectronMuonTrkOverlap(const std::vector<const manchester::MMuon*>* muons, const std::vector<const manchester::MElectron*>* electrons);

  bool hasElectronMuonTrkOverlap(const manchester::MMuon& muon, const manchester::MElectron &em);
  
  inline void sortSelectedObjectsByPt(const bool flag) { m_sortByPt = flag; }

  void usingData(bool flag);

  bool hasBadJet(const MEventTool* event) const;

  bool hasBadJet(const std::vector<const manchester::MJet*>* jets) const;

  static bool isLooseBadJet(const manchester::MJet& jet);

  void setElectronEnergyCorrection(const int& sw);

  void setElectronEnergySmearing(const int& sw);

  double getPileUpWeight(double mu);

  const Analysis::CalibrationDataInterfaceROOT* GetSV0BTagSFTool() const {return m_sv0_calibTool;}

  void SetSV0RandomMode(const int sw);

  void dropJetsUsingEffEstimator(MEventTool* event);
  
  void SetJetEffDroppingMode(const int sw) ;

  void SetFracDataLArProb(const double frac);

  inline bool SimulatingLArProblems() const {return m_simulate_lar_problems;}

  inline const egammaOQ* EgammaOQTool() const {return m_egammaOQ;}

  bool hasJetinLArHole(MEventTool* event);

 protected:

  void varyJES(MEventTool* event);

  void doJER(MEventTool* event);
  void doJER(manchester::MJet& jet);

  //apply muonsmear

  void doMuonSmear(std::vector<manchester::MMuon>* muons, MEventTool* event);
  void correctElectrons(MEventTool* event);

  // Cuts
  double m_muonPtCut;
  double m_muonPt03ConeCut;
  double m_muonEt03ConeCut;
  double m_jetPtCut;
  double m_jetLowPtCut;
  double m_emPtCut;
  double m_emEtCone20C1;
  double m_emEtCone20C2;
  double m_jvfCut;
  double m_sv0Cut;

  SmearingClass* m_mcp_muonsmear;
  std::string m_muonsmear_option;
  bool m_apply_muonsmear;
  int m_muonscale_mode;
  
  //Tool to caluculate pileup
  Root::TPileupReweighting* m_tPileUp;

  bool m_realData;

  MultijetJESUncertaintyProvider* m_JES_uncertainty_tool;
  int m_JES_uncertainty_flag;

  bool m_create_sumjets;

  //Check that smearing has been done
  bool smeared;


  EnergyRescaler* m_egamma_ERescaler;

  int m_ERescaler_mode; // <0 = off, 0 = default, 1 = +1 sigma, 2 = -1 sigma

  int m_EMSmear_mode; // <0 = off, 0 = default, 1 = +1 sigma, 2 = -1 sigma

  bool m_sortByPt;

  Analysis::CalibrationDataInterfaceROOT* m_sv0_calibTool;

  BTagRandomiser* m_sv0_randtool;

  int m_sv0_rand_flag;

  JERProvider* m_JER_tool;
  int m_JER_flag;
  TRandom3 m_rand_JER; 

  JetEfficiencyEstimator* m_jeteff_tool;
  
  int m_jeteff_flag;

  egammaOQ* m_egammaOQ;
  TRandom3 m_rand_lar;
  double m_frac_lar_problems;
  bool m_simulate_lar_problems;

  MET_Cleaning_Utils* m_met_clean_utils;

};//TopObjectSel


#endif // TOPUTILS_TOPOBJECT_SEL_H__

---