TMBBTag.hpp

Go to the documentation of this file.

#ifndef TMB_TREE_TMBBTAG_HPP__
#define TMB_TREE_TMBBTAG_HPP__

#include "TRef.h"
#include "TRefArray.h"

class TMBJet;
class TMBMuon;
class TMBTrack;

//          Base class for b-tagging branches.  There is one instance
//          of this class (and its subclass, if any), for each 
//          reconstructed jet.  This class can exist in several branches,
//          with different branches having differences with respect to
//          any of the following:
//
//          a) Jet reconstruction algorithm (JCCA, JCCB, etc.)
//          b) Jet correction algorithm (uncorrected, JES, muon, etc.)
//          c) B-tagging algorithm (SVT, JLIP, CSIP, etc.).
//          d) B-tagging operating point (LOOSE, MEDIUM, TIGHT, etc.).
//
//          It is expected that specific b-tagging algorithms will
//          derive subclasses with this class as a base class, for the
//          purpose of adding attributes or overriding the TRF
//          methods.  However, this is not required.  It is
//          permissible to instantiate TMBBTag concretely and save it
//          in a tree branch by itself.
//
// Created: 25-Jan-2005   H. Greenlee
//
// \ingroup bid

class TMBBTag : public TObject {

 private:
  
  Bool_t _taggable;      // Taggable flag.
  Bool_t _tagged;        // Tag decision (positive).
  Bool_t _neg_tagged;    // Tag decision (negative).

  // The MC info
  Double_t _trf_data;    // The prob of tagging this guy in data.
  Double_t _trf_data_err;// The abosolute error on the above.
  Double_t _trf_mc;      // The prob of tagging this guy in MC.
  Double_t _trf_sf;      // The scale factor to re-weight this tag from MC to data.
  Int_t _mc_flavor;      // Jet flavor: -1 = Unknown (data). 0 = Light. 4 = C. 5 = B.

  // Associations.
  TRef _jet;             // Reconstructed jet (TMBJet).
  TRef _muon;            // Associated muon (TMBMuon).
  int _num_tracks;       // Number of positive-tag tracks.
  int _num_neg_tracks;   // Number of negative-tag tracks.
  TRefArray _tracks;     // Tracks used by b-tagging algorithm.
  TRefArray _neg_tracks; // Tracks used by negative b-tagging algorithm.

  // A cross-check
  TString _algo;
  TString _trackbranch, _muonbranch, _jetbranch;
  int _id;

 public:
  
  // Constructors, destructor.
  TMBBTag();
  //TMBBTag(const TMBBTag& btag);
  TMBBTag(Bool_t taggable,
          Bool_t tagged,
          Bool_t neg_tagged,
          Int_t mc_flavor,
          const TMBJet* jet,
          const TMBMuon* muon,
          const TRefArray* tracks,
          const TRefArray* neg_tracks);
  
  virtual ~TMBBTag();

  Bool_t is_taggable() const {return _taggable;}
  Bool_t is_tagged() const {return _tagged;}
  Bool_t is_neg_tagged() const {return _neg_tagged;}
  Int_t mc_flavor() const {return _mc_flavor;}
  bool print() const;
  TString GetAlgo() const {return _algo;}
  void SetAlgo(const char* algo){_algo=algo;}
  void SetBranches(const char* jet, const char* muon, const char* track){
    _jetbranch=jet; _muonbranch=muon; _trackbranch=track;
  }
  int GetId() const {return _id;}
  void SetId(int id) {_id=id;}

  const TMBJet* GetJet() const;
  //const TRef& GetJetRef() const {return _jet;}

  const TMBMuon* GetMuon() const;
  //const TRef& GetMuonRef() const {return _muon;}

  int num_tracks() const {return _num_tracks;}
  int num_neg_tracks() const {return _num_neg_tracks;}
  //const TRefArray& tracks() const {return _tracks;}
  //const TRefArray& neg_tracks() const {return _neg_tracks;}

  const TMBTrack *track(int i) const { return (const TMBTrack *)_tracks.At(i); }
  const TMBTrack *neg_track(int i) const { return (const TMBTrack *)_neg_tracks.At(i); }

  //TRF methods. For data (or when not filled) these will return zero.
  inline Double_t data_trf() const {return _trf_data;}
  inline Double_t mc_trf() const {return _trf_mc;}
  inline Double_t scale_factor() const {return _trf_sf;}

  //Methods used to set various TRF related values after the object has been created.
  inline void set_data_trf (double val, double err);
  inline void set_mc_flavor (int value);
  
  ClassDef(TMBBTag, 5);
};

void TMBBTag::set_data_trf (double val, double err)
{
  _trf_data = val;
  _trf_data_err = err;
}

void TMBBTag::set_mc_flavor (int value)
{
  _mc_flavor = value;
}
#endif

---