Muon.hh

Go to the documentation of this file.

#ifndef ICHiggsTauTau_Muon_hh
#define ICHiggsTauTau_Muon_hh
#include <map>
#include <string>
#include "Math/Vector4D.h"
#include "Math/Vector4Dfwd.h"
#include "Math/Point3D.h"
#include "Math/Point3Dfwd.h"
#include "UserCode/ICHiggsTauTau/interface/Candidate.hh"
#include "Rtypes.h"

namespace ic {

class Muon : public Candidate {
 private:
  typedef ROOT::Math::XYZPoint Point;
  typedef std::map<std::size_t, float> UFmap;

 public:
  Muon();
  virtual ~Muon();
  virtual void Print() const;




  inline std::vector<std::size_t> const& gen_particles() const {
    return gen_particles_;
  }

  inline Point const& ref_point() const { return ref_point_; }

  inline bool is_standalone() const { return is_standalone_; }

  inline bool is_global() const { return is_global_; }

  inline bool is_tracker() const { return is_tracker_; }

  inline bool is_calo() const { return is_calo_; }

  inline bool is_pf() const { return is_pf_; }

  inline double gt_normalized_chi2() const { return gt_normalized_chi2_; }

  inline float cq_chi2_localposition() const { return cq_chi2_localposition_; }

  inline float cq_trk_kink() const { return cq_trk_kink_; }

  inline int gt_valid_muon_hits() const { return gt_valid_muon_hits_; }

  inline int matched_stations() const { return matched_stations_; }

  inline int it_pixel_hits() const { return it_pixel_hits_; }

  inline int it_tracker_hits() const { return it_tracker_hits_; }

  inline int it_layers_with_measurement() const {
    return it_layers_with_measurement_;
  }

  inline double it_valid_fraction() const { return it_valid_fraction_; }

  inline float segment_compatibility() const { return segment_compatibility_; }

  inline float dr03_tk_sum_pt() const { return dr03_tk_sum_pt_; }

  inline float dr03_ecal_rechit_sum_et() const {
    return dr03_ecal_rechit_sum_et_;
  }

  inline float dr03_hcal_tower_sum_et() const {
    return dr03_hcal_tower_sum_et_;
  }

  inline float dr03_pfiso_charged_all() const {
    return dr03_pfiso_charged_all_;
  }

  inline float dr03_pfiso_charged() const { return dr03_pfiso_charged_; }

  inline float dr03_pfiso_neutral() const { return dr03_pfiso_neutral_; }

  inline float dr03_pfiso_gamma() const { return dr03_pfiso_gamma_; }

  inline float dr03_pfiso_pu() const { return dr03_pfiso_pu_; }

  inline float dr04_pfiso_charged_all() const {
    return dr04_pfiso_charged_all_;
  }

  inline float dr04_pfiso_charged() const { return dr04_pfiso_charged_; }

  inline float dr04_pfiso_neutral() const { return dr04_pfiso_neutral_; }

  inline float dr04_pfiso_gamma() const { return dr04_pfiso_gamma_; }

  inline float dr04_pfiso_pu() const { return dr04_pfiso_pu_; }

  inline double vx() const { return ref_point_.x(); }

  inline double vy() const { return ref_point_.y(); }

  inline double vz() const { return ref_point_.z(); }

  inline double dxy_vertex() const { return dxy_vertex_; }

  inline double dz_vertex() const { return dz_vertex_; }

  inline double dxy_beamspot() const { return dxy_beamspot_; }

  inline void set_gen_particles(std::vector<std::size_t> const& gen_particles) {
    gen_particles_ = gen_particles;
  }

  inline void set_ref_point(Point const& ref_point) { ref_point_ = ref_point; }

  inline void set_is_standalone(bool const& is_standalone) {
    is_standalone_ = is_standalone;
  }

  inline void set_is_global(bool const& is_global) { is_global_ = is_global; }

  inline void set_is_tracker(bool const& is_tracker) {
    is_tracker_ = is_tracker;
  }

  inline void set_is_calo(bool const& is_calo) { is_calo_ = is_calo; }

  inline void set_is_pf(bool const& is_pf) { is_pf_ = is_pf; }

  inline void set_gt_normalized_chi2(double const& gt_normalized_chi2) {
    gt_normalized_chi2_ = gt_normalized_chi2;
  }

  inline void set_cq_chi2_localposition(float const& cq_chi2_localposition) {
    cq_chi2_localposition_ = cq_chi2_localposition;
  }

  inline void set_cq_trk_kink(float const& cq_trk_kink) {
    cq_trk_kink_ = cq_trk_kink;
  }

  inline void set_gt_valid_muon_hits(int const& gt_valid_muon_hits) {
    gt_valid_muon_hits_ = gt_valid_muon_hits;
  }

  inline void set_matched_stations(int const& matched_stations) {
    matched_stations_ = matched_stations;
  }

  inline void set_it_pixel_hits(int const& it_pixel_hits) {
    it_pixel_hits_ = it_pixel_hits;
  }

  inline void set_it_tracker_hits(int const& it_tracker_hits) {
    it_tracker_hits_ = it_tracker_hits;
  }

  inline void set_it_layers_with_measurement(
      int const& it_layers_with_measurement) {
    it_layers_with_measurement_ = it_layers_with_measurement;
  }

  inline void set_it_valid_fraction(double const& it_valid_fraction) {
    it_valid_fraction_ = it_valid_fraction;
  }

  inline void set_segment_compatibility(float const& segment_compatibility) {
    segment_compatibility_ = segment_compatibility;
  }

  inline void set_dr03_tk_sum_pt(float const& dr03_tk_sum_pt) {
    dr03_tk_sum_pt_ = dr03_tk_sum_pt;
  }

  inline void set_dr03_ecal_rechit_sum_et(
      float const& dr03_ecal_rechit_sum_et) {
    dr03_ecal_rechit_sum_et_ = dr03_ecal_rechit_sum_et;
  }

  inline void set_dr03_hcal_tower_sum_et(float const& dr03_hcal_tower_sum_et) {
    dr03_hcal_tower_sum_et_ = dr03_hcal_tower_sum_et;
  }

  inline void set_dr03_pfiso_charged_all(float const& dr03_pfiso_charged_all) {
    dr03_pfiso_charged_all_ = dr03_pfiso_charged_all;
  }

  inline void set_dr03_pfiso_charged(float const& dr03_pfiso_charged) {
    dr03_pfiso_charged_ = dr03_pfiso_charged;
  }

  inline void set_dr03_pfiso_neutral(float const& dr03_pfiso_neutral) {
    dr03_pfiso_neutral_ = dr03_pfiso_neutral;
  }

  inline void set_dr03_pfiso_gamma(float const& dr03_pfiso_gamma) {
    dr03_pfiso_gamma_ = dr03_pfiso_gamma;
  }

  inline void set_dr03_pfiso_pu(float const& dr03_pfiso_pu) {
    dr03_pfiso_pu_ = dr03_pfiso_pu;
  }

  inline void set_dr04_pfiso_charged_all(float const& dr04_pfiso_charged_all) {
    dr04_pfiso_charged_all_ = dr04_pfiso_charged_all;
  }

  inline void set_dr04_pfiso_charged(float const& dr04_pfiso_charged) {
    dr04_pfiso_charged_ = dr04_pfiso_charged;
  }

  inline void set_dr04_pfiso_neutral(float const& dr04_pfiso_neutral) {
    dr04_pfiso_neutral_ = dr04_pfiso_neutral;
  }

  inline void set_dr04_pfiso_gamma(float const& dr04_pfiso_gamma) {
    dr04_pfiso_gamma_ = dr04_pfiso_gamma;
  }

  inline void set_dr04_pfiso_pu(float const& dr04_pfiso_pu) {
    dr04_pfiso_pu_ = dr04_pfiso_pu;
  }

  inline void set_vx(double const& x) { ref_point_.SetX(x); }

  inline void set_vy(double const& y) { ref_point_.SetY(y); }

  inline void set_vz(double const& z) { ref_point_.SetZ(z); }

  inline void set_dxy_vertex(double const& dxy_vertex) {
    dxy_vertex_ = dxy_vertex;
  }

  inline void set_dz_vertex(double const& dz_vertex) { dz_vertex_ = dz_vertex; }

  inline void set_dxy_beamspot(double const& dxy_beamspot) {
    dxy_beamspot_ = dxy_beamspot;
  }
  void SetIdIso(std::string const& name, float const& value);
  bool HasIdIso(std::string const& name) const;
  float GetIdIso(std::string const& name) const;
 private:
  float dr03_tk_sum_pt_;
  float dr03_ecal_rechit_sum_et_;
  float dr03_hcal_tower_sum_et_;

  float dr03_pfiso_charged_all_;
  float dr03_pfiso_charged_;
  float dr03_pfiso_neutral_;
  float dr03_pfiso_gamma_;
  float dr03_pfiso_pu_;
  float dr04_pfiso_charged_all_;
  float dr04_pfiso_charged_;
  float dr04_pfiso_neutral_;
  float dr04_pfiso_gamma_;
  float dr04_pfiso_pu_;

  bool is_standalone_;
  bool is_global_;
  bool is_tracker_;
  bool is_calo_;
  bool is_pf_;
  double gt_normalized_chi2_;
  float cq_chi2_localposition_;
  float cq_trk_kink_;
  int gt_valid_muon_hits_;
  int matched_stations_;
  int it_pixel_hits_;
  int it_tracker_hits_;
  int it_layers_with_measurement_;
  double it_valid_fraction_;
  float segment_compatibility_;

  Point ref_point_;

  double dxy_vertex_;
  double dz_vertex_;
  double dxy_beamspot_;

  std::vector<std::size_t> gen_particles_;

  UFmap muon_idiso_;

 #ifndef SKIP_CINT_DICT
 public:
  ClassDef(Muon, 5);
 #endif
};

typedef std::vector<ic::Muon> MuonCollection;
}
#endif