TMBTrackCalJet.hpp

Go to the documentation of this file.

#ifndef TMBTrackCalJet_H
#define TMBTrackCalJet_H

#include "tmb_tree/TMBLorentzVector.hpp"

#include "tmb_tree/TMBTrackCal.hpp"
#include "tmb_tree/TMBTrack.hpp"
#include "tmb_tree/TMBJet.hpp"
#include "kinem_util/AnglesUtil.hpp"

#ifndef ROOT_TRef
#include "TRef.h"
#endif

#ifndef ROOT_TRefArray
#include "TRefArray.h"
#endif

#ifndef ROOT_TLorentzVector
#include "TLorentzVector.h"
#endif

#include <vector>
#include <iostream>



class TMBTrackCalJet : public TMBLorentzVector {

 private:

  float _q;
  
  float _Corr, _Cin, _Cout, _Csub;
  std::vector<float> _Efraction;
  std::vector<int>   _Ncells;

  TRef _jet;
  TRefArray _trackCalList;
  

 public:

  TMBTrackCalJet();
  TMBTrackCalJet(TRef jet, TRefArray* trackCalList, 
                 Float_t C, Float_t Cin, Float_t Cout, Float_t Csub, 
                 std::vector<Float_t> Efraction, std::vector<Int_t> Ncells);
  virtual ~TMBTrackCalJet();
  
  
  TMBJet* GetJet() const {
    return _jet.IsValid() ? (TMBJet*)_jet.GetObject() : 0;
  }

  TMBTrackCal* GetTrackCal(Int_t itrack) const {
    return (TMBTrackCal*)_trackCalList.At(itrack);
  }
  

  Float_t GetC() const { return _Corr; }
  Float_t GetCin() const { return _Cin; }
  Float_t GetCout() const { return _Cout; }
  Float_t GetCsub() const { return _Csub; }

  Float_t GetEfraction(Int_t itrack) const {
    return _Efraction[itrack];
  }
  Int_t GetNcells(Int_t itrack) const {
    return _Ncells[itrack];
  }
 
  Int_t GetTrackMultiplicity() const {
    return _trackCalList.GetLast()+1;
  }


  // Methods
  //----------------------------------------
  Float_t GetDR(Int_t itrack) const {

    TMBTrackCal* trkcal = (TMBTrackCal*) _trackCalList.At(itrack);
    TMBTrack* trk = (TMBTrack*) trkcal->GetChargedTrack();
    TMBJet* jet = _jet.IsValid() ? (TMBJet*) _jet.GetObject() : 0;
    return jet->DeltaR(*trk);
  }

  Float_t GetDR(Int_t itrack, Int_t layer) const {
    
    if(layer>17 || layer<1) return -1.0;

    TMBJet* jet = _jet.IsValid() ? (TMBJet*) _jet.GetObject() : 0;
    float jdeta = 0.1 * jet->detEta();
    float jdphi = (jet->detPhi() + 0.05) / 64.0 * 2.0 * kinem::PI;

    TMBTrackCal* trkcal = (TMBTrackCal*) _trackCalList.At(itrack);
    Float_t trk_eta, trk_phi;
    trkcal->getCalEtaPhi(layer, trk_eta, trk_phi);
    
    double deta = jdeta-trk_eta;
    double dphi = kinem::delta_phi(jdphi,trk_phi);
    double dr = sqrt(deta*deta + dphi*dphi);

    return dr;
  }

  /*
  void MatchTracks(float& Ein, int& ntrkin, 
                   float& Eout, int& ntrkout, 
                   float track_cone_size = 0.7,
                   float ptMin = 0.5, float ptMax = 25, 
                   float dcaRmax = 0.25, float dcaZmax = 0.5,
                   int cftMin = 7, int smtMin = 0);
  */


  Float_t        charge()      const     {return _q;}
 
  void print(std::ostream& os) const;

    
  ClassDef(TMBTrackCalJet, 3);   //TMBTrackCalJet
};

#endif // TMBTrackCalJet

---